Linux Audio

Check our new training course

Loading...
v6.8
   1// SPDX-License-Identifier: GPL-2.0-or-later
   2//
   3// core.c  --  Voltage/Current Regulator framework.
   4//
   5// Copyright 2007, 2008 Wolfson Microelectronics PLC.
   6// Copyright 2008 SlimLogic Ltd.
   7//
   8// Author: Liam Girdwood <lrg@slimlogic.co.uk>
 
 
 
 
 
 
 
 
   9
  10#include <linux/kernel.h>
  11#include <linux/init.h>
  12#include <linux/debugfs.h>
  13#include <linux/device.h>
  14#include <linux/slab.h>
  15#include <linux/async.h>
  16#include <linux/err.h>
  17#include <linux/mutex.h>
  18#include <linux/suspend.h>
  19#include <linux/delay.h>
  20#include <linux/gpio/consumer.h>
  21#include <linux/of.h>
  22#include <linux/reboot.h>
  23#include <linux/regmap.h>
  24#include <linux/regulator/of_regulator.h>
  25#include <linux/regulator/consumer.h>
  26#include <linux/regulator/coupler.h>
  27#include <linux/regulator/driver.h>
  28#include <linux/regulator/machine.h>
  29#include <linux/module.h>
  30
  31#define CREATE_TRACE_POINTS
  32#include <trace/events/regulator.h>
  33
  34#include "dummy.h"
  35#include "internal.h"
  36#include "regnl.h"
  37
  38static DEFINE_WW_CLASS(regulator_ww_class);
  39static DEFINE_MUTEX(regulator_nesting_mutex);
 
 
 
 
 
 
 
 
 
  40static DEFINE_MUTEX(regulator_list_mutex);
 
  41static LIST_HEAD(regulator_map_list);
  42static LIST_HEAD(regulator_ena_gpio_list);
  43static LIST_HEAD(regulator_supply_alias_list);
  44static LIST_HEAD(regulator_coupler_list);
  45static bool has_full_constraints;
 
  46
 
  47static struct dentry *debugfs_root;
 
  48
  49/*
  50 * struct regulator_map
  51 *
  52 * Used to provide symbolic supply names to devices.
  53 */
  54struct regulator_map {
  55	struct list_head list;
  56	const char *dev_name;   /* The dev_name() for the consumer */
  57	const char *supply;
  58	struct regulator_dev *regulator;
  59};
  60
  61/*
  62 * struct regulator_enable_gpio
  63 *
  64 * Management for shared enable GPIO pin
  65 */
  66struct regulator_enable_gpio {
  67	struct list_head list;
  68	struct gpio_desc *gpiod;
  69	u32 enable_count;	/* a number of enabled shared GPIO */
  70	u32 request_count;	/* a number of requested shared GPIO */
  71};
  72
  73/*
  74 * struct regulator_supply_alias
  75 *
  76 * Used to map lookups for a supply onto an alternative device.
  77 */
  78struct regulator_supply_alias {
 
  79	struct list_head list;
  80	struct device *src_dev;
  81	const char *src_supply;
  82	struct device *alias_dev;
  83	const char *alias_supply;
 
 
 
 
 
  84};
  85
  86static int _regulator_is_enabled(struct regulator_dev *rdev);
  87static int _regulator_disable(struct regulator *regulator);
  88static int _regulator_get_error_flags(struct regulator_dev *rdev, unsigned int *flags);
  89static int _regulator_get_current_limit(struct regulator_dev *rdev);
  90static unsigned int _regulator_get_mode(struct regulator_dev *rdev);
  91static int _notifier_call_chain(struct regulator_dev *rdev,
  92				  unsigned long event, void *data);
  93static int _regulator_do_set_voltage(struct regulator_dev *rdev,
  94				     int min_uV, int max_uV);
  95static int regulator_balance_voltage(struct regulator_dev *rdev,
  96				     suspend_state_t state);
  97static struct regulator *create_regulator(struct regulator_dev *rdev,
  98					  struct device *dev,
  99					  const char *supply_name);
 100static void destroy_regulator(struct regulator *regulator);
 101static void _regulator_put(struct regulator *regulator);
 102
 103const char *rdev_get_name(struct regulator_dev *rdev)
 104{
 105	if (rdev->constraints && rdev->constraints->name)
 106		return rdev->constraints->name;
 107	else if (rdev->desc->name)
 108		return rdev->desc->name;
 109	else
 110		return "";
 111}
 112EXPORT_SYMBOL_GPL(rdev_get_name);
 113
 114static bool have_full_constraints(void)
 
 115{
 116	return has_full_constraints || of_have_populated_dt();
 117}
 118
 119static bool regulator_ops_is_valid(struct regulator_dev *rdev, int ops)
 120{
 121	if (!rdev->constraints) {
 122		rdev_err(rdev, "no constraints\n");
 123		return false;
 124	}
 125
 126	if (rdev->constraints->valid_ops_mask & ops)
 127		return true;
 128
 129	return false;
 130}
 131
 132/**
 133 * regulator_lock_nested - lock a single regulator
 134 * @rdev:		regulator source
 135 * @ww_ctx:		w/w mutex acquire context
 136 *
 137 * This function can be called many times by one task on
 138 * a single regulator and its mutex will be locked only
 139 * once. If a task, which is calling this function is other
 140 * than the one, which initially locked the mutex, it will
 141 * wait on mutex.
 142 */
 143static inline int regulator_lock_nested(struct regulator_dev *rdev,
 144					struct ww_acquire_ctx *ww_ctx)
 145{
 146	bool lock = false;
 147	int ret = 0;
 148
 149	mutex_lock(&regulator_nesting_mutex);
 150
 151	if (!ww_mutex_trylock(&rdev->mutex, ww_ctx)) {
 152		if (rdev->mutex_owner == current)
 153			rdev->ref_cnt++;
 154		else
 155			lock = true;
 156
 157		if (lock) {
 158			mutex_unlock(&regulator_nesting_mutex);
 159			ret = ww_mutex_lock(&rdev->mutex, ww_ctx);
 160			mutex_lock(&regulator_nesting_mutex);
 161		}
 162	} else {
 163		lock = true;
 164	}
 165
 166	if (lock && ret != -EDEADLK) {
 167		rdev->ref_cnt++;
 168		rdev->mutex_owner = current;
 169	}
 170
 171	mutex_unlock(&regulator_nesting_mutex);
 172
 173	return ret;
 174}
 175
 176/**
 177 * regulator_lock - lock a single regulator
 178 * @rdev:		regulator source
 179 *
 180 * This function can be called many times by one task on
 181 * a single regulator and its mutex will be locked only
 182 * once. If a task, which is calling this function is other
 183 * than the one, which initially locked the mutex, it will
 184 * wait on mutex.
 185 */
 186static void regulator_lock(struct regulator_dev *rdev)
 187{
 188	regulator_lock_nested(rdev, NULL);
 189}
 190
 191/**
 192 * regulator_unlock - unlock a single regulator
 193 * @rdev:		regulator_source
 194 *
 195 * This function unlocks the mutex when the
 196 * reference counter reaches 0.
 197 */
 198static void regulator_unlock(struct regulator_dev *rdev)
 199{
 200	mutex_lock(&regulator_nesting_mutex);
 201
 202	if (--rdev->ref_cnt == 0) {
 203		rdev->mutex_owner = NULL;
 204		ww_mutex_unlock(&rdev->mutex);
 205	}
 206
 207	WARN_ON_ONCE(rdev->ref_cnt < 0);
 208
 209	mutex_unlock(&regulator_nesting_mutex);
 210}
 211
 212/**
 213 * regulator_lock_two - lock two regulators
 214 * @rdev1:		first regulator
 215 * @rdev2:		second regulator
 216 * @ww_ctx:		w/w mutex acquire context
 217 *
 218 * Locks both rdevs using the regulator_ww_class.
 219 */
 220static void regulator_lock_two(struct regulator_dev *rdev1,
 221			       struct regulator_dev *rdev2,
 222			       struct ww_acquire_ctx *ww_ctx)
 223{
 224	struct regulator_dev *held, *contended;
 225	int ret;
 226
 227	ww_acquire_init(ww_ctx, &regulator_ww_class);
 228
 229	/* Try to just grab both of them */
 230	ret = regulator_lock_nested(rdev1, ww_ctx);
 231	WARN_ON(ret);
 232	ret = regulator_lock_nested(rdev2, ww_ctx);
 233	if (ret != -EDEADLOCK) {
 234		WARN_ON(ret);
 235		goto exit;
 236	}
 237
 238	held = rdev1;
 239	contended = rdev2;
 240	while (true) {
 241		regulator_unlock(held);
 242
 243		ww_mutex_lock_slow(&contended->mutex, ww_ctx);
 244		contended->ref_cnt++;
 245		contended->mutex_owner = current;
 246		swap(held, contended);
 247		ret = regulator_lock_nested(contended, ww_ctx);
 248
 249		if (ret != -EDEADLOCK) {
 250			WARN_ON(ret);
 251			break;
 252		}
 253	}
 254
 255exit:
 256	ww_acquire_done(ww_ctx);
 257}
 258
 259/**
 260 * regulator_unlock_two - unlock two regulators
 261 * @rdev1:		first regulator
 262 * @rdev2:		second regulator
 263 * @ww_ctx:		w/w mutex acquire context
 264 *
 265 * The inverse of regulator_lock_two().
 266 */
 267
 268static void regulator_unlock_two(struct regulator_dev *rdev1,
 269				 struct regulator_dev *rdev2,
 270				 struct ww_acquire_ctx *ww_ctx)
 271{
 272	regulator_unlock(rdev2);
 273	regulator_unlock(rdev1);
 274	ww_acquire_fini(ww_ctx);
 275}
 276
 277static bool regulator_supply_is_couple(struct regulator_dev *rdev)
 278{
 279	struct regulator_dev *c_rdev;
 280	int i;
 281
 282	for (i = 1; i < rdev->coupling_desc.n_coupled; i++) {
 283		c_rdev = rdev->coupling_desc.coupled_rdevs[i];
 284
 285		if (rdev->supply->rdev == c_rdev)
 286			return true;
 287	}
 288
 289	return false;
 290}
 291
 292static void regulator_unlock_recursive(struct regulator_dev *rdev,
 293				       unsigned int n_coupled)
 294{
 295	struct regulator_dev *c_rdev, *supply_rdev;
 296	int i, supply_n_coupled;
 297
 298	for (i = n_coupled; i > 0; i--) {
 299		c_rdev = rdev->coupling_desc.coupled_rdevs[i - 1];
 300
 301		if (!c_rdev)
 302			continue;
 303
 304		if (c_rdev->supply && !regulator_supply_is_couple(c_rdev)) {
 305			supply_rdev = c_rdev->supply->rdev;
 306			supply_n_coupled = supply_rdev->coupling_desc.n_coupled;
 307
 308			regulator_unlock_recursive(supply_rdev,
 309						   supply_n_coupled);
 310		}
 311
 312		regulator_unlock(c_rdev);
 313	}
 314}
 315
 316static int regulator_lock_recursive(struct regulator_dev *rdev,
 317				    struct regulator_dev **new_contended_rdev,
 318				    struct regulator_dev **old_contended_rdev,
 319				    struct ww_acquire_ctx *ww_ctx)
 320{
 321	struct regulator_dev *c_rdev;
 322	int i, err;
 323
 324	for (i = 0; i < rdev->coupling_desc.n_coupled; i++) {
 325		c_rdev = rdev->coupling_desc.coupled_rdevs[i];
 326
 327		if (!c_rdev)
 328			continue;
 329
 330		if (c_rdev != *old_contended_rdev) {
 331			err = regulator_lock_nested(c_rdev, ww_ctx);
 332			if (err) {
 333				if (err == -EDEADLK) {
 334					*new_contended_rdev = c_rdev;
 335					goto err_unlock;
 336				}
 337
 338				/* shouldn't happen */
 339				WARN_ON_ONCE(err != -EALREADY);
 340			}
 341		} else {
 342			*old_contended_rdev = NULL;
 343		}
 344
 345		if (c_rdev->supply && !regulator_supply_is_couple(c_rdev)) {
 346			err = regulator_lock_recursive(c_rdev->supply->rdev,
 347						       new_contended_rdev,
 348						       old_contended_rdev,
 349						       ww_ctx);
 350			if (err) {
 351				regulator_unlock(c_rdev);
 352				goto err_unlock;
 353			}
 354		}
 
 355	}
 356
 357	return 0;
 358
 359err_unlock:
 360	regulator_unlock_recursive(rdev, i);
 361
 362	return err;
 363}
 364
 365/**
 366 * regulator_unlock_dependent - unlock regulator's suppliers and coupled
 367 *				regulators
 368 * @rdev:			regulator source
 369 * @ww_ctx:			w/w mutex acquire context
 370 *
 371 * Unlock all regulators related with rdev by coupling or supplying.
 372 */
 373static void regulator_unlock_dependent(struct regulator_dev *rdev,
 374				       struct ww_acquire_ctx *ww_ctx)
 375{
 376	regulator_unlock_recursive(rdev, rdev->coupling_desc.n_coupled);
 377	ww_acquire_fini(ww_ctx);
 378}
 379
 380/**
 381 * regulator_lock_dependent - lock regulator's suppliers and coupled regulators
 382 * @rdev:			regulator source
 383 * @ww_ctx:			w/w mutex acquire context
 384 *
 385 * This function as a wrapper on regulator_lock_recursive(), which locks
 386 * all regulators related with rdev by coupling or supplying.
 387 */
 388static void regulator_lock_dependent(struct regulator_dev *rdev,
 389				     struct ww_acquire_ctx *ww_ctx)
 390{
 391	struct regulator_dev *new_contended_rdev = NULL;
 392	struct regulator_dev *old_contended_rdev = NULL;
 393	int err;
 394
 395	mutex_lock(&regulator_list_mutex);
 396
 397	ww_acquire_init(ww_ctx, &regulator_ww_class);
 398
 399	do {
 400		if (new_contended_rdev) {
 401			ww_mutex_lock_slow(&new_contended_rdev->mutex, ww_ctx);
 402			old_contended_rdev = new_contended_rdev;
 403			old_contended_rdev->ref_cnt++;
 404			old_contended_rdev->mutex_owner = current;
 405		}
 406
 407		err = regulator_lock_recursive(rdev,
 408					       &new_contended_rdev,
 409					       &old_contended_rdev,
 410					       ww_ctx);
 411
 412		if (old_contended_rdev)
 413			regulator_unlock(old_contended_rdev);
 414
 415	} while (err == -EDEADLK);
 416
 417	ww_acquire_done(ww_ctx);
 418
 419	mutex_unlock(&regulator_list_mutex);
 420}
 421
 422/**
 423 * of_get_child_regulator - get a child regulator device node
 424 * based on supply name
 425 * @parent: Parent device node
 426 * @prop_name: Combination regulator supply name and "-supply"
 427 *
 428 * Traverse all child nodes.
 429 * Extract the child regulator device node corresponding to the supply name.
 430 * returns the device node corresponding to the regulator if found, else
 431 * returns NULL.
 432 */
 433static struct device_node *of_get_child_regulator(struct device_node *parent,
 434						  const char *prop_name)
 435{
 436	struct device_node *regnode = NULL;
 437	struct device_node *child = NULL;
 438
 439	for_each_child_of_node(parent, child) {
 440		regnode = of_parse_phandle(child, prop_name, 0);
 441
 442		if (!regnode) {
 443			regnode = of_get_child_regulator(child, prop_name);
 444			if (regnode)
 445				goto err_node_put;
 446		} else {
 447			goto err_node_put;
 448		}
 449	}
 450	return NULL;
 451
 452err_node_put:
 453	of_node_put(child);
 454	return regnode;
 455}
 456
 457/**
 458 * of_get_regulator - get a regulator device node based on supply name
 459 * @dev: Device pointer for the consumer (of regulator) device
 460 * @supply: regulator supply name
 461 *
 462 * Extract the regulator device node corresponding to the supply name.
 463 * returns the device node corresponding to the regulator if found, else
 464 * returns NULL.
 465 */
 466static struct device_node *of_get_regulator(struct device *dev, const char *supply)
 467{
 468	struct device_node *regnode = NULL;
 469	char prop_name[64]; /* 64 is max size of property name */
 470
 471	dev_dbg(dev, "Looking up %s-supply from device tree\n", supply);
 472
 473	snprintf(prop_name, 64, "%s-supply", supply);
 474	regnode = of_parse_phandle(dev->of_node, prop_name, 0);
 475
 476	if (!regnode) {
 477		regnode = of_get_child_regulator(dev->of_node, prop_name);
 478		if (regnode)
 479			return regnode;
 480
 481		dev_dbg(dev, "Looking up %s property in node %pOF failed\n",
 482				prop_name, dev->of_node);
 483		return NULL;
 484	}
 485	return regnode;
 486}
 487
 488/* Platform voltage constraint check */
 489int regulator_check_voltage(struct regulator_dev *rdev,
 490			    int *min_uV, int *max_uV)
 491{
 492	BUG_ON(*min_uV > *max_uV);
 493
 494	if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_VOLTAGE)) {
 495		rdev_err(rdev, "voltage operation not allowed\n");
 
 
 
 
 496		return -EPERM;
 497	}
 498
 499	if (*max_uV > rdev->constraints->max_uV)
 500		*max_uV = rdev->constraints->max_uV;
 501	if (*min_uV < rdev->constraints->min_uV)
 502		*min_uV = rdev->constraints->min_uV;
 503
 504	if (*min_uV > *max_uV) {
 505		rdev_err(rdev, "unsupportable voltage range: %d-%duV\n",
 506			 *min_uV, *max_uV);
 507		return -EINVAL;
 508	}
 509
 510	return 0;
 511}
 512
 513/* return 0 if the state is valid */
 514static int regulator_check_states(suspend_state_t state)
 515{
 516	return (state > PM_SUSPEND_MAX || state == PM_SUSPEND_TO_IDLE);
 517}
 518
 519/* Make sure we select a voltage that suits the needs of all
 520 * regulator consumers
 521 */
 522int regulator_check_consumers(struct regulator_dev *rdev,
 523			      int *min_uV, int *max_uV,
 524			      suspend_state_t state)
 525{
 526	struct regulator *regulator;
 527	struct regulator_voltage *voltage;
 528
 529	list_for_each_entry(regulator, &rdev->consumer_list, list) {
 530		voltage = &regulator->voltage[state];
 531		/*
 532		 * Assume consumers that didn't say anything are OK
 533		 * with anything in the constraint range.
 534		 */
 535		if (!voltage->min_uV && !voltage->max_uV)
 536			continue;
 537
 538		if (*max_uV > voltage->max_uV)
 539			*max_uV = voltage->max_uV;
 540		if (*min_uV < voltage->min_uV)
 541			*min_uV = voltage->min_uV;
 542	}
 543
 544	if (*min_uV > *max_uV) {
 545		rdev_err(rdev, "Restricting voltage, %u-%uuV\n",
 546			*min_uV, *max_uV);
 547		return -EINVAL;
 548	}
 549
 550	return 0;
 551}
 552
 553/* current constraint check */
 554static int regulator_check_current_limit(struct regulator_dev *rdev,
 555					int *min_uA, int *max_uA)
 556{
 557	BUG_ON(*min_uA > *max_uA);
 558
 559	if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_CURRENT)) {
 560		rdev_err(rdev, "current operation not allowed\n");
 
 
 
 
 561		return -EPERM;
 562	}
 563
 564	if (*max_uA > rdev->constraints->max_uA)
 565		*max_uA = rdev->constraints->max_uA;
 566	if (*min_uA < rdev->constraints->min_uA)
 567		*min_uA = rdev->constraints->min_uA;
 568
 569	if (*min_uA > *max_uA) {
 570		rdev_err(rdev, "unsupportable current range: %d-%duA\n",
 571			 *min_uA, *max_uA);
 572		return -EINVAL;
 573	}
 574
 575	return 0;
 576}
 577
 578/* operating mode constraint check */
 579static int regulator_mode_constrain(struct regulator_dev *rdev,
 580				    unsigned int *mode)
 581{
 582	switch (*mode) {
 583	case REGULATOR_MODE_FAST:
 584	case REGULATOR_MODE_NORMAL:
 585	case REGULATOR_MODE_IDLE:
 586	case REGULATOR_MODE_STANDBY:
 587		break;
 588	default:
 589		rdev_err(rdev, "invalid mode %x specified\n", *mode);
 590		return -EINVAL;
 591	}
 592
 593	if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_MODE)) {
 594		rdev_err(rdev, "mode operation not allowed\n");
 
 
 
 
 595		return -EPERM;
 596	}
 597
 598	/* The modes are bitmasks, the most power hungry modes having
 599	 * the lowest values. If the requested mode isn't supported
 600	 * try higher modes.
 601	 */
 602	while (*mode) {
 603		if (rdev->constraints->valid_modes_mask & *mode)
 604			return 0;
 605		*mode /= 2;
 606	}
 607
 608	return -EINVAL;
 609}
 610
 611static inline struct regulator_state *
 612regulator_get_suspend_state(struct regulator_dev *rdev, suspend_state_t state)
 613{
 614	if (rdev->constraints == NULL)
 615		return NULL;
 616
 617	switch (state) {
 618	case PM_SUSPEND_STANDBY:
 619		return &rdev->constraints->state_standby;
 620	case PM_SUSPEND_MEM:
 621		return &rdev->constraints->state_mem;
 622	case PM_SUSPEND_MAX:
 623		return &rdev->constraints->state_disk;
 624	default:
 625		return NULL;
 626	}
 
 627}
 628
 629static const struct regulator_state *
 630regulator_get_suspend_state_check(struct regulator_dev *rdev, suspend_state_t state)
 631{
 632	const struct regulator_state *rstate;
 633
 634	rstate = regulator_get_suspend_state(rdev, state);
 635	if (rstate == NULL)
 636		return NULL;
 637
 638	/* If we have no suspend mode configuration don't set anything;
 639	 * only warn if the driver implements set_suspend_voltage or
 640	 * set_suspend_mode callback.
 641	 */
 642	if (rstate->enabled != ENABLE_IN_SUSPEND &&
 643	    rstate->enabled != DISABLE_IN_SUSPEND) {
 644		if (rdev->desc->ops->set_suspend_voltage ||
 645		    rdev->desc->ops->set_suspend_mode)
 646			rdev_warn(rdev, "No configuration\n");
 647		return NULL;
 648	}
 649
 650	return rstate;
 651}
 652
 653static ssize_t microvolts_show(struct device *dev,
 654			       struct device_attribute *attr, char *buf)
 655{
 656	struct regulator_dev *rdev = dev_get_drvdata(dev);
 657	int uV;
 658
 659	regulator_lock(rdev);
 660	uV = regulator_get_voltage_rdev(rdev);
 661	regulator_unlock(rdev);
 662
 663	if (uV < 0)
 664		return uV;
 665	return sprintf(buf, "%d\n", uV);
 666}
 667static DEVICE_ATTR_RO(microvolts);
 668
 669static ssize_t microamps_show(struct device *dev,
 670			      struct device_attribute *attr, char *buf)
 671{
 672	struct regulator_dev *rdev = dev_get_drvdata(dev);
 673
 674	return sprintf(buf, "%d\n", _regulator_get_current_limit(rdev));
 675}
 676static DEVICE_ATTR_RO(microamps);
 677
 678static ssize_t name_show(struct device *dev, struct device_attribute *attr,
 679			 char *buf)
 680{
 681	struct regulator_dev *rdev = dev_get_drvdata(dev);
 682
 683	return sprintf(buf, "%s\n", rdev_get_name(rdev));
 684}
 685static DEVICE_ATTR_RO(name);
 686
 687static const char *regulator_opmode_to_str(int mode)
 688{
 689	switch (mode) {
 690	case REGULATOR_MODE_FAST:
 691		return "fast";
 692	case REGULATOR_MODE_NORMAL:
 693		return "normal";
 694	case REGULATOR_MODE_IDLE:
 695		return "idle";
 696	case REGULATOR_MODE_STANDBY:
 697		return "standby";
 698	}
 699	return "unknown";
 700}
 701
 702static ssize_t regulator_print_opmode(char *buf, int mode)
 703{
 704	return sprintf(buf, "%s\n", regulator_opmode_to_str(mode));
 705}
 706
 707static ssize_t opmode_show(struct device *dev,
 708			   struct device_attribute *attr, char *buf)
 709{
 710	struct regulator_dev *rdev = dev_get_drvdata(dev);
 711
 712	return regulator_print_opmode(buf, _regulator_get_mode(rdev));
 713}
 714static DEVICE_ATTR_RO(opmode);
 715
 716static ssize_t regulator_print_state(char *buf, int state)
 717{
 718	if (state > 0)
 719		return sprintf(buf, "enabled\n");
 720	else if (state == 0)
 721		return sprintf(buf, "disabled\n");
 722	else
 723		return sprintf(buf, "unknown\n");
 724}
 725
 726static ssize_t state_show(struct device *dev,
 727			  struct device_attribute *attr, char *buf)
 728{
 729	struct regulator_dev *rdev = dev_get_drvdata(dev);
 730	ssize_t ret;
 731
 732	regulator_lock(rdev);
 733	ret = regulator_print_state(buf, _regulator_is_enabled(rdev));
 734	regulator_unlock(rdev);
 735
 736	return ret;
 737}
 738static DEVICE_ATTR_RO(state);
 739
 740static ssize_t status_show(struct device *dev,
 741			   struct device_attribute *attr, char *buf)
 742{
 743	struct regulator_dev *rdev = dev_get_drvdata(dev);
 744	int status;
 745	char *label;
 746
 747	status = rdev->desc->ops->get_status(rdev);
 748	if (status < 0)
 749		return status;
 750
 751	switch (status) {
 752	case REGULATOR_STATUS_OFF:
 753		label = "off";
 754		break;
 755	case REGULATOR_STATUS_ON:
 756		label = "on";
 757		break;
 758	case REGULATOR_STATUS_ERROR:
 759		label = "error";
 760		break;
 761	case REGULATOR_STATUS_FAST:
 762		label = "fast";
 763		break;
 764	case REGULATOR_STATUS_NORMAL:
 765		label = "normal";
 766		break;
 767	case REGULATOR_STATUS_IDLE:
 768		label = "idle";
 769		break;
 770	case REGULATOR_STATUS_STANDBY:
 771		label = "standby";
 772		break;
 773	case REGULATOR_STATUS_BYPASS:
 774		label = "bypass";
 775		break;
 776	case REGULATOR_STATUS_UNDEFINED:
 777		label = "undefined";
 778		break;
 779	default:
 780		return -ERANGE;
 781	}
 782
 783	return sprintf(buf, "%s\n", label);
 784}
 785static DEVICE_ATTR_RO(status);
 786
 787static ssize_t min_microamps_show(struct device *dev,
 788				  struct device_attribute *attr, char *buf)
 789{
 790	struct regulator_dev *rdev = dev_get_drvdata(dev);
 791
 792	if (!rdev->constraints)
 793		return sprintf(buf, "constraint not defined\n");
 794
 795	return sprintf(buf, "%d\n", rdev->constraints->min_uA);
 796}
 797static DEVICE_ATTR_RO(min_microamps);
 798
 799static ssize_t max_microamps_show(struct device *dev,
 800				  struct device_attribute *attr, char *buf)
 801{
 802	struct regulator_dev *rdev = dev_get_drvdata(dev);
 803
 804	if (!rdev->constraints)
 805		return sprintf(buf, "constraint not defined\n");
 806
 807	return sprintf(buf, "%d\n", rdev->constraints->max_uA);
 808}
 809static DEVICE_ATTR_RO(max_microamps);
 810
 811static ssize_t min_microvolts_show(struct device *dev,
 812				   struct device_attribute *attr, char *buf)
 813{
 814	struct regulator_dev *rdev = dev_get_drvdata(dev);
 815
 816	if (!rdev->constraints)
 817		return sprintf(buf, "constraint not defined\n");
 818
 819	return sprintf(buf, "%d\n", rdev->constraints->min_uV);
 820}
 821static DEVICE_ATTR_RO(min_microvolts);
 822
 823static ssize_t max_microvolts_show(struct device *dev,
 824				   struct device_attribute *attr, char *buf)
 825{
 826	struct regulator_dev *rdev = dev_get_drvdata(dev);
 827
 828	if (!rdev->constraints)
 829		return sprintf(buf, "constraint not defined\n");
 830
 831	return sprintf(buf, "%d\n", rdev->constraints->max_uV);
 832}
 833static DEVICE_ATTR_RO(max_microvolts);
 834
 835static ssize_t requested_microamps_show(struct device *dev,
 836					struct device_attribute *attr, char *buf)
 837{
 838	struct regulator_dev *rdev = dev_get_drvdata(dev);
 839	struct regulator *regulator;
 840	int uA = 0;
 841
 842	regulator_lock(rdev);
 843	list_for_each_entry(regulator, &rdev->consumer_list, list) {
 844		if (regulator->enable_count)
 845			uA += regulator->uA_load;
 846	}
 847	regulator_unlock(rdev);
 848	return sprintf(buf, "%d\n", uA);
 849}
 850static DEVICE_ATTR_RO(requested_microamps);
 851
 852static ssize_t num_users_show(struct device *dev, struct device_attribute *attr,
 853			      char *buf)
 854{
 855	struct regulator_dev *rdev = dev_get_drvdata(dev);
 856	return sprintf(buf, "%d\n", rdev->use_count);
 857}
 858static DEVICE_ATTR_RO(num_users);
 859
 860static ssize_t type_show(struct device *dev, struct device_attribute *attr,
 861			 char *buf)
 862{
 863	struct regulator_dev *rdev = dev_get_drvdata(dev);
 864
 865	switch (rdev->desc->type) {
 866	case REGULATOR_VOLTAGE:
 867		return sprintf(buf, "voltage\n");
 868	case REGULATOR_CURRENT:
 869		return sprintf(buf, "current\n");
 870	}
 871	return sprintf(buf, "unknown\n");
 872}
 873static DEVICE_ATTR_RO(type);
 874
 875static ssize_t suspend_mem_microvolts_show(struct device *dev,
 876					   struct device_attribute *attr, char *buf)
 877{
 878	struct regulator_dev *rdev = dev_get_drvdata(dev);
 879
 880	return sprintf(buf, "%d\n", rdev->constraints->state_mem.uV);
 881}
 882static DEVICE_ATTR_RO(suspend_mem_microvolts);
 
 883
 884static ssize_t suspend_disk_microvolts_show(struct device *dev,
 885					    struct device_attribute *attr, char *buf)
 886{
 887	struct regulator_dev *rdev = dev_get_drvdata(dev);
 888
 889	return sprintf(buf, "%d\n", rdev->constraints->state_disk.uV);
 890}
 891static DEVICE_ATTR_RO(suspend_disk_microvolts);
 
 892
 893static ssize_t suspend_standby_microvolts_show(struct device *dev,
 894					       struct device_attribute *attr, char *buf)
 895{
 896	struct regulator_dev *rdev = dev_get_drvdata(dev);
 897
 898	return sprintf(buf, "%d\n", rdev->constraints->state_standby.uV);
 899}
 900static DEVICE_ATTR_RO(suspend_standby_microvolts);
 
 901
 902static ssize_t suspend_mem_mode_show(struct device *dev,
 903				     struct device_attribute *attr, char *buf)
 904{
 905	struct regulator_dev *rdev = dev_get_drvdata(dev);
 906
 907	return regulator_print_opmode(buf,
 908		rdev->constraints->state_mem.mode);
 909}
 910static DEVICE_ATTR_RO(suspend_mem_mode);
 
 911
 912static ssize_t suspend_disk_mode_show(struct device *dev,
 913				      struct device_attribute *attr, char *buf)
 914{
 915	struct regulator_dev *rdev = dev_get_drvdata(dev);
 916
 917	return regulator_print_opmode(buf,
 918		rdev->constraints->state_disk.mode);
 919}
 920static DEVICE_ATTR_RO(suspend_disk_mode);
 
 921
 922static ssize_t suspend_standby_mode_show(struct device *dev,
 923					 struct device_attribute *attr, char *buf)
 924{
 925	struct regulator_dev *rdev = dev_get_drvdata(dev);
 926
 927	return regulator_print_opmode(buf,
 928		rdev->constraints->state_standby.mode);
 929}
 930static DEVICE_ATTR_RO(suspend_standby_mode);
 
 931
 932static ssize_t suspend_mem_state_show(struct device *dev,
 933				      struct device_attribute *attr, char *buf)
 934{
 935	struct regulator_dev *rdev = dev_get_drvdata(dev);
 936
 937	return regulator_print_state(buf,
 938			rdev->constraints->state_mem.enabled);
 939}
 940static DEVICE_ATTR_RO(suspend_mem_state);
 
 941
 942static ssize_t suspend_disk_state_show(struct device *dev,
 943				       struct device_attribute *attr, char *buf)
 944{
 945	struct regulator_dev *rdev = dev_get_drvdata(dev);
 946
 947	return regulator_print_state(buf,
 948			rdev->constraints->state_disk.enabled);
 949}
 950static DEVICE_ATTR_RO(suspend_disk_state);
 
 951
 952static ssize_t suspend_standby_state_show(struct device *dev,
 953					  struct device_attribute *attr, char *buf)
 954{
 955	struct regulator_dev *rdev = dev_get_drvdata(dev);
 956
 957	return regulator_print_state(buf,
 958			rdev->constraints->state_standby.enabled);
 959}
 960static DEVICE_ATTR_RO(suspend_standby_state);
 961
 962static ssize_t bypass_show(struct device *dev,
 963			   struct device_attribute *attr, char *buf)
 964{
 965	struct regulator_dev *rdev = dev_get_drvdata(dev);
 966	const char *report;
 967	bool bypass;
 968	int ret;
 969
 970	ret = rdev->desc->ops->get_bypass(rdev, &bypass);
 971
 972	if (ret != 0)
 973		report = "unknown";
 974	else if (bypass)
 975		report = "enabled";
 976	else
 977		report = "disabled";
 
 
 
 
 978
 979	return sprintf(buf, "%s\n", report);
 
 
 
 980}
 981static DEVICE_ATTR_RO(bypass);
 982
 983#define REGULATOR_ERROR_ATTR(name, bit)							\
 984	static ssize_t name##_show(struct device *dev, struct device_attribute *attr,	\
 985				   char *buf)						\
 986	{										\
 987		int ret;								\
 988		unsigned int flags;							\
 989		struct regulator_dev *rdev = dev_get_drvdata(dev);			\
 990		ret = _regulator_get_error_flags(rdev, &flags);				\
 991		if (ret)								\
 992			return ret;							\
 993		return sysfs_emit(buf, "%d\n", !!(flags & (bit)));			\
 994	}										\
 995	static DEVICE_ATTR_RO(name)
 996
 997REGULATOR_ERROR_ATTR(under_voltage, REGULATOR_ERROR_UNDER_VOLTAGE);
 998REGULATOR_ERROR_ATTR(over_current, REGULATOR_ERROR_OVER_CURRENT);
 999REGULATOR_ERROR_ATTR(regulation_out, REGULATOR_ERROR_REGULATION_OUT);
1000REGULATOR_ERROR_ATTR(fail, REGULATOR_ERROR_FAIL);
1001REGULATOR_ERROR_ATTR(over_temp, REGULATOR_ERROR_OVER_TEMP);
1002REGULATOR_ERROR_ATTR(under_voltage_warn, REGULATOR_ERROR_UNDER_VOLTAGE_WARN);
1003REGULATOR_ERROR_ATTR(over_current_warn, REGULATOR_ERROR_OVER_CURRENT_WARN);
1004REGULATOR_ERROR_ATTR(over_voltage_warn, REGULATOR_ERROR_OVER_VOLTAGE_WARN);
1005REGULATOR_ERROR_ATTR(over_temp_warn, REGULATOR_ERROR_OVER_TEMP_WARN);
1006
1007/* Calculate the new optimum regulator operating mode based on the new total
1008 * consumer load. All locks held by caller
1009 */
1010static int drms_uA_update(struct regulator_dev *rdev)
1011{
1012	struct regulator *sibling;
1013	int current_uA = 0, output_uV, input_uV, err;
1014	unsigned int mode;
1015
1016	/*
1017	 * first check to see if we can set modes at all, otherwise just
1018	 * tell the consumer everything is OK.
1019	 */
1020	if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_DRMS)) {
1021		rdev_dbg(rdev, "DRMS operation not allowed\n");
1022		return 0;
1023	}
1024
1025	if (!rdev->desc->ops->get_optimum_mode &&
1026	    !rdev->desc->ops->set_load)
1027		return 0;
 
1028
1029	if (!rdev->desc->ops->set_mode &&
1030	    !rdev->desc->ops->set_load)
1031		return -EINVAL;
 
 
 
 
 
1032
1033	/* calc total requested load */
1034	list_for_each_entry(sibling, &rdev->consumer_list, list) {
1035		if (sibling->enable_count)
1036			current_uA += sibling->uA_load;
1037	}
1038
1039	current_uA += rdev->constraints->system_load;
1040
1041	if (rdev->desc->ops->set_load) {
1042		/* set the optimum mode for our new total regulator load */
1043		err = rdev->desc->ops->set_load(rdev, current_uA);
1044		if (err < 0)
1045			rdev_err(rdev, "failed to set load %d: %pe\n",
1046				 current_uA, ERR_PTR(err));
1047	} else {
1048		/*
1049		 * Unfortunately in some cases the constraints->valid_ops has
1050		 * REGULATOR_CHANGE_DRMS but there are no valid modes listed.
1051		 * That's not really legit but we won't consider it a fatal
1052		 * error here. We'll treat it as if REGULATOR_CHANGE_DRMS
1053		 * wasn't set.
1054		 */
1055		if (!rdev->constraints->valid_modes_mask) {
1056			rdev_dbg(rdev, "Can change modes; but no valid mode\n");
1057			return 0;
1058		}
1059
1060		/* get output voltage */
1061		output_uV = regulator_get_voltage_rdev(rdev);
1062
1063		/*
1064		 * Don't return an error; if regulator driver cares about
1065		 * output_uV then it's up to the driver to validate.
1066		 */
1067		if (output_uV <= 0)
1068			rdev_dbg(rdev, "invalid output voltage found\n");
1069
1070		/* get input voltage */
1071		input_uV = 0;
1072		if (rdev->supply)
1073			input_uV = regulator_get_voltage_rdev(rdev->supply->rdev);
1074		if (input_uV <= 0)
1075			input_uV = rdev->constraints->input_uV;
1076
1077		/*
1078		 * Don't return an error; if regulator driver cares about
1079		 * input_uV then it's up to the driver to validate.
1080		 */
1081		if (input_uV <= 0)
1082			rdev_dbg(rdev, "invalid input voltage found\n");
1083
1084		/* now get the optimum mode for our new total regulator load */
1085		mode = rdev->desc->ops->get_optimum_mode(rdev, input_uV,
1086							 output_uV, current_uA);
 
 
1087
1088		/* check the new mode is allowed */
1089		err = regulator_mode_constrain(rdev, &mode);
1090		if (err < 0) {
1091			rdev_err(rdev, "failed to get optimum mode @ %d uA %d -> %d uV: %pe\n",
1092				 current_uA, input_uV, output_uV, ERR_PTR(err));
1093			return err;
1094		}
1095
1096		err = rdev->desc->ops->set_mode(rdev, mode);
1097		if (err < 0)
1098			rdev_err(rdev, "failed to set optimum mode %x: %pe\n",
1099				 mode, ERR_PTR(err));
 
 
 
 
1100	}
1101
1102	return err;
1103}
 
 
1104
1105static int __suspend_set_state(struct regulator_dev *rdev,
1106			       const struct regulator_state *rstate)
1107{
1108	int ret = 0;
1109
1110	if (rstate->enabled == ENABLE_IN_SUSPEND &&
1111		rdev->desc->ops->set_suspend_enable)
1112		ret = rdev->desc->ops->set_suspend_enable(rdev);
1113	else if (rstate->enabled == DISABLE_IN_SUSPEND &&
1114		rdev->desc->ops->set_suspend_disable)
1115		ret = rdev->desc->ops->set_suspend_disable(rdev);
1116	else /* OK if set_suspend_enable or set_suspend_disable is NULL */
1117		ret = 0;
1118
1119	if (ret < 0) {
1120		rdev_err(rdev, "failed to enabled/disable: %pe\n", ERR_PTR(ret));
1121		return ret;
1122	}
1123
1124	if (rdev->desc->ops->set_suspend_voltage && rstate->uV > 0) {
1125		ret = rdev->desc->ops->set_suspend_voltage(rdev, rstate->uV);
1126		if (ret < 0) {
1127			rdev_err(rdev, "failed to set voltage: %pe\n", ERR_PTR(ret));
1128			return ret;
1129		}
1130	}
1131
1132	if (rdev->desc->ops->set_suspend_mode && rstate->mode > 0) {
1133		ret = rdev->desc->ops->set_suspend_mode(rdev, rstate->mode);
1134		if (ret < 0) {
1135			rdev_err(rdev, "failed to set mode: %pe\n", ERR_PTR(ret));
1136			return ret;
1137		}
1138	}
1139
1140	return ret;
1141}
1142
1143static int suspend_set_initial_state(struct regulator_dev *rdev)
 
1144{
1145	const struct regulator_state *rstate;
1146
1147	rstate = regulator_get_suspend_state_check(rdev,
1148			rdev->constraints->initial_state);
1149	if (!rstate)
1150		return 0;
1151
1152	return __suspend_set_state(rdev, rstate);
 
 
 
 
 
 
 
 
 
 
 
 
1153}
1154
1155#if defined(DEBUG) || defined(CONFIG_DYNAMIC_DEBUG)
1156static void print_constraints_debug(struct regulator_dev *rdev)
1157{
1158	struct regulation_constraints *constraints = rdev->constraints;
1159	char buf[160] = "";
1160	size_t len = sizeof(buf) - 1;
1161	int count = 0;
1162	int ret;
1163
1164	if (constraints->min_uV && constraints->max_uV) {
1165		if (constraints->min_uV == constraints->max_uV)
1166			count += scnprintf(buf + count, len - count, "%d mV ",
1167					   constraints->min_uV / 1000);
1168		else
1169			count += scnprintf(buf + count, len - count,
1170					   "%d <--> %d mV ",
1171					   constraints->min_uV / 1000,
1172					   constraints->max_uV / 1000);
1173	}
1174
1175	if (!constraints->min_uV ||
1176	    constraints->min_uV != constraints->max_uV) {
1177		ret = regulator_get_voltage_rdev(rdev);
1178		if (ret > 0)
1179			count += scnprintf(buf + count, len - count,
1180					   "at %d mV ", ret / 1000);
1181	}
1182
1183	if (constraints->uV_offset)
1184		count += scnprintf(buf + count, len - count, "%dmV offset ",
1185				   constraints->uV_offset / 1000);
1186
1187	if (constraints->min_uA && constraints->max_uA) {
1188		if (constraints->min_uA == constraints->max_uA)
1189			count += scnprintf(buf + count, len - count, "%d mA ",
1190					   constraints->min_uA / 1000);
1191		else
1192			count += scnprintf(buf + count, len - count,
1193					   "%d <--> %d mA ",
1194					   constraints->min_uA / 1000,
1195					   constraints->max_uA / 1000);
1196	}
1197
1198	if (!constraints->min_uA ||
1199	    constraints->min_uA != constraints->max_uA) {
1200		ret = _regulator_get_current_limit(rdev);
1201		if (ret > 0)
1202			count += scnprintf(buf + count, len - count,
1203					   "at %d mA ", ret / 1000);
1204	}
1205
1206	if (constraints->valid_modes_mask & REGULATOR_MODE_FAST)
1207		count += scnprintf(buf + count, len - count, "fast ");
1208	if (constraints->valid_modes_mask & REGULATOR_MODE_NORMAL)
1209		count += scnprintf(buf + count, len - count, "normal ");
1210	if (constraints->valid_modes_mask & REGULATOR_MODE_IDLE)
1211		count += scnprintf(buf + count, len - count, "idle ");
1212	if (constraints->valid_modes_mask & REGULATOR_MODE_STANDBY)
1213		count += scnprintf(buf + count, len - count, "standby ");
1214
1215	if (!count)
1216		count = scnprintf(buf, len, "no parameters");
1217	else
1218		--count;
1219
1220	count += scnprintf(buf + count, len - count, ", %s",
1221		_regulator_is_enabled(rdev) ? "enabled" : "disabled");
1222
1223	rdev_dbg(rdev, "%s\n", buf);
1224}
1225#else /* !DEBUG && !CONFIG_DYNAMIC_DEBUG */
1226static inline void print_constraints_debug(struct regulator_dev *rdev) {}
1227#endif /* !DEBUG && !CONFIG_DYNAMIC_DEBUG */
1228
1229static void print_constraints(struct regulator_dev *rdev)
1230{
1231	struct regulation_constraints *constraints = rdev->constraints;
1232
1233	print_constraints_debug(rdev);
1234
1235	if ((constraints->min_uV != constraints->max_uV) &&
1236	    !regulator_ops_is_valid(rdev, REGULATOR_CHANGE_VOLTAGE))
1237		rdev_warn(rdev,
1238			  "Voltage range but no REGULATOR_CHANGE_VOLTAGE\n");
1239}
1240
1241static int machine_constraints_voltage(struct regulator_dev *rdev,
1242	struct regulation_constraints *constraints)
1243{
1244	const struct regulator_ops *ops = rdev->desc->ops;
1245	int ret;
1246
1247	/* do we need to apply the constraint voltage */
1248	if (rdev->constraints->apply_uV &&
1249	    rdev->constraints->min_uV && rdev->constraints->max_uV) {
1250		int target_min, target_max;
1251		int current_uV = regulator_get_voltage_rdev(rdev);
1252
1253		if (current_uV == -ENOTRECOVERABLE) {
1254			/* This regulator can't be read and must be initialized */
1255			rdev_info(rdev, "Setting %d-%duV\n",
1256				  rdev->constraints->min_uV,
1257				  rdev->constraints->max_uV);
1258			_regulator_do_set_voltage(rdev,
1259						  rdev->constraints->min_uV,
1260						  rdev->constraints->max_uV);
1261			current_uV = regulator_get_voltage_rdev(rdev);
1262		}
1263
1264		if (current_uV < 0) {
1265			if (current_uV != -EPROBE_DEFER)
1266				rdev_err(rdev,
1267					 "failed to get the current voltage: %pe\n",
1268					 ERR_PTR(current_uV));
1269			return current_uV;
1270		}
1271
1272		/*
1273		 * If we're below the minimum voltage move up to the
1274		 * minimum voltage, if we're above the maximum voltage
1275		 * then move down to the maximum.
1276		 */
1277		target_min = current_uV;
1278		target_max = current_uV;
1279
1280		if (current_uV < rdev->constraints->min_uV) {
1281			target_min = rdev->constraints->min_uV;
1282			target_max = rdev->constraints->min_uV;
1283		}
1284
1285		if (current_uV > rdev->constraints->max_uV) {
1286			target_min = rdev->constraints->max_uV;
1287			target_max = rdev->constraints->max_uV;
1288		}
1289
1290		if (target_min != current_uV || target_max != current_uV) {
1291			rdev_info(rdev, "Bringing %duV into %d-%duV\n",
1292				  current_uV, target_min, target_max);
1293			ret = _regulator_do_set_voltage(
1294				rdev, target_min, target_max);
1295			if (ret < 0) {
1296				rdev_err(rdev,
1297					"failed to apply %d-%duV constraint: %pe\n",
1298					target_min, target_max, ERR_PTR(ret));
1299				return ret;
1300			}
1301		}
1302	}
1303
1304	/* constrain machine-level voltage specs to fit
1305	 * the actual range supported by this regulator.
1306	 */
1307	if (ops->list_voltage && rdev->desc->n_voltages) {
1308		int	count = rdev->desc->n_voltages;
1309		int	i;
1310		int	min_uV = INT_MAX;
1311		int	max_uV = INT_MIN;
1312		int	cmin = constraints->min_uV;
1313		int	cmax = constraints->max_uV;
1314
1315		/* it's safe to autoconfigure fixed-voltage supplies
1316		 * and the constraints are used by list_voltage.
1317		 */
1318		if (count == 1 && !cmin) {
1319			cmin = 1;
1320			cmax = INT_MAX;
1321			constraints->min_uV = cmin;
1322			constraints->max_uV = cmax;
1323		}
1324
1325		/* voltage constraints are optional */
1326		if ((cmin == 0) && (cmax == 0))
1327			return 0;
1328
1329		/* else require explicit machine-level constraints */
1330		if (cmin <= 0 || cmax <= 0 || cmax < cmin) {
1331			rdev_err(rdev, "invalid voltage constraints\n");
1332			return -EINVAL;
1333		}
1334
1335		/* no need to loop voltages if range is continuous */
1336		if (rdev->desc->continuous_voltage_range)
1337			return 0;
1338
1339		/* initial: [cmin..cmax] valid, [min_uV..max_uV] not */
1340		for (i = 0; i < count; i++) {
1341			int	value;
1342
1343			value = ops->list_voltage(rdev, i);
1344			if (value <= 0)
1345				continue;
1346
1347			/* maybe adjust [min_uV..max_uV] */
1348			if (value >= cmin && value < min_uV)
1349				min_uV = value;
1350			if (value <= cmax && value > max_uV)
1351				max_uV = value;
1352		}
1353
1354		/* final: [min_uV..max_uV] valid iff constraints valid */
1355		if (max_uV < min_uV) {
1356			rdev_err(rdev,
1357				 "unsupportable voltage constraints %u-%uuV\n",
1358				 min_uV, max_uV);
1359			return -EINVAL;
1360		}
1361
1362		/* use regulator's subset of machine constraints */
1363		if (constraints->min_uV < min_uV) {
1364			rdev_dbg(rdev, "override min_uV, %d -> %d\n",
1365				 constraints->min_uV, min_uV);
1366			constraints->min_uV = min_uV;
1367		}
1368		if (constraints->max_uV > max_uV) {
1369			rdev_dbg(rdev, "override max_uV, %d -> %d\n",
1370				 constraints->max_uV, max_uV);
1371			constraints->max_uV = max_uV;
1372		}
1373	}
1374
1375	return 0;
1376}
1377
1378static int machine_constraints_current(struct regulator_dev *rdev,
1379	struct regulation_constraints *constraints)
1380{
1381	const struct regulator_ops *ops = rdev->desc->ops;
1382	int ret;
1383
1384	if (!constraints->min_uA && !constraints->max_uA)
1385		return 0;
1386
1387	if (constraints->min_uA > constraints->max_uA) {
1388		rdev_err(rdev, "Invalid current constraints\n");
1389		return -EINVAL;
1390	}
1391
1392	if (!ops->set_current_limit || !ops->get_current_limit) {
1393		rdev_warn(rdev, "Operation of current configuration missing\n");
1394		return 0;
1395	}
1396
1397	/* Set regulator current in constraints range */
1398	ret = ops->set_current_limit(rdev, constraints->min_uA,
1399			constraints->max_uA);
1400	if (ret < 0) {
1401		rdev_err(rdev, "Failed to set current constraint, %d\n", ret);
1402		return ret;
1403	}
1404
1405	return 0;
1406}
1407
1408static int _regulator_do_enable(struct regulator_dev *rdev);
1409
1410static int notif_set_limit(struct regulator_dev *rdev,
1411			   int (*set)(struct regulator_dev *, int, int, bool),
1412			   int limit, int severity)
1413{
1414	bool enable;
1415
1416	if (limit == REGULATOR_NOTIF_LIMIT_DISABLE) {
1417		enable = false;
1418		limit = 0;
1419	} else {
1420		enable = true;
1421	}
1422
1423	if (limit == REGULATOR_NOTIF_LIMIT_ENABLE)
1424		limit = 0;
1425
1426	return set(rdev, limit, severity, enable);
1427}
1428
1429static int handle_notify_limits(struct regulator_dev *rdev,
1430			int (*set)(struct regulator_dev *, int, int, bool),
1431			struct notification_limit *limits)
1432{
1433	int ret = 0;
1434
1435	if (!set)
1436		return -EOPNOTSUPP;
1437
1438	if (limits->prot)
1439		ret = notif_set_limit(rdev, set, limits->prot,
1440				      REGULATOR_SEVERITY_PROT);
1441	if (ret)
1442		return ret;
1443
1444	if (limits->err)
1445		ret = notif_set_limit(rdev, set, limits->err,
1446				      REGULATOR_SEVERITY_ERR);
1447	if (ret)
1448		return ret;
1449
1450	if (limits->warn)
1451		ret = notif_set_limit(rdev, set, limits->warn,
1452				      REGULATOR_SEVERITY_WARN);
1453
1454	return ret;
1455}
1456/**
1457 * set_machine_constraints - sets regulator constraints
1458 * @rdev: regulator source
 
1459 *
1460 * Allows platform initialisation code to define and constrain
1461 * regulator circuits e.g. valid voltage/current ranges, etc.  NOTE:
1462 * Constraints *must* be set by platform code in order for some
1463 * regulator operations to proceed i.e. set_voltage, set_current_limit,
1464 * set_mode.
1465 */
1466static int set_machine_constraints(struct regulator_dev *rdev)
 
1467{
1468	int ret = 0;
1469	const struct regulator_ops *ops = rdev->desc->ops;
1470
1471	ret = machine_constraints_voltage(rdev, rdev->constraints);
1472	if (ret != 0)
1473		return ret;
 
1474
1475	ret = machine_constraints_current(rdev, rdev->constraints);
1476	if (ret != 0)
1477		return ret;
1478
1479	if (rdev->constraints->ilim_uA && ops->set_input_current_limit) {
1480		ret = ops->set_input_current_limit(rdev,
1481						   rdev->constraints->ilim_uA);
1482		if (ret < 0) {
1483			rdev_err(rdev, "failed to set input limit: %pe\n", ERR_PTR(ret));
1484			return ret;
1485		}
1486	}
1487
1488	/* do we need to setup our suspend state */
1489	if (rdev->constraints->initial_state) {
1490		ret = suspend_set_initial_state(rdev);
1491		if (ret < 0) {
1492			rdev_err(rdev, "failed to set suspend state: %pe\n", ERR_PTR(ret));
1493			return ret;
1494		}
1495	}
1496
1497	if (rdev->constraints->initial_mode) {
1498		if (!ops->set_mode) {
1499			rdev_err(rdev, "no set_mode operation\n");
1500			return -EINVAL;
 
1501		}
1502
1503		ret = ops->set_mode(rdev, rdev->constraints->initial_mode);
1504		if (ret < 0) {
1505			rdev_err(rdev, "failed to set initial mode: %pe\n", ERR_PTR(ret));
1506			return ret;
1507		}
1508	} else if (rdev->constraints->system_load) {
1509		/*
1510		 * We'll only apply the initial system load if an
1511		 * initial mode wasn't specified.
1512		 */
1513		drms_uA_update(rdev);
1514	}
1515
1516	if ((rdev->constraints->ramp_delay || rdev->constraints->ramp_disable)
1517		&& ops->set_ramp_delay) {
1518		ret = ops->set_ramp_delay(rdev, rdev->constraints->ramp_delay);
1519		if (ret < 0) {
1520			rdev_err(rdev, "failed to set ramp_delay: %pe\n", ERR_PTR(ret));
1521			return ret;
1522		}
1523	}
1524
1525	if (rdev->constraints->pull_down && ops->set_pull_down) {
1526		ret = ops->set_pull_down(rdev);
1527		if (ret < 0) {
1528			rdev_err(rdev, "failed to set pull down: %pe\n", ERR_PTR(ret));
1529			return ret;
1530		}
1531	}
1532
1533	if (rdev->constraints->soft_start && ops->set_soft_start) {
1534		ret = ops->set_soft_start(rdev);
1535		if (ret < 0) {
1536			rdev_err(rdev, "failed to set soft start: %pe\n", ERR_PTR(ret));
1537			return ret;
1538		}
1539	}
1540
1541	/*
1542	 * Existing logic does not warn if over_current_protection is given as
1543	 * a constraint but driver does not support that. I think we should
1544	 * warn about this type of issues as it is possible someone changes
1545	 * PMIC on board to another type - and the another PMIC's driver does
1546	 * not support setting protection. Board composer may happily believe
1547	 * the DT limits are respected - especially if the new PMIC HW also
1548	 * supports protection but the driver does not. I won't change the logic
1549	 * without hearing more experienced opinion on this though.
1550	 *
1551	 * If warning is seen as a good idea then we can merge handling the
1552	 * over-curret protection and detection and get rid of this special
1553	 * handling.
1554	 */
1555	if (rdev->constraints->over_current_protection
1556		&& ops->set_over_current_protection) {
1557		int lim = rdev->constraints->over_curr_limits.prot;
1558
1559		ret = ops->set_over_current_protection(rdev, lim,
1560						       REGULATOR_SEVERITY_PROT,
1561						       true);
1562		if (ret < 0) {
1563			rdev_err(rdev, "failed to set over current protection: %pe\n",
1564				 ERR_PTR(ret));
1565			return ret;
1566		}
1567	}
1568
1569	if (rdev->constraints->over_current_detection)
1570		ret = handle_notify_limits(rdev,
1571					   ops->set_over_current_protection,
1572					   &rdev->constraints->over_curr_limits);
1573	if (ret) {
1574		if (ret != -EOPNOTSUPP) {
1575			rdev_err(rdev, "failed to set over current limits: %pe\n",
1576				 ERR_PTR(ret));
1577			return ret;
1578		}
1579		rdev_warn(rdev,
1580			  "IC does not support requested over-current limits\n");
1581	}
1582
1583	if (rdev->constraints->over_voltage_detection)
1584		ret = handle_notify_limits(rdev,
1585					   ops->set_over_voltage_protection,
1586					   &rdev->constraints->over_voltage_limits);
1587	if (ret) {
1588		if (ret != -EOPNOTSUPP) {
1589			rdev_err(rdev, "failed to set over voltage limits %pe\n",
1590				 ERR_PTR(ret));
1591			return ret;
1592		}
1593		rdev_warn(rdev,
1594			  "IC does not support requested over voltage limits\n");
1595	}
1596
1597	if (rdev->constraints->under_voltage_detection)
1598		ret = handle_notify_limits(rdev,
1599					   ops->set_under_voltage_protection,
1600					   &rdev->constraints->under_voltage_limits);
1601	if (ret) {
1602		if (ret != -EOPNOTSUPP) {
1603			rdev_err(rdev, "failed to set under voltage limits %pe\n",
1604				 ERR_PTR(ret));
1605			return ret;
1606		}
1607		rdev_warn(rdev,
1608			  "IC does not support requested under voltage limits\n");
1609	}
1610
1611	if (rdev->constraints->over_temp_detection)
1612		ret = handle_notify_limits(rdev,
1613					   ops->set_thermal_protection,
1614					   &rdev->constraints->temp_limits);
1615	if (ret) {
1616		if (ret != -EOPNOTSUPP) {
1617			rdev_err(rdev, "failed to set temperature limits %pe\n",
1618				 ERR_PTR(ret));
1619			return ret;
1620		}
1621		rdev_warn(rdev,
1622			  "IC does not support requested temperature limits\n");
1623	}
1624
1625	if (rdev->constraints->active_discharge && ops->set_active_discharge) {
1626		bool ad_state = (rdev->constraints->active_discharge ==
1627			      REGULATOR_ACTIVE_DISCHARGE_ENABLE) ? true : false;
1628
1629		ret = ops->set_active_discharge(rdev, ad_state);
1630		if (ret < 0) {
1631			rdev_err(rdev, "failed to set active discharge: %pe\n", ERR_PTR(ret));
1632			return ret;
1633		}
1634	}
1635
1636	/*
1637	 * If there is no mechanism for controlling the regulator then
1638	 * flag it as always_on so we don't end up duplicating checks
1639	 * for this so much.  Note that we could control the state of
1640	 * a supply to control the output on a regulator that has no
1641	 * direct control.
1642	 */
1643	if (!rdev->ena_pin && !ops->enable) {
1644		if (rdev->supply_name && !rdev->supply)
1645			return -EPROBE_DEFER;
1646
1647		if (rdev->supply)
1648			rdev->constraints->always_on =
1649				rdev->supply->rdev->constraints->always_on;
1650		else
1651			rdev->constraints->always_on = true;
1652	}
1653
1654	/* If the constraints say the regulator should be on at this point
1655	 * and we have control then make sure it is enabled.
1656	 */
1657	if (rdev->constraints->always_on || rdev->constraints->boot_on) {
1658		/* If we want to enable this regulator, make sure that we know
1659		 * the supplying regulator.
1660		 */
1661		if (rdev->supply_name && !rdev->supply)
1662			return -EPROBE_DEFER;
1663
1664		/* If supplying regulator has already been enabled,
1665		 * it's not intended to have use_count increment
1666		 * when rdev is only boot-on.
1667		 */
1668		if (rdev->supply &&
1669		    (rdev->constraints->always_on ||
1670		     !regulator_is_enabled(rdev->supply))) {
1671			ret = regulator_enable(rdev->supply);
1672			if (ret < 0) {
1673				_regulator_put(rdev->supply);
1674				rdev->supply = NULL;
1675				return ret;
1676			}
1677		}
1678
1679		ret = _regulator_do_enable(rdev);
1680		if (ret < 0 && ret != -EINVAL) {
1681			rdev_err(rdev, "failed to enable: %pe\n", ERR_PTR(ret));
1682			return ret;
1683		}
1684
1685		if (rdev->constraints->always_on)
1686			rdev->use_count++;
1687	} else if (rdev->desc->off_on_delay) {
1688		rdev->last_off = ktime_get();
1689	}
1690
1691	print_constraints(rdev);
1692	return 0;
 
 
 
 
1693}
1694
1695/**
1696 * set_supply - set regulator supply regulator
1697 * @rdev: regulator (locked)
1698 * @supply_rdev: supply regulator (locked))
1699 *
1700 * Called by platform initialisation code to set the supply regulator for this
1701 * regulator. This ensures that a regulators supply will also be enabled by the
1702 * core if it's child is enabled.
1703 */
1704static int set_supply(struct regulator_dev *rdev,
1705		      struct regulator_dev *supply_rdev)
1706{
1707	int err;
1708
1709	rdev_dbg(rdev, "supplied by %s\n", rdev_get_name(supply_rdev));
1710
1711	if (!try_module_get(supply_rdev->owner))
1712		return -ENODEV;
1713
1714	rdev->supply = create_regulator(supply_rdev, &rdev->dev, "SUPPLY");
1715	if (rdev->supply == NULL) {
1716		module_put(supply_rdev->owner);
1717		err = -ENOMEM;
1718		return err;
1719	}
1720	supply_rdev->open_count++;
1721
1722	return 0;
1723}
1724
1725/**
1726 * set_consumer_device_supply - Bind a regulator to a symbolic supply
1727 * @rdev:         regulator source
 
1728 * @consumer_dev_name: dev_name() string for device supply applies to
1729 * @supply:       symbolic name for supply
1730 *
1731 * Allows platform initialisation code to map physical regulator
1732 * sources to symbolic names for supplies for use by devices.  Devices
1733 * should use these symbolic names to request regulators, avoiding the
1734 * need to provide board-specific regulator names as platform data.
 
 
1735 */
1736static int set_consumer_device_supply(struct regulator_dev *rdev,
1737				      const char *consumer_dev_name,
1738				      const char *supply)
1739{
1740	struct regulator_map *node, *new_node;
1741	int has_dev;
1742
 
 
 
 
 
 
1743	if (supply == NULL)
1744		return -EINVAL;
1745
1746	if (consumer_dev_name != NULL)
1747		has_dev = 1;
1748	else
1749		has_dev = 0;
1750
1751	new_node = kzalloc(sizeof(struct regulator_map), GFP_KERNEL);
1752	if (new_node == NULL)
1753		return -ENOMEM;
1754
1755	new_node->regulator = rdev;
1756	new_node->supply = supply;
1757
1758	if (has_dev) {
1759		new_node->dev_name = kstrdup(consumer_dev_name, GFP_KERNEL);
1760		if (new_node->dev_name == NULL) {
1761			kfree(new_node);
1762			return -ENOMEM;
1763		}
1764	}
1765
1766	mutex_lock(&regulator_list_mutex);
1767	list_for_each_entry(node, &regulator_map_list, list) {
1768		if (node->dev_name && consumer_dev_name) {
1769			if (strcmp(node->dev_name, consumer_dev_name) != 0)
1770				continue;
1771		} else if (node->dev_name || consumer_dev_name) {
1772			continue;
1773		}
1774
1775		if (strcmp(node->supply, supply) != 0)
1776			continue;
1777
1778		pr_debug("%s: %s/%s is '%s' supply; fail %s/%s\n",
1779			 consumer_dev_name,
1780			 dev_name(&node->regulator->dev),
1781			 node->regulator->desc->name,
1782			 supply,
1783			 dev_name(&rdev->dev), rdev_get_name(rdev));
1784		goto fail;
1785	}
1786
1787	list_add(&new_node->list, &regulator_map_list);
1788	mutex_unlock(&regulator_list_mutex);
 
1789
1790	return 0;
 
1791
1792fail:
1793	mutex_unlock(&regulator_list_mutex);
1794	kfree(new_node->dev_name);
1795	kfree(new_node);
1796	return -EBUSY;
 
 
 
 
 
1797}
1798
1799static void unset_regulator_supplies(struct regulator_dev *rdev)
1800{
1801	struct regulator_map *node, *n;
1802
1803	list_for_each_entry_safe(node, n, &regulator_map_list, list) {
1804		if (rdev == node->regulator) {
1805			list_del(&node->list);
1806			kfree(node->dev_name);
1807			kfree(node);
1808		}
1809	}
1810}
1811
1812#ifdef CONFIG_DEBUG_FS
1813static ssize_t constraint_flags_read_file(struct file *file,
1814					  char __user *user_buf,
1815					  size_t count, loff_t *ppos)
1816{
1817	const struct regulator *regulator = file->private_data;
1818	const struct regulation_constraints *c = regulator->rdev->constraints;
1819	char *buf;
1820	ssize_t ret;
1821
1822	if (!c)
1823		return 0;
1824
1825	buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
1826	if (!buf)
1827		return -ENOMEM;
1828
1829	ret = snprintf(buf, PAGE_SIZE,
1830			"always_on: %u\n"
1831			"boot_on: %u\n"
1832			"apply_uV: %u\n"
1833			"ramp_disable: %u\n"
1834			"soft_start: %u\n"
1835			"pull_down: %u\n"
1836			"over_current_protection: %u\n",
1837			c->always_on,
1838			c->boot_on,
1839			c->apply_uV,
1840			c->ramp_disable,
1841			c->soft_start,
1842			c->pull_down,
1843			c->over_current_protection);
1844
1845	ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
1846	kfree(buf);
1847
1848	return ret;
1849}
1850
1851#endif
1852
1853static const struct file_operations constraint_flags_fops = {
1854#ifdef CONFIG_DEBUG_FS
1855	.open = simple_open,
1856	.read = constraint_flags_read_file,
1857	.llseek = default_llseek,
1858#endif
1859};
1860
1861#define REG_STR_SIZE	64
1862
1863static struct regulator *create_regulator(struct regulator_dev *rdev,
1864					  struct device *dev,
1865					  const char *supply_name)
1866{
1867	struct regulator *regulator;
1868	int err = 0;
1869
1870	lockdep_assert_held_once(&rdev->mutex.base);
1871
1872	if (dev) {
1873		char buf[REG_STR_SIZE];
1874		int size;
1875
1876		size = snprintf(buf, REG_STR_SIZE, "%s-%s",
1877				dev->kobj.name, supply_name);
1878		if (size >= REG_STR_SIZE)
1879			return NULL;
1880
1881		supply_name = kstrdup(buf, GFP_KERNEL);
1882		if (supply_name == NULL)
1883			return NULL;
1884	} else {
1885		supply_name = kstrdup_const(supply_name, GFP_KERNEL);
1886		if (supply_name == NULL)
1887			return NULL;
1888	}
1889
1890	regulator = kzalloc(sizeof(*regulator), GFP_KERNEL);
1891	if (regulator == NULL) {
1892		kfree_const(supply_name);
1893		return NULL;
1894	}
1895
 
1896	regulator->rdev = rdev;
1897	regulator->supply_name = supply_name;
1898
1899	list_add(&regulator->list, &rdev->consumer_list);
1900
1901	if (dev) {
 
 
 
 
 
 
 
1902		regulator->dev = dev;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1903
1904		/* Add a link to the device sysfs entry */
1905		err = sysfs_create_link_nowarn(&rdev->dev.kobj, &dev->kobj,
1906					       supply_name);
 
 
 
1907		if (err) {
1908			rdev_dbg(rdev, "could not add device link %s: %pe\n",
1909				  dev->kobj.name, ERR_PTR(err));
1910			/* non-fatal */
1911		}
 
 
 
 
1912	}
1913
1914	if (err != -EEXIST)
1915		regulator->debugfs = debugfs_create_dir(supply_name, rdev->debugfs);
1916	if (IS_ERR(regulator->debugfs))
1917		rdev_dbg(rdev, "Failed to create debugfs directory\n");
1918
1919	debugfs_create_u32("uA_load", 0444, regulator->debugfs,
1920			   &regulator->uA_load);
1921	debugfs_create_u32("min_uV", 0444, regulator->debugfs,
1922			   &regulator->voltage[PM_SUSPEND_ON].min_uV);
1923	debugfs_create_u32("max_uV", 0444, regulator->debugfs,
1924			   &regulator->voltage[PM_SUSPEND_ON].max_uV);
1925	debugfs_create_file("constraint_flags", 0444, regulator->debugfs,
1926			    regulator, &constraint_flags_fops);
1927
1928	/*
1929	 * Check now if the regulator is an always on regulator - if
1930	 * it is then we don't need to do nearly so much work for
1931	 * enable/disable calls.
1932	 */
1933	if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_STATUS) &&
1934	    _regulator_is_enabled(rdev))
1935		regulator->always_on = true;
1936
 
1937	return regulator;
1938}
1939
1940static int _regulator_get_enable_time(struct regulator_dev *rdev)
1941{
1942	if (rdev->constraints && rdev->constraints->enable_time)
1943		return rdev->constraints->enable_time;
1944	if (rdev->desc->ops->enable_time)
1945		return rdev->desc->ops->enable_time(rdev);
1946	return rdev->desc->enable_time;
1947}
1948
1949static struct regulator_supply_alias *regulator_find_supply_alias(
1950		struct device *dev, const char *supply)
1951{
1952	struct regulator_supply_alias *map;
1953
1954	list_for_each_entry(map, &regulator_supply_alias_list, list)
1955		if (map->src_dev == dev && strcmp(map->src_supply, supply) == 0)
1956			return map;
1957
1958	return NULL;
1959}
1960
1961static void regulator_supply_alias(struct device **dev, const char **supply)
1962{
1963	struct regulator_supply_alias *map;
1964
1965	map = regulator_find_supply_alias(*dev, *supply);
1966	if (map) {
1967		dev_dbg(*dev, "Mapping supply %s to %s,%s\n",
1968				*supply, map->alias_supply,
1969				dev_name(map->alias_dev));
1970		*dev = map->alias_dev;
1971		*supply = map->alias_supply;
1972	}
1973}
1974
1975static int regulator_match(struct device *dev, const void *data)
1976{
1977	struct regulator_dev *r = dev_to_rdev(dev);
1978
1979	return strcmp(rdev_get_name(r), data) == 0;
1980}
1981
1982static struct regulator_dev *regulator_lookup_by_name(const char *name)
1983{
1984	struct device *dev;
1985
1986	dev = class_find_device(&regulator_class, NULL, name, regulator_match);
1987
1988	return dev ? dev_to_rdev(dev) : NULL;
1989}
1990
1991/**
1992 * regulator_dev_lookup - lookup a regulator device.
1993 * @dev: device for regulator "consumer".
1994 * @supply: Supply name or regulator ID.
1995 *
1996 * If successful, returns a struct regulator_dev that corresponds to the name
1997 * @supply and with the embedded struct device refcount incremented by one.
1998 * The refcount must be dropped by calling put_device().
1999 * On failure one of the following ERR-PTR-encoded values is returned:
2000 * -ENODEV if lookup fails permanently, -EPROBE_DEFER if lookup could succeed
2001 * in the future.
2002 */
2003static struct regulator_dev *regulator_dev_lookup(struct device *dev,
2004						  const char *supply)
2005{
2006	struct regulator_dev *r = NULL;
2007	struct device_node *node;
2008	struct regulator_map *map;
 
2009	const char *devname = NULL;
 
2010
2011	regulator_supply_alias(&dev, &supply);
2012
2013	/* first do a dt based lookup */
2014	if (dev && dev->of_node) {
2015		node = of_get_regulator(dev, supply);
2016		if (node) {
2017			r = of_find_regulator_by_node(node);
2018			of_node_put(node);
2019			if (r)
2020				return r;
2021
2022			/*
2023			 * We have a node, but there is no device.
2024			 * assume it has not registered yet.
2025			 */
2026			return ERR_PTR(-EPROBE_DEFER);
2027		}
2028	}
2029
2030	/* if not found, try doing it non-dt way */
2031	if (dev)
2032		devname = dev_name(dev);
2033
2034	mutex_lock(&regulator_list_mutex);
 
2035	list_for_each_entry(map, &regulator_map_list, list) {
2036		/* If the mapping has a device set up it must match */
2037		if (map->dev_name &&
2038		    (!devname || strcmp(map->dev_name, devname)))
2039			continue;
2040
2041		if (strcmp(map->supply, supply) == 0 &&
2042		    get_device(&map->regulator->dev)) {
2043			r = map->regulator;
2044			break;
2045		}
2046	}
2047	mutex_unlock(&regulator_list_mutex);
2048
2049	if (r)
2050		return r;
2051
2052	r = regulator_lookup_by_name(supply);
2053	if (r)
2054		return r;
2055
2056	return ERR_PTR(-ENODEV);
2057}
2058
2059static int regulator_resolve_supply(struct regulator_dev *rdev)
2060{
2061	struct regulator_dev *r;
2062	struct device *dev = rdev->dev.parent;
2063	struct ww_acquire_ctx ww_ctx;
2064	int ret = 0;
2065
2066	/* No supply to resolve? */
2067	if (!rdev->supply_name)
2068		return 0;
2069
2070	/* Supply already resolved? (fast-path without locking contention) */
2071	if (rdev->supply)
2072		return 0;
2073
2074	r = regulator_dev_lookup(dev, rdev->supply_name);
2075	if (IS_ERR(r)) {
2076		ret = PTR_ERR(r);
2077
2078		/* Did the lookup explicitly defer for us? */
2079		if (ret == -EPROBE_DEFER)
2080			goto out;
2081
2082		if (have_full_constraints()) {
2083			r = dummy_regulator_rdev;
2084			get_device(&r->dev);
2085		} else {
2086			dev_err(dev, "Failed to resolve %s-supply for %s\n",
2087				rdev->supply_name, rdev->desc->name);
2088			ret = -EPROBE_DEFER;
2089			goto out;
2090		}
2091	}
2092
2093	if (r == rdev) {
2094		dev_err(dev, "Supply for %s (%s) resolved to itself\n",
2095			rdev->desc->name, rdev->supply_name);
2096		if (!have_full_constraints()) {
2097			ret = -EINVAL;
2098			goto out;
2099		}
2100		r = dummy_regulator_rdev;
2101		get_device(&r->dev);
2102	}
2103
2104	/*
2105	 * If the supply's parent device is not the same as the
2106	 * regulator's parent device, then ensure the parent device
2107	 * is bound before we resolve the supply, in case the parent
2108	 * device get probe deferred and unregisters the supply.
2109	 */
2110	if (r->dev.parent && r->dev.parent != rdev->dev.parent) {
2111		if (!device_is_bound(r->dev.parent)) {
2112			put_device(&r->dev);
2113			ret = -EPROBE_DEFER;
2114			goto out;
2115		}
2116	}
2117
2118	/* Recursively resolve the supply of the supply */
2119	ret = regulator_resolve_supply(r);
2120	if (ret < 0) {
2121		put_device(&r->dev);
2122		goto out;
2123	}
2124
2125	/*
2126	 * Recheck rdev->supply with rdev->mutex lock held to avoid a race
2127	 * between rdev->supply null check and setting rdev->supply in
2128	 * set_supply() from concurrent tasks.
2129	 */
2130	regulator_lock_two(rdev, r, &ww_ctx);
2131
2132	/* Supply just resolved by a concurrent task? */
2133	if (rdev->supply) {
2134		regulator_unlock_two(rdev, r, &ww_ctx);
2135		put_device(&r->dev);
2136		goto out;
2137	}
2138
2139	ret = set_supply(rdev, r);
2140	if (ret < 0) {
2141		regulator_unlock_two(rdev, r, &ww_ctx);
2142		put_device(&r->dev);
2143		goto out;
2144	}
 
2145
2146	regulator_unlock_two(rdev, r, &ww_ctx);
2147
2148	/*
2149	 * In set_machine_constraints() we may have turned this regulator on
2150	 * but we couldn't propagate to the supply if it hadn't been resolved
2151	 * yet.  Do it now.
2152	 */
2153	if (rdev->use_count) {
2154		ret = regulator_enable(rdev->supply);
2155		if (ret < 0) {
2156			_regulator_put(rdev->supply);
2157			rdev->supply = NULL;
2158			goto out;
2159		}
2160	}
2161
2162out:
2163	return ret;
2164}
2165
2166/* Internal regulator request function */
2167struct regulator *_regulator_get(struct device *dev, const char *id,
2168				 enum regulator_get_type get_type)
2169{
2170	struct regulator_dev *rdev;
2171	struct regulator *regulator;
2172	struct device_link *link;
2173	int ret;
2174
2175	if (get_type >= MAX_GET_TYPE) {
2176		dev_err(dev, "invalid type %d in %s\n", get_type, __func__);
2177		return ERR_PTR(-EINVAL);
2178	}
2179
2180	if (id == NULL) {
2181		pr_err("get() with no identifier\n");
2182		return ERR_PTR(-EINVAL);
2183	}
2184
2185	rdev = regulator_dev_lookup(dev, id);
2186	if (IS_ERR(rdev)) {
2187		ret = PTR_ERR(rdev);
2188
2189		/*
2190		 * If regulator_dev_lookup() fails with error other
2191		 * than -ENODEV our job here is done, we simply return it.
2192		 */
2193		if (ret != -ENODEV)
2194			return ERR_PTR(ret);
2195
2196		if (!have_full_constraints()) {
2197			dev_warn(dev,
2198				 "incomplete constraints, dummy supplies not allowed\n");
2199			return ERR_PTR(-ENODEV);
2200		}
2201
2202		switch (get_type) {
2203		case NORMAL_GET:
2204			/*
2205			 * Assume that a regulator is physically present and
2206			 * enabled, even if it isn't hooked up, and just
2207			 * provide a dummy.
2208			 */
2209			dev_warn(dev, "supply %s not found, using dummy regulator\n", id);
2210			rdev = dummy_regulator_rdev;
2211			get_device(&rdev->dev);
2212			break;
2213
2214		case EXCLUSIVE_GET:
2215			dev_warn(dev,
2216				 "dummy supplies not allowed for exclusive requests\n");
2217			fallthrough;
2218
2219		default:
2220			return ERR_PTR(-ENODEV);
2221		}
2222	}
2223
 
2224	if (rdev->exclusive) {
2225		regulator = ERR_PTR(-EPERM);
2226		put_device(&rdev->dev);
2227		return regulator;
2228	}
2229
2230	if (get_type == EXCLUSIVE_GET && rdev->open_count) {
2231		regulator = ERR_PTR(-EBUSY);
2232		put_device(&rdev->dev);
2233		return regulator;
2234	}
2235
2236	mutex_lock(&regulator_list_mutex);
2237	ret = (rdev->coupling_desc.n_resolved != rdev->coupling_desc.n_coupled);
2238	mutex_unlock(&regulator_list_mutex);
2239
2240	if (ret != 0) {
2241		regulator = ERR_PTR(-EPROBE_DEFER);
2242		put_device(&rdev->dev);
2243		return regulator;
2244	}
2245
2246	ret = regulator_resolve_supply(rdev);
2247	if (ret < 0) {
2248		regulator = ERR_PTR(ret);
2249		put_device(&rdev->dev);
2250		return regulator;
2251	}
2252
2253	if (!try_module_get(rdev->owner)) {
2254		regulator = ERR_PTR(-EPROBE_DEFER);
2255		put_device(&rdev->dev);
2256		return regulator;
2257	}
2258
2259	regulator_lock(rdev);
2260	regulator = create_regulator(rdev, dev, id);
2261	regulator_unlock(rdev);
2262	if (regulator == NULL) {
2263		regulator = ERR_PTR(-ENOMEM);
2264		module_put(rdev->owner);
2265		put_device(&rdev->dev);
2266		return regulator;
2267	}
2268
2269	rdev->open_count++;
2270	if (get_type == EXCLUSIVE_GET) {
2271		rdev->exclusive = 1;
2272
2273		ret = _regulator_is_enabled(rdev);
2274		if (ret > 0) {
2275			rdev->use_count = 1;
2276			regulator->enable_count = 1;
2277		} else {
2278			rdev->use_count = 0;
2279			regulator->enable_count = 0;
2280		}
2281	}
2282
2283	link = device_link_add(dev, &rdev->dev, DL_FLAG_STATELESS);
2284	if (!IS_ERR_OR_NULL(link))
2285		regulator->device_link = true;
2286
2287	return regulator;
2288}
2289
2290/**
2291 * regulator_get - lookup and obtain a reference to a regulator.
2292 * @dev: device for regulator "consumer"
2293 * @id: Supply name or regulator ID.
2294 *
2295 * Returns a struct regulator corresponding to the regulator producer,
2296 * or IS_ERR() condition containing errno.
2297 *
2298 * Use of supply names configured via set_consumer_device_supply() is
2299 * strongly encouraged.  It is recommended that the supply name used
2300 * should match the name used for the supply and/or the relevant
2301 * device pins in the datasheet.
2302 */
2303struct regulator *regulator_get(struct device *dev, const char *id)
2304{
2305	return _regulator_get(dev, id, NORMAL_GET);
2306}
2307EXPORT_SYMBOL_GPL(regulator_get);
2308
2309/**
2310 * regulator_get_exclusive - obtain exclusive access to a regulator.
2311 * @dev: device for regulator "consumer"
2312 * @id: Supply name or regulator ID.
2313 *
2314 * Returns a struct regulator corresponding to the regulator producer,
2315 * or IS_ERR() condition containing errno.  Other consumers will be
2316 * unable to obtain this regulator while this reference is held and the
2317 * use count for the regulator will be initialised to reflect the current
2318 * state of the regulator.
2319 *
2320 * This is intended for use by consumers which cannot tolerate shared
2321 * use of the regulator such as those which need to force the
2322 * regulator off for correct operation of the hardware they are
2323 * controlling.
2324 *
2325 * Use of supply names configured via set_consumer_device_supply() is
2326 * strongly encouraged.  It is recommended that the supply name used
2327 * should match the name used for the supply and/or the relevant
2328 * device pins in the datasheet.
2329 */
2330struct regulator *regulator_get_exclusive(struct device *dev, const char *id)
2331{
2332	return _regulator_get(dev, id, EXCLUSIVE_GET);
2333}
2334EXPORT_SYMBOL_GPL(regulator_get_exclusive);
2335
2336/**
2337 * regulator_get_optional - obtain optional access to a regulator.
2338 * @dev: device for regulator "consumer"
2339 * @id: Supply name or regulator ID.
2340 *
2341 * Returns a struct regulator corresponding to the regulator producer,
2342 * or IS_ERR() condition containing errno.
2343 *
2344 * This is intended for use by consumers for devices which can have
2345 * some supplies unconnected in normal use, such as some MMC devices.
2346 * It can allow the regulator core to provide stub supplies for other
2347 * supplies requested using normal regulator_get() calls without
2348 * disrupting the operation of drivers that can handle absent
2349 * supplies.
2350 *
2351 * Use of supply names configured via set_consumer_device_supply() is
2352 * strongly encouraged.  It is recommended that the supply name used
2353 * should match the name used for the supply and/or the relevant
2354 * device pins in the datasheet.
2355 */
2356struct regulator *regulator_get_optional(struct device *dev, const char *id)
2357{
2358	return _regulator_get(dev, id, OPTIONAL_GET);
2359}
2360EXPORT_SYMBOL_GPL(regulator_get_optional);
2361
2362static void destroy_regulator(struct regulator *regulator)
2363{
2364	struct regulator_dev *rdev = regulator->rdev;
2365
2366	debugfs_remove_recursive(regulator->debugfs);
2367
2368	if (regulator->dev) {
2369		if (regulator->device_link)
2370			device_link_remove(regulator->dev, &rdev->dev);
2371
2372		/* remove any sysfs entries */
2373		sysfs_remove_link(&rdev->dev.kobj, regulator->supply_name);
2374	}
2375
2376	regulator_lock(rdev);
2377	list_del(&regulator->list);
2378
2379	rdev->open_count--;
2380	rdev->exclusive = 0;
2381	regulator_unlock(rdev);
2382
2383	kfree_const(regulator->supply_name);
2384	kfree(regulator);
2385}
2386
2387/* regulator_list_mutex lock held by regulator_put() */
2388static void _regulator_put(struct regulator *regulator)
2389{
2390	struct regulator_dev *rdev;
2391
2392	if (IS_ERR_OR_NULL(regulator))
2393		return;
2394
2395	lockdep_assert_held_once(&regulator_list_mutex);
2396
2397	/* Docs say you must disable before calling regulator_put() */
2398	WARN_ON(regulator->enable_count);
2399
2400	rdev = regulator->rdev;
2401
2402	destroy_regulator(regulator);
2403
2404	module_put(rdev->owner);
2405	put_device(&rdev->dev);
2406}
2407
2408/**
2409 * regulator_put - "free" the regulator source
2410 * @regulator: regulator source
2411 *
2412 * Note: drivers must ensure that all regulator_enable calls made on this
2413 * regulator source are balanced by regulator_disable calls prior to calling
2414 * this function.
2415 */
2416void regulator_put(struct regulator *regulator)
2417{
2418	mutex_lock(&regulator_list_mutex);
2419	_regulator_put(regulator);
2420	mutex_unlock(&regulator_list_mutex);
2421}
2422EXPORT_SYMBOL_GPL(regulator_put);
2423
2424/**
2425 * regulator_register_supply_alias - Provide device alias for supply lookup
2426 *
2427 * @dev: device that will be given as the regulator "consumer"
2428 * @id: Supply name or regulator ID
2429 * @alias_dev: device that should be used to lookup the supply
2430 * @alias_id: Supply name or regulator ID that should be used to lookup the
2431 * supply
2432 *
2433 * All lookups for id on dev will instead be conducted for alias_id on
2434 * alias_dev.
2435 */
2436int regulator_register_supply_alias(struct device *dev, const char *id,
2437				    struct device *alias_dev,
2438				    const char *alias_id)
2439{
2440	struct regulator_supply_alias *map;
2441
2442	map = regulator_find_supply_alias(dev, id);
2443	if (map)
2444		return -EEXIST;
2445
2446	map = kzalloc(sizeof(struct regulator_supply_alias), GFP_KERNEL);
2447	if (!map)
2448		return -ENOMEM;
2449
2450	map->src_dev = dev;
2451	map->src_supply = id;
2452	map->alias_dev = alias_dev;
2453	map->alias_supply = alias_id;
2454
2455	list_add(&map->list, &regulator_supply_alias_list);
2456
2457	pr_info("Adding alias for supply %s,%s -> %s,%s\n",
2458		id, dev_name(dev), alias_id, dev_name(alias_dev));
2459
2460	return 0;
2461}
2462EXPORT_SYMBOL_GPL(regulator_register_supply_alias);
2463
2464/**
2465 * regulator_unregister_supply_alias - Remove device alias
2466 *
2467 * @dev: device that will be given as the regulator "consumer"
2468 * @id: Supply name or regulator ID
2469 *
2470 * Remove a lookup alias if one exists for id on dev.
2471 */
2472void regulator_unregister_supply_alias(struct device *dev, const char *id)
2473{
2474	struct regulator_supply_alias *map;
2475
2476	map = regulator_find_supply_alias(dev, id);
2477	if (map) {
2478		list_del(&map->list);
2479		kfree(map);
2480	}
2481}
2482EXPORT_SYMBOL_GPL(regulator_unregister_supply_alias);
2483
2484/**
2485 * regulator_bulk_register_supply_alias - register multiple aliases
2486 *
2487 * @dev: device that will be given as the regulator "consumer"
2488 * @id: List of supply names or regulator IDs
2489 * @alias_dev: device that should be used to lookup the supply
2490 * @alias_id: List of supply names or regulator IDs that should be used to
2491 * lookup the supply
2492 * @num_id: Number of aliases to register
2493 *
2494 * @return 0 on success, an errno on failure.
2495 *
2496 * This helper function allows drivers to register several supply
2497 * aliases in one operation.  If any of the aliases cannot be
2498 * registered any aliases that were registered will be removed
2499 * before returning to the caller.
2500 */
2501int regulator_bulk_register_supply_alias(struct device *dev,
2502					 const char *const *id,
2503					 struct device *alias_dev,
2504					 const char *const *alias_id,
2505					 int num_id)
2506{
2507	int i;
2508	int ret;
2509
2510	for (i = 0; i < num_id; ++i) {
2511		ret = regulator_register_supply_alias(dev, id[i], alias_dev,
2512						      alias_id[i]);
2513		if (ret < 0)
2514			goto err;
2515	}
2516
2517	return 0;
2518
2519err:
2520	dev_err(dev,
2521		"Failed to create supply alias %s,%s -> %s,%s\n",
2522		id[i], dev_name(dev), alias_id[i], dev_name(alias_dev));
2523
2524	while (--i >= 0)
2525		regulator_unregister_supply_alias(dev, id[i]);
2526
2527	return ret;
2528}
2529EXPORT_SYMBOL_GPL(regulator_bulk_register_supply_alias);
2530
2531/**
2532 * regulator_bulk_unregister_supply_alias - unregister multiple aliases
2533 *
2534 * @dev: device that will be given as the regulator "consumer"
2535 * @id: List of supply names or regulator IDs
2536 * @num_id: Number of aliases to unregister
2537 *
2538 * This helper function allows drivers to unregister several supply
2539 * aliases in one operation.
2540 */
2541void regulator_bulk_unregister_supply_alias(struct device *dev,
2542					    const char *const *id,
2543					    int num_id)
2544{
2545	int i;
2546
2547	for (i = 0; i < num_id; ++i)
2548		regulator_unregister_supply_alias(dev, id[i]);
2549}
2550EXPORT_SYMBOL_GPL(regulator_bulk_unregister_supply_alias);
2551
2552
2553/* Manage enable GPIO list. Same GPIO pin can be shared among regulators */
2554static int regulator_ena_gpio_request(struct regulator_dev *rdev,
2555				const struct regulator_config *config)
2556{
2557	struct regulator_enable_gpio *pin, *new_pin;
2558	struct gpio_desc *gpiod;
2559
2560	gpiod = config->ena_gpiod;
2561	new_pin = kzalloc(sizeof(*new_pin), GFP_KERNEL);
2562
2563	mutex_lock(&regulator_list_mutex);
 
2564
2565	list_for_each_entry(pin, &regulator_ena_gpio_list, list) {
2566		if (pin->gpiod == gpiod) {
2567			rdev_dbg(rdev, "GPIO is already used\n");
2568			goto update_ena_gpio_to_rdev;
2569		}
2570	}
2571
2572	if (new_pin == NULL) {
2573		mutex_unlock(&regulator_list_mutex);
2574		return -ENOMEM;
 
 
2575	}
 
 
 
2576
2577	pin = new_pin;
2578	new_pin = NULL;
2579
2580	pin->gpiod = gpiod;
2581	list_add(&pin->list, &regulator_ena_gpio_list);
2582
2583update_ena_gpio_to_rdev:
2584	pin->request_count++;
2585	rdev->ena_pin = pin;
2586
 
2587	mutex_unlock(&regulator_list_mutex);
2588	kfree(new_pin);
2589
2590	return 0;
2591}
2592
2593static void regulator_ena_gpio_free(struct regulator_dev *rdev)
2594{
2595	struct regulator_enable_gpio *pin, *n;
2596
2597	if (!rdev->ena_pin)
2598		return;
2599
2600	/* Free the GPIO only in case of no use */
2601	list_for_each_entry_safe(pin, n, &regulator_ena_gpio_list, list) {
2602		if (pin != rdev->ena_pin)
2603			continue;
2604
2605		if (--pin->request_count)
2606			break;
2607
2608		gpiod_put(pin->gpiod);
2609		list_del(&pin->list);
2610		kfree(pin);
2611		break;
2612	}
2613
2614	rdev->ena_pin = NULL;
2615}
 
2616
2617/**
2618 * regulator_ena_gpio_ctrl - balance enable_count of each GPIO and actual GPIO pin control
2619 * @rdev: regulator_dev structure
2620 * @enable: enable GPIO at initial use?
2621 *
2622 * GPIO is enabled in case of initial use. (enable_count is 0)
2623 * GPIO is disabled when it is not shared any more. (enable_count <= 1)
2624 */
2625static int regulator_ena_gpio_ctrl(struct regulator_dev *rdev, bool enable)
2626{
2627	struct regulator_enable_gpio *pin = rdev->ena_pin;
2628
2629	if (!pin)
2630		return -EINVAL;
2631
2632	if (enable) {
2633		/* Enable GPIO at initial use */
2634		if (pin->enable_count == 0)
2635			gpiod_set_value_cansleep(pin->gpiod, 1);
2636
2637		pin->enable_count++;
2638	} else {
2639		if (pin->enable_count > 1) {
2640			pin->enable_count--;
2641			return 0;
2642		}
2643
2644		/* Disable GPIO if not used */
2645		if (pin->enable_count <= 1) {
2646			gpiod_set_value_cansleep(pin->gpiod, 0);
2647			pin->enable_count = 0;
2648		}
2649	}
2650
2651	return 0;
2652}
2653
2654/**
2655 * _regulator_delay_helper - a delay helper function
2656 * @delay: time to delay in microseconds
2657 *
2658 * Delay for the requested amount of time as per the guidelines in:
2659 *
2660 *     Documentation/timers/timers-howto.rst
2661 *
2662 * The assumption here is that these regulator operations will never used in
2663 * atomic context and therefore sleeping functions can be used.
2664 */
2665static void _regulator_delay_helper(unsigned int delay)
2666{
2667	unsigned int ms = delay / 1000;
2668	unsigned int us = delay % 1000;
2669
2670	if (ms > 0) {
2671		/*
2672		 * For small enough values, handle super-millisecond
2673		 * delays in the usleep_range() call below.
2674		 */
2675		if (ms < 20)
2676			us += ms * 1000;
2677		else
2678			msleep(ms);
2679	}
2680
2681	/*
2682	 * Give the scheduler some room to coalesce with any other
2683	 * wakeup sources. For delays shorter than 10 us, don't even
2684	 * bother setting up high-resolution timers and just busy-
2685	 * loop.
2686	 */
2687	if (us >= 10)
2688		usleep_range(us, us + 100);
2689	else
2690		udelay(us);
2691}
2692
2693/**
2694 * _regulator_check_status_enabled
2695 *
2696 * A helper function to check if the regulator status can be interpreted
2697 * as 'regulator is enabled'.
2698 * @rdev: the regulator device to check
2699 *
2700 * Return:
2701 * * 1			- if status shows regulator is in enabled state
2702 * * 0			- if not enabled state
2703 * * Error Value	- as received from ops->get_status()
2704 */
2705static inline int _regulator_check_status_enabled(struct regulator_dev *rdev)
2706{
2707	int ret = rdev->desc->ops->get_status(rdev);
2708
2709	if (ret < 0) {
2710		rdev_info(rdev, "get_status returned error: %d\n", ret);
2711		return ret;
2712	}
2713
2714	switch (ret) {
2715	case REGULATOR_STATUS_OFF:
2716	case REGULATOR_STATUS_ERROR:
2717	case REGULATOR_STATUS_UNDEFINED:
2718		return 0;
2719	default:
2720		return 1;
2721	}
2722}
2723
2724static int _regulator_do_enable(struct regulator_dev *rdev)
 
2725{
2726	int ret, delay;
2727
2728	/* Query before enabling in case configuration dependent.  */
2729	ret = _regulator_get_enable_time(rdev);
2730	if (ret >= 0) {
2731		delay = ret;
2732	} else {
2733		rdev_warn(rdev, "enable_time() failed: %pe\n", ERR_PTR(ret));
2734		delay = 0;
2735	}
2736
2737	trace_regulator_enable(rdev_get_name(rdev));
 
 
 
 
 
2738
2739	if (rdev->desc->off_on_delay) {
2740		/* if needed, keep a distance of off_on_delay from last time
2741		 * this regulator was disabled.
2742		 */
2743		ktime_t end = ktime_add_us(rdev->last_off, rdev->desc->off_on_delay);
2744		s64 remaining = ktime_us_delta(end, ktime_get_boottime());
2745
2746		if (remaining > 0)
2747			_regulator_delay_helper(remaining);
2748	}
 
 
 
 
 
 
 
 
 
2749
2750	if (rdev->ena_pin) {
2751		if (!rdev->ena_gpio_state) {
2752			ret = regulator_ena_gpio_ctrl(rdev, true);
 
2753			if (ret < 0)
2754				return ret;
2755			rdev->ena_gpio_state = 1;
2756		}
2757	} else if (rdev->desc->ops->enable) {
2758		ret = rdev->desc->ops->enable(rdev);
2759		if (ret < 0)
2760			return ret;
2761	} else {
2762		return -EINVAL;
2763	}
2764
2765	/* Allow the regulator to ramp; it would be useful to extend
2766	 * this for bulk operations so that the regulators can ramp
2767	 * together.
2768	 */
2769	trace_regulator_enable_delay(rdev_get_name(rdev));
2770
2771	/* If poll_enabled_time is set, poll upto the delay calculated
2772	 * above, delaying poll_enabled_time uS to check if the regulator
2773	 * actually got enabled.
2774	 * If the regulator isn't enabled after our delay helper has expired,
2775	 * return -ETIMEDOUT.
2776	 */
2777	if (rdev->desc->poll_enabled_time) {
2778		int time_remaining = delay;
2779
2780		while (time_remaining > 0) {
2781			_regulator_delay_helper(rdev->desc->poll_enabled_time);
2782
2783			if (rdev->desc->ops->get_status) {
2784				ret = _regulator_check_status_enabled(rdev);
2785				if (ret < 0)
2786					return ret;
2787				else if (ret)
2788					break;
2789			} else if (rdev->desc->ops->is_enabled(rdev))
2790				break;
2791
2792			time_remaining -= rdev->desc->poll_enabled_time;
2793		}
2794
2795		if (time_remaining <= 0) {
2796			rdev_err(rdev, "Enabled check timed out\n");
2797			return -ETIMEDOUT;
2798		}
2799	} else {
2800		_regulator_delay_helper(delay);
2801	}
2802
2803	trace_regulator_enable_complete(rdev_get_name(rdev));
2804
2805	return 0;
2806}
2807
2808/**
2809 * _regulator_handle_consumer_enable - handle that a consumer enabled
2810 * @regulator: regulator source
2811 *
2812 * Some things on a regulator consumer (like the contribution towards total
2813 * load on the regulator) only have an effect when the consumer wants the
2814 * regulator enabled.  Explained in example with two consumers of the same
2815 * regulator:
2816 *   consumer A: set_load(100);       => total load = 0
2817 *   consumer A: regulator_enable();  => total load = 100
2818 *   consumer B: set_load(1000);      => total load = 100
2819 *   consumer B: regulator_enable();  => total load = 1100
2820 *   consumer A: regulator_disable(); => total_load = 1000
2821 *
2822 * This function (together with _regulator_handle_consumer_disable) is
2823 * responsible for keeping track of the refcount for a given regulator consumer
2824 * and applying / unapplying these things.
2825 *
2826 * Returns 0 upon no error; -error upon error.
2827 */
2828static int _regulator_handle_consumer_enable(struct regulator *regulator)
2829{
2830	int ret;
2831	struct regulator_dev *rdev = regulator->rdev;
2832
2833	lockdep_assert_held_once(&rdev->mutex.base);
2834
2835	regulator->enable_count++;
2836	if (regulator->uA_load && regulator->enable_count == 1) {
2837		ret = drms_uA_update(rdev);
2838		if (ret)
2839			regulator->enable_count--;
2840		return ret;
2841	}
2842
2843	return 0;
2844}
2845
2846/**
2847 * _regulator_handle_consumer_disable - handle that a consumer disabled
2848 * @regulator: regulator source
2849 *
2850 * The opposite of _regulator_handle_consumer_enable().
2851 *
2852 * Returns 0 upon no error; -error upon error.
2853 */
2854static int _regulator_handle_consumer_disable(struct regulator *regulator)
2855{
2856	struct regulator_dev *rdev = regulator->rdev;
2857
2858	lockdep_assert_held_once(&rdev->mutex.base);
2859
2860	if (!regulator->enable_count) {
2861		rdev_err(rdev, "Underflow of regulator enable count\n");
2862		return -EINVAL;
2863	}
2864
2865	regulator->enable_count--;
2866	if (regulator->uA_load && regulator->enable_count == 0)
2867		return drms_uA_update(rdev);
2868
2869	return 0;
2870}
2871
2872/* locks held by regulator_enable() */
2873static int _regulator_enable(struct regulator *regulator)
2874{
2875	struct regulator_dev *rdev = regulator->rdev;
2876	int ret;
2877
2878	lockdep_assert_held_once(&rdev->mutex.base);
2879
2880	if (rdev->use_count == 0 && rdev->supply) {
2881		ret = _regulator_enable(rdev->supply);
2882		if (ret < 0)
2883			return ret;
2884	}
2885
2886	/* balance only if there are regulators coupled */
2887	if (rdev->coupling_desc.n_coupled > 1) {
2888		ret = regulator_balance_voltage(rdev, PM_SUSPEND_ON);
2889		if (ret < 0)
2890			goto err_disable_supply;
2891	}
2892
2893	ret = _regulator_handle_consumer_enable(regulator);
2894	if (ret < 0)
2895		goto err_disable_supply;
2896
2897	if (rdev->use_count == 0) {
2898		/*
2899		 * The regulator may already be enabled if it's not switchable
2900		 * or was left on
2901		 */
2902		ret = _regulator_is_enabled(rdev);
2903		if (ret == -EINVAL || ret == 0) {
2904			if (!regulator_ops_is_valid(rdev,
2905					REGULATOR_CHANGE_STATUS)) {
2906				ret = -EPERM;
2907				goto err_consumer_disable;
2908			}
2909
2910			ret = _regulator_do_enable(rdev);
2911			if (ret < 0)
2912				goto err_consumer_disable;
2913
2914			_notifier_call_chain(rdev, REGULATOR_EVENT_ENABLE,
2915					     NULL);
2916		} else if (ret < 0) {
2917			rdev_err(rdev, "is_enabled() failed: %pe\n", ERR_PTR(ret));
2918			goto err_consumer_disable;
2919		}
2920		/* Fallthrough on positive return values - already enabled */
2921	}
2922
2923	if (regulator->enable_count == 1)
2924		rdev->use_count++;
2925
2926	return 0;
2927
2928err_consumer_disable:
2929	_regulator_handle_consumer_disable(regulator);
2930
2931err_disable_supply:
2932	if (rdev->use_count == 0 && rdev->supply)
2933		_regulator_disable(rdev->supply);
2934
2935	return ret;
2936}
2937
2938/**
2939 * regulator_enable - enable regulator output
2940 * @regulator: regulator source
2941 *
2942 * Request that the regulator be enabled with the regulator output at
2943 * the predefined voltage or current value.  Calls to regulator_enable()
2944 * must be balanced with calls to regulator_disable().
2945 *
2946 * NOTE: the output value can be set by other drivers, boot loader or may be
2947 * hardwired in the regulator.
2948 */
2949int regulator_enable(struct regulator *regulator)
2950{
2951	struct regulator_dev *rdev = regulator->rdev;
2952	struct ww_acquire_ctx ww_ctx;
2953	int ret;
2954
2955	regulator_lock_dependent(rdev, &ww_ctx);
2956	ret = _regulator_enable(regulator);
2957	regulator_unlock_dependent(rdev, &ww_ctx);
2958
2959	return ret;
2960}
2961EXPORT_SYMBOL_GPL(regulator_enable);
2962
2963static int _regulator_do_disable(struct regulator_dev *rdev)
2964{
2965	int ret;
2966
2967	trace_regulator_disable(rdev_get_name(rdev));
2968
2969	if (rdev->ena_pin) {
2970		if (rdev->ena_gpio_state) {
2971			ret = regulator_ena_gpio_ctrl(rdev, false);
2972			if (ret < 0)
2973				return ret;
2974			rdev->ena_gpio_state = 0;
2975		}
2976
2977	} else if (rdev->desc->ops->disable) {
2978		ret = rdev->desc->ops->disable(rdev);
2979		if (ret != 0)
2980			return ret;
2981	}
2982
2983	if (rdev->desc->off_on_delay)
2984		rdev->last_off = ktime_get_boottime();
 
2985
2986	trace_regulator_disable_complete(rdev_get_name(rdev));
 
2987
2988	return 0;
2989}
 
2990
2991/* locks held by regulator_disable() */
2992static int _regulator_disable(struct regulator *regulator)
2993{
2994	struct regulator_dev *rdev = regulator->rdev;
2995	int ret = 0;
2996
2997	lockdep_assert_held_once(&rdev->mutex.base);
2998
2999	if (WARN(regulator->enable_count == 0,
3000		 "unbalanced disables for %s\n", rdev_get_name(rdev)))
3001		return -EIO;
3002
3003	if (regulator->enable_count == 1) {
3004	/* disabling last enable_count from this regulator */
3005		/* are we the last user and permitted to disable ? */
3006		if (rdev->use_count == 1 &&
3007		    (rdev->constraints && !rdev->constraints->always_on)) {
3008
3009			/* we are last user */
3010			if (regulator_ops_is_valid(rdev, REGULATOR_CHANGE_STATUS)) {
3011				ret = _notifier_call_chain(rdev,
3012							   REGULATOR_EVENT_PRE_DISABLE,
3013							   NULL);
3014				if (ret & NOTIFY_STOP_MASK)
3015					return -EINVAL;
3016
3017				ret = _regulator_do_disable(rdev);
3018				if (ret < 0) {
3019					rdev_err(rdev, "failed to disable: %pe\n", ERR_PTR(ret));
3020					_notifier_call_chain(rdev,
3021							REGULATOR_EVENT_ABORT_DISABLE,
3022							NULL);
3023					return ret;
3024				}
3025				_notifier_call_chain(rdev, REGULATOR_EVENT_DISABLE,
3026						NULL);
3027			}
3028
3029			rdev->use_count = 0;
3030		} else if (rdev->use_count > 1) {
3031			rdev->use_count--;
 
3032		}
3033	}
3034
3035	if (ret == 0)
3036		ret = _regulator_handle_consumer_disable(regulator);
3037
3038	if (ret == 0 && rdev->coupling_desc.n_coupled > 1)
3039		ret = regulator_balance_voltage(rdev, PM_SUSPEND_ON);
 
 
3040
3041	if (ret == 0 && rdev->use_count == 0 && rdev->supply)
3042		ret = _regulator_disable(rdev->supply);
3043
3044	return ret;
3045}
3046
3047/**
3048 * regulator_disable - disable regulator output
3049 * @regulator: regulator source
3050 *
3051 * Disable the regulator output voltage or current.  Calls to
3052 * regulator_enable() must be balanced with calls to
3053 * regulator_disable().
3054 *
3055 * NOTE: this will only disable the regulator output if no other consumer
3056 * devices have it enabled, the regulator device supports disabling and
3057 * machine constraints permit this operation.
3058 */
3059int regulator_disable(struct regulator *regulator)
3060{
3061	struct regulator_dev *rdev = regulator->rdev;
3062	struct ww_acquire_ctx ww_ctx;
3063	int ret;
3064
3065	regulator_lock_dependent(rdev, &ww_ctx);
3066	ret = _regulator_disable(regulator);
3067	regulator_unlock_dependent(rdev, &ww_ctx);
 
 
 
3068
3069	return ret;
3070}
3071EXPORT_SYMBOL_GPL(regulator_disable);
3072
3073/* locks held by regulator_force_disable() */
3074static int _regulator_force_disable(struct regulator_dev *rdev)
3075{
3076	int ret = 0;
3077
3078	lockdep_assert_held_once(&rdev->mutex.base);
3079
3080	ret = _notifier_call_chain(rdev, REGULATOR_EVENT_FORCE_DISABLE |
3081			REGULATOR_EVENT_PRE_DISABLE, NULL);
3082	if (ret & NOTIFY_STOP_MASK)
3083		return -EINVAL;
3084
3085	ret = _regulator_do_disable(rdev);
3086	if (ret < 0) {
3087		rdev_err(rdev, "failed to force disable: %pe\n", ERR_PTR(ret));
3088		_notifier_call_chain(rdev, REGULATOR_EVENT_FORCE_DISABLE |
3089				REGULATOR_EVENT_ABORT_DISABLE, NULL);
3090		return ret;
3091	}
3092
3093	_notifier_call_chain(rdev, REGULATOR_EVENT_FORCE_DISABLE |
3094			REGULATOR_EVENT_DISABLE, NULL);
 
3095
3096	return 0;
3097}
3098
3099/**
3100 * regulator_force_disable - force disable regulator output
3101 * @regulator: regulator source
3102 *
3103 * Forcibly disable the regulator output voltage or current.
3104 * NOTE: this *will* disable the regulator output even if other consumer
3105 * devices have it enabled. This should be used for situations when device
3106 * damage will likely occur if the regulator is not disabled (e.g. over temp).
3107 */
3108int regulator_force_disable(struct regulator *regulator)
3109{
3110	struct regulator_dev *rdev = regulator->rdev;
3111	struct ww_acquire_ctx ww_ctx;
3112	int ret;
3113
3114	regulator_lock_dependent(rdev, &ww_ctx);
3115
3116	ret = _regulator_force_disable(regulator->rdev);
 
3117
3118	if (rdev->coupling_desc.n_coupled > 1)
3119		regulator_balance_voltage(rdev, PM_SUSPEND_ON);
3120
3121	if (regulator->uA_load) {
3122		regulator->uA_load = 0;
3123		ret = drms_uA_update(rdev);
3124	}
3125
3126	if (rdev->use_count != 0 && rdev->supply)
3127		_regulator_disable(rdev->supply);
3128
3129	regulator_unlock_dependent(rdev, &ww_ctx);
3130
3131	return ret;
3132}
3133EXPORT_SYMBOL_GPL(regulator_force_disable);
3134
3135static void regulator_disable_work(struct work_struct *work)
3136{
3137	struct regulator_dev *rdev = container_of(work, struct regulator_dev,
3138						  disable_work.work);
3139	struct ww_acquire_ctx ww_ctx;
3140	int count, i, ret;
3141	struct regulator *regulator;
3142	int total_count = 0;
3143
3144	regulator_lock_dependent(rdev, &ww_ctx);
3145
3146	/*
3147	 * Workqueue functions queue the new work instance while the previous
3148	 * work instance is being processed. Cancel the queued work instance
3149	 * as the work instance under processing does the job of the queued
3150	 * work instance.
3151	 */
3152	cancel_delayed_work(&rdev->disable_work);
3153
3154	list_for_each_entry(regulator, &rdev->consumer_list, list) {
3155		count = regulator->deferred_disables;
3156
3157		if (!count)
3158			continue;
3159
3160		total_count += count;
3161		regulator->deferred_disables = 0;
3162
3163		for (i = 0; i < count; i++) {
3164			ret = _regulator_disable(regulator);
3165			if (ret != 0)
3166				rdev_err(rdev, "Deferred disable failed: %pe\n",
3167					 ERR_PTR(ret));
3168		}
3169	}
3170	WARN_ON(!total_count);
3171
3172	if (rdev->coupling_desc.n_coupled > 1)
3173		regulator_balance_voltage(rdev, PM_SUSPEND_ON);
3174
3175	regulator_unlock_dependent(rdev, &ww_ctx);
3176}
3177
3178/**
3179 * regulator_disable_deferred - disable regulator output with delay
3180 * @regulator: regulator source
3181 * @ms: milliseconds until the regulator is disabled
3182 *
3183 * Execute regulator_disable() on the regulator after a delay.  This
3184 * is intended for use with devices that require some time to quiesce.
3185 *
3186 * NOTE: this will only disable the regulator output if no other consumer
3187 * devices have it enabled, the regulator device supports disabling and
3188 * machine constraints permit this operation.
3189 */
3190int regulator_disable_deferred(struct regulator *regulator, int ms)
3191{
3192	struct regulator_dev *rdev = regulator->rdev;
3193
3194	if (!ms)
3195		return regulator_disable(regulator);
3196
3197	regulator_lock(rdev);
3198	regulator->deferred_disables++;
3199	mod_delayed_work(system_power_efficient_wq, &rdev->disable_work,
3200			 msecs_to_jiffies(ms));
3201	regulator_unlock(rdev);
3202
3203	return 0;
3204}
3205EXPORT_SYMBOL_GPL(regulator_disable_deferred);
3206
3207static int _regulator_is_enabled(struct regulator_dev *rdev)
3208{
3209	/* A GPIO control always takes precedence */
3210	if (rdev->ena_pin)
3211		return rdev->ena_gpio_state;
3212
3213	/* If we don't know then assume that the regulator is always on */
3214	if (!rdev->desc->ops->is_enabled)
3215		return 1;
3216
3217	return rdev->desc->ops->is_enabled(rdev);
3218}
3219
3220static int _regulator_list_voltage(struct regulator_dev *rdev,
3221				   unsigned selector, int lock)
3222{
3223	const struct regulator_ops *ops = rdev->desc->ops;
3224	int ret;
3225
3226	if (rdev->desc->fixed_uV && rdev->desc->n_voltages == 1 && !selector)
3227		return rdev->desc->fixed_uV;
3228
3229	if (ops->list_voltage) {
3230		if (selector >= rdev->desc->n_voltages)
3231			return -EINVAL;
3232		if (selector < rdev->desc->linear_min_sel)
3233			return 0;
3234		if (lock)
3235			regulator_lock(rdev);
3236		ret = ops->list_voltage(rdev, selector);
3237		if (lock)
3238			regulator_unlock(rdev);
3239	} else if (rdev->is_switch && rdev->supply) {
3240		ret = _regulator_list_voltage(rdev->supply->rdev,
3241					      selector, lock);
3242	} else {
3243		return -EINVAL;
3244	}
3245
3246	if (ret > 0) {
3247		if (ret < rdev->constraints->min_uV)
3248			ret = 0;
3249		else if (ret > rdev->constraints->max_uV)
3250			ret = 0;
3251	}
3252
3253	return ret;
3254}
3255
3256/**
3257 * regulator_is_enabled - is the regulator output enabled
3258 * @regulator: regulator source
3259 *
3260 * Returns positive if the regulator driver backing the source/client
3261 * has requested that the device be enabled, zero if it hasn't, else a
3262 * negative errno code.
3263 *
3264 * Note that the device backing this regulator handle can have multiple
3265 * users, so it might be enabled even if regulator_enable() was never
3266 * called for this particular source.
3267 */
3268int regulator_is_enabled(struct regulator *regulator)
3269{
3270	int ret;
3271
3272	if (regulator->always_on)
3273		return 1;
3274
3275	regulator_lock(regulator->rdev);
3276	ret = _regulator_is_enabled(regulator->rdev);
3277	regulator_unlock(regulator->rdev);
3278
3279	return ret;
3280}
3281EXPORT_SYMBOL_GPL(regulator_is_enabled);
3282
3283/**
3284 * regulator_count_voltages - count regulator_list_voltage() selectors
3285 * @regulator: regulator source
3286 *
3287 * Returns number of selectors, or negative errno.  Selectors are
3288 * numbered starting at zero, and typically correspond to bitfields
3289 * in hardware registers.
3290 */
3291int regulator_count_voltages(struct regulator *regulator)
3292{
3293	struct regulator_dev	*rdev = regulator->rdev;
3294
3295	if (rdev->desc->n_voltages)
3296		return rdev->desc->n_voltages;
3297
3298	if (!rdev->is_switch || !rdev->supply)
3299		return -EINVAL;
3300
3301	return regulator_count_voltages(rdev->supply);
3302}
3303EXPORT_SYMBOL_GPL(regulator_count_voltages);
3304
3305/**
3306 * regulator_list_voltage - enumerate supported voltages
3307 * @regulator: regulator source
3308 * @selector: identify voltage to list
3309 * Context: can sleep
3310 *
3311 * Returns a voltage that can be passed to @regulator_set_voltage(),
3312 * zero if this selector code can't be used on this system, or a
3313 * negative errno.
3314 */
3315int regulator_list_voltage(struct regulator *regulator, unsigned selector)
3316{
3317	return _regulator_list_voltage(regulator->rdev, selector, 1);
3318}
3319EXPORT_SYMBOL_GPL(regulator_list_voltage);
3320
3321/**
3322 * regulator_get_regmap - get the regulator's register map
3323 * @regulator: regulator source
3324 *
3325 * Returns the register map for the given regulator, or an ERR_PTR value
3326 * if the regulator doesn't use regmap.
3327 */
3328struct regmap *regulator_get_regmap(struct regulator *regulator)
3329{
3330	struct regmap *map = regulator->rdev->regmap;
3331
3332	return map ? map : ERR_PTR(-EOPNOTSUPP);
3333}
3334
3335/**
3336 * regulator_get_hardware_vsel_register - get the HW voltage selector register
3337 * @regulator: regulator source
3338 * @vsel_reg: voltage selector register, output parameter
3339 * @vsel_mask: mask for voltage selector bitfield, output parameter
3340 *
3341 * Returns the hardware register offset and bitmask used for setting the
3342 * regulator voltage. This might be useful when configuring voltage-scaling
3343 * hardware or firmware that can make I2C requests behind the kernel's back,
3344 * for example.
3345 *
3346 * On success, the output parameters @vsel_reg and @vsel_mask are filled in
3347 * and 0 is returned, otherwise a negative errno is returned.
3348 */
3349int regulator_get_hardware_vsel_register(struct regulator *regulator,
3350					 unsigned *vsel_reg,
3351					 unsigned *vsel_mask)
3352{
3353	struct regulator_dev *rdev = regulator->rdev;
3354	const struct regulator_ops *ops = rdev->desc->ops;
3355
3356	if (ops->set_voltage_sel != regulator_set_voltage_sel_regmap)
3357		return -EOPNOTSUPP;
3358
3359	*vsel_reg = rdev->desc->vsel_reg;
3360	*vsel_mask = rdev->desc->vsel_mask;
3361
3362	return 0;
3363}
3364EXPORT_SYMBOL_GPL(regulator_get_hardware_vsel_register);
3365
3366/**
3367 * regulator_list_hardware_vsel - get the HW-specific register value for a selector
3368 * @regulator: regulator source
3369 * @selector: identify voltage to list
3370 *
3371 * Converts the selector to a hardware-specific voltage selector that can be
3372 * directly written to the regulator registers. The address of the voltage
3373 * register can be determined by calling @regulator_get_hardware_vsel_register.
3374 *
3375 * On error a negative errno is returned.
3376 */
3377int regulator_list_hardware_vsel(struct regulator *regulator,
3378				 unsigned selector)
3379{
3380	struct regulator_dev *rdev = regulator->rdev;
3381	const struct regulator_ops *ops = rdev->desc->ops;
3382
3383	if (selector >= rdev->desc->n_voltages)
3384		return -EINVAL;
3385	if (selector < rdev->desc->linear_min_sel)
3386		return 0;
3387	if (ops->set_voltage_sel != regulator_set_voltage_sel_regmap)
3388		return -EOPNOTSUPP;
3389
3390	return selector;
3391}
3392EXPORT_SYMBOL_GPL(regulator_list_hardware_vsel);
3393
3394/**
3395 * regulator_get_linear_step - return the voltage step size between VSEL values
3396 * @regulator: regulator source
3397 *
3398 * Returns the voltage step size between VSEL values for linear
3399 * regulators, or return 0 if the regulator isn't a linear regulator.
3400 */
3401unsigned int regulator_get_linear_step(struct regulator *regulator)
3402{
3403	struct regulator_dev *rdev = regulator->rdev;
3404
3405	return rdev->desc->uV_step;
3406}
3407EXPORT_SYMBOL_GPL(regulator_get_linear_step);
3408
3409/**
3410 * regulator_is_supported_voltage - check if a voltage range can be supported
3411 *
3412 * @regulator: Regulator to check.
3413 * @min_uV: Minimum required voltage in uV.
3414 * @max_uV: Maximum required voltage in uV.
3415 *
3416 * Returns a boolean.
3417 */
3418int regulator_is_supported_voltage(struct regulator *regulator,
3419				   int min_uV, int max_uV)
3420{
3421	struct regulator_dev *rdev = regulator->rdev;
3422	int i, voltages, ret;
3423
3424	/* If we can't change voltage check the current voltage */
3425	if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_VOLTAGE)) {
3426		ret = regulator_get_voltage(regulator);
3427		if (ret >= 0)
3428			return min_uV <= ret && ret <= max_uV;
3429		else
3430			return ret;
3431	}
3432
3433	/* Any voltage within constrains range is fine? */
3434	if (rdev->desc->continuous_voltage_range)
3435		return min_uV >= rdev->constraints->min_uV &&
3436				max_uV <= rdev->constraints->max_uV;
3437
3438	ret = regulator_count_voltages(regulator);
3439	if (ret < 0)
3440		return 0;
3441	voltages = ret;
3442
3443	for (i = 0; i < voltages; i++) {
3444		ret = regulator_list_voltage(regulator, i);
3445
3446		if (ret >= min_uV && ret <= max_uV)
3447			return 1;
3448	}
3449
3450	return 0;
3451}
3452EXPORT_SYMBOL_GPL(regulator_is_supported_voltage);
3453
3454static int regulator_map_voltage(struct regulator_dev *rdev, int min_uV,
3455				 int max_uV)
3456{
3457	const struct regulator_desc *desc = rdev->desc;
3458
3459	if (desc->ops->map_voltage)
3460		return desc->ops->map_voltage(rdev, min_uV, max_uV);
3461
3462	if (desc->ops->list_voltage == regulator_list_voltage_linear)
3463		return regulator_map_voltage_linear(rdev, min_uV, max_uV);
3464
3465	if (desc->ops->list_voltage == regulator_list_voltage_linear_range)
3466		return regulator_map_voltage_linear_range(rdev, min_uV, max_uV);
3467
3468	if (desc->ops->list_voltage ==
3469		regulator_list_voltage_pickable_linear_range)
3470		return regulator_map_voltage_pickable_linear_range(rdev,
3471							min_uV, max_uV);
3472
3473	return regulator_map_voltage_iterate(rdev, min_uV, max_uV);
3474}
3475
3476static int _regulator_call_set_voltage(struct regulator_dev *rdev,
3477				       int min_uV, int max_uV,
3478				       unsigned *selector)
3479{
3480	struct pre_voltage_change_data data;
3481	int ret;
3482
3483	data.old_uV = regulator_get_voltage_rdev(rdev);
3484	data.min_uV = min_uV;
3485	data.max_uV = max_uV;
3486	ret = _notifier_call_chain(rdev, REGULATOR_EVENT_PRE_VOLTAGE_CHANGE,
3487				   &data);
3488	if (ret & NOTIFY_STOP_MASK)
3489		return -EINVAL;
3490
3491	ret = rdev->desc->ops->set_voltage(rdev, min_uV, max_uV, selector);
3492	if (ret >= 0)
3493		return ret;
3494
3495	_notifier_call_chain(rdev, REGULATOR_EVENT_ABORT_VOLTAGE_CHANGE,
3496			     (void *)data.old_uV);
3497
3498	return ret;
3499}
3500
3501static int _regulator_call_set_voltage_sel(struct regulator_dev *rdev,
3502					   int uV, unsigned selector)
3503{
3504	struct pre_voltage_change_data data;
3505	int ret;
3506
3507	data.old_uV = regulator_get_voltage_rdev(rdev);
3508	data.min_uV = uV;
3509	data.max_uV = uV;
3510	ret = _notifier_call_chain(rdev, REGULATOR_EVENT_PRE_VOLTAGE_CHANGE,
3511				   &data);
3512	if (ret & NOTIFY_STOP_MASK)
3513		return -EINVAL;
3514
3515	ret = rdev->desc->ops->set_voltage_sel(rdev, selector);
3516	if (ret >= 0)
3517		return ret;
3518
3519	_notifier_call_chain(rdev, REGULATOR_EVENT_ABORT_VOLTAGE_CHANGE,
3520			     (void *)data.old_uV);
3521
3522	return ret;
3523}
3524
3525static int _regulator_set_voltage_sel_step(struct regulator_dev *rdev,
3526					   int uV, int new_selector)
3527{
3528	const struct regulator_ops *ops = rdev->desc->ops;
3529	int diff, old_sel, curr_sel, ret;
3530
3531	/* Stepping is only needed if the regulator is enabled. */
3532	if (!_regulator_is_enabled(rdev))
3533		goto final_set;
3534
3535	if (!ops->get_voltage_sel)
3536		return -EINVAL;
3537
3538	old_sel = ops->get_voltage_sel(rdev);
3539	if (old_sel < 0)
3540		return old_sel;
3541
3542	diff = new_selector - old_sel;
3543	if (diff == 0)
3544		return 0; /* No change needed. */
3545
3546	if (diff > 0) {
3547		/* Stepping up. */
3548		for (curr_sel = old_sel + rdev->desc->vsel_step;
3549		     curr_sel < new_selector;
3550		     curr_sel += rdev->desc->vsel_step) {
3551			/*
3552			 * Call the callback directly instead of using
3553			 * _regulator_call_set_voltage_sel() as we don't
3554			 * want to notify anyone yet. Same in the branch
3555			 * below.
3556			 */
3557			ret = ops->set_voltage_sel(rdev, curr_sel);
3558			if (ret)
3559				goto try_revert;
3560		}
3561	} else {
3562		/* Stepping down. */
3563		for (curr_sel = old_sel - rdev->desc->vsel_step;
3564		     curr_sel > new_selector;
3565		     curr_sel -= rdev->desc->vsel_step) {
3566			ret = ops->set_voltage_sel(rdev, curr_sel);
3567			if (ret)
3568				goto try_revert;
3569		}
3570	}
3571
3572final_set:
3573	/* The final selector will trigger the notifiers. */
3574	return _regulator_call_set_voltage_sel(rdev, uV, new_selector);
3575
3576try_revert:
3577	/*
3578	 * At least try to return to the previous voltage if setting a new
3579	 * one failed.
3580	 */
3581	(void)ops->set_voltage_sel(rdev, old_sel);
3582	return ret;
3583}
3584
3585static int _regulator_set_voltage_time(struct regulator_dev *rdev,
3586				       int old_uV, int new_uV)
3587{
3588	unsigned int ramp_delay = 0;
3589
3590	if (rdev->constraints->ramp_delay)
3591		ramp_delay = rdev->constraints->ramp_delay;
3592	else if (rdev->desc->ramp_delay)
3593		ramp_delay = rdev->desc->ramp_delay;
3594	else if (rdev->constraints->settling_time)
3595		return rdev->constraints->settling_time;
3596	else if (rdev->constraints->settling_time_up &&
3597		 (new_uV > old_uV))
3598		return rdev->constraints->settling_time_up;
3599	else if (rdev->constraints->settling_time_down &&
3600		 (new_uV < old_uV))
3601		return rdev->constraints->settling_time_down;
3602
3603	if (ramp_delay == 0)
3604		return 0;
3605
3606	return DIV_ROUND_UP(abs(new_uV - old_uV), ramp_delay);
3607}
3608
3609static int _regulator_do_set_voltage(struct regulator_dev *rdev,
3610				     int min_uV, int max_uV)
3611{
3612	int ret;
3613	int delay = 0;
3614	int best_val = 0;
3615	unsigned int selector;
3616	int old_selector = -1;
3617	const struct regulator_ops *ops = rdev->desc->ops;
3618	int old_uV = regulator_get_voltage_rdev(rdev);
3619
3620	trace_regulator_set_voltage(rdev_get_name(rdev), min_uV, max_uV);
3621
3622	min_uV += rdev->constraints->uV_offset;
3623	max_uV += rdev->constraints->uV_offset;
3624
3625	/*
3626	 * If we can't obtain the old selector there is not enough
3627	 * info to call set_voltage_time_sel().
3628	 */
3629	if (_regulator_is_enabled(rdev) &&
3630	    ops->set_voltage_time_sel && ops->get_voltage_sel) {
3631		old_selector = ops->get_voltage_sel(rdev);
3632		if (old_selector < 0)
3633			return old_selector;
3634	}
3635
3636	if (ops->set_voltage) {
3637		ret = _regulator_call_set_voltage(rdev, min_uV, max_uV,
3638						  &selector);
3639
3640		if (ret >= 0) {
3641			if (ops->list_voltage)
3642				best_val = ops->list_voltage(rdev,
3643							     selector);
3644			else
3645				best_val = regulator_get_voltage_rdev(rdev);
3646		}
3647
3648	} else if (ops->set_voltage_sel) {
3649		ret = regulator_map_voltage(rdev, min_uV, max_uV);
3650		if (ret >= 0) {
3651			best_val = ops->list_voltage(rdev, ret);
3652			if (min_uV <= best_val && max_uV >= best_val) {
3653				selector = ret;
3654				if (old_selector == selector)
3655					ret = 0;
3656				else if (rdev->desc->vsel_step)
3657					ret = _regulator_set_voltage_sel_step(
3658						rdev, best_val, selector);
3659				else
3660					ret = _regulator_call_set_voltage_sel(
3661						rdev, best_val, selector);
3662			} else {
3663				ret = -EINVAL;
3664			}
3665		}
3666	} else {
3667		ret = -EINVAL;
3668	}
3669
3670	if (ret)
3671		goto out;
3672
3673	if (ops->set_voltage_time_sel) {
3674		/*
3675		 * Call set_voltage_time_sel if successfully obtained
3676		 * old_selector
3677		 */
3678		if (old_selector >= 0 && old_selector != selector)
3679			delay = ops->set_voltage_time_sel(rdev, old_selector,
3680							  selector);
3681	} else {
3682		if (old_uV != best_val) {
3683			if (ops->set_voltage_time)
3684				delay = ops->set_voltage_time(rdev, old_uV,
3685							      best_val);
3686			else
3687				delay = _regulator_set_voltage_time(rdev,
3688								    old_uV,
3689								    best_val);
3690		}
3691	}
3692
3693	if (delay < 0) {
3694		rdev_warn(rdev, "failed to get delay: %pe\n", ERR_PTR(delay));
3695		delay = 0;
3696	}
3697
3698	/* Insert any necessary delays */
3699	_regulator_delay_helper(delay);
3700
3701	if (best_val >= 0) {
3702		unsigned long data = best_val;
3703
3704		_notifier_call_chain(rdev, REGULATOR_EVENT_VOLTAGE_CHANGE,
3705				     (void *)data);
3706	}
3707
3708out:
3709	trace_regulator_set_voltage_complete(rdev_get_name(rdev), best_val);
3710
3711	return ret;
3712}
3713
3714static int _regulator_do_set_suspend_voltage(struct regulator_dev *rdev,
3715				  int min_uV, int max_uV, suspend_state_t state)
3716{
3717	struct regulator_state *rstate;
3718	int uV, sel;
3719
3720	rstate = regulator_get_suspend_state(rdev, state);
3721	if (rstate == NULL)
3722		return -EINVAL;
3723
3724	if (min_uV < rstate->min_uV)
3725		min_uV = rstate->min_uV;
3726	if (max_uV > rstate->max_uV)
3727		max_uV = rstate->max_uV;
3728
3729	sel = regulator_map_voltage(rdev, min_uV, max_uV);
3730	if (sel < 0)
3731		return sel;
3732
3733	uV = rdev->desc->ops->list_voltage(rdev, sel);
3734	if (uV >= min_uV && uV <= max_uV)
3735		rstate->uV = uV;
3736
3737	return 0;
3738}
3739
3740static int regulator_set_voltage_unlocked(struct regulator *regulator,
3741					  int min_uV, int max_uV,
3742					  suspend_state_t state)
3743{
3744	struct regulator_dev *rdev = regulator->rdev;
3745	struct regulator_voltage *voltage = &regulator->voltage[state];
3746	int ret = 0;
3747	int old_min_uV, old_max_uV;
3748	int current_uV;
3749
3750	/* If we're setting the same range as last time the change
3751	 * should be a noop (some cpufreq implementations use the same
3752	 * voltage for multiple frequencies, for example).
3753	 */
3754	if (voltage->min_uV == min_uV && voltage->max_uV == max_uV)
3755		goto out;
3756
3757	/* If we're trying to set a range that overlaps the current voltage,
3758	 * return successfully even though the regulator does not support
3759	 * changing the voltage.
3760	 */
3761	if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_VOLTAGE)) {
3762		current_uV = regulator_get_voltage_rdev(rdev);
3763		if (min_uV <= current_uV && current_uV <= max_uV) {
3764			voltage->min_uV = min_uV;
3765			voltage->max_uV = max_uV;
3766			goto out;
3767		}
3768	}
3769
3770	/* sanity check */
3771	if (!rdev->desc->ops->set_voltage &&
3772	    !rdev->desc->ops->set_voltage_sel) {
3773		ret = -EINVAL;
3774		goto out;
3775	}
3776
3777	/* constraints check */
3778	ret = regulator_check_voltage(rdev, &min_uV, &max_uV);
3779	if (ret < 0)
3780		goto out;
3781
3782	/* restore original values in case of error */
3783	old_min_uV = voltage->min_uV;
3784	old_max_uV = voltage->max_uV;
3785	voltage->min_uV = min_uV;
3786	voltage->max_uV = max_uV;
3787
3788	/* for not coupled regulators this will just set the voltage */
3789	ret = regulator_balance_voltage(rdev, state);
3790	if (ret < 0) {
3791		voltage->min_uV = old_min_uV;
3792		voltage->max_uV = old_max_uV;
3793	}
3794
3795out:
3796	return ret;
3797}
3798
3799int regulator_set_voltage_rdev(struct regulator_dev *rdev, int min_uV,
3800			       int max_uV, suspend_state_t state)
3801{
3802	int best_supply_uV = 0;
3803	int supply_change_uV = 0;
3804	int ret;
3805
3806	if (rdev->supply &&
3807	    regulator_ops_is_valid(rdev->supply->rdev,
3808				   REGULATOR_CHANGE_VOLTAGE) &&
3809	    (rdev->desc->min_dropout_uV || !(rdev->desc->ops->get_voltage ||
3810					   rdev->desc->ops->get_voltage_sel))) {
3811		int current_supply_uV;
3812		int selector;
3813
3814		selector = regulator_map_voltage(rdev, min_uV, max_uV);
3815		if (selector < 0) {
3816			ret = selector;
3817			goto out;
3818		}
3819
3820		best_supply_uV = _regulator_list_voltage(rdev, selector, 0);
3821		if (best_supply_uV < 0) {
3822			ret = best_supply_uV;
3823			goto out;
3824		}
3825
3826		best_supply_uV += rdev->desc->min_dropout_uV;
3827
3828		current_supply_uV = regulator_get_voltage_rdev(rdev->supply->rdev);
3829		if (current_supply_uV < 0) {
3830			ret = current_supply_uV;
3831			goto out;
3832		}
3833
3834		supply_change_uV = best_supply_uV - current_supply_uV;
3835	}
3836
3837	if (supply_change_uV > 0) {
3838		ret = regulator_set_voltage_unlocked(rdev->supply,
3839				best_supply_uV, INT_MAX, state);
3840		if (ret) {
3841			dev_err(&rdev->dev, "Failed to increase supply voltage: %pe\n",
3842				ERR_PTR(ret));
3843			goto out;
3844		}
3845	}
3846
3847	if (state == PM_SUSPEND_ON)
3848		ret = _regulator_do_set_voltage(rdev, min_uV, max_uV);
3849	else
3850		ret = _regulator_do_set_suspend_voltage(rdev, min_uV,
3851							max_uV, state);
3852	if (ret < 0)
3853		goto out;
3854
3855	if (supply_change_uV < 0) {
3856		ret = regulator_set_voltage_unlocked(rdev->supply,
3857				best_supply_uV, INT_MAX, state);
3858		if (ret)
3859			dev_warn(&rdev->dev, "Failed to decrease supply voltage: %pe\n",
3860				 ERR_PTR(ret));
3861		/* No need to fail here */
3862		ret = 0;
3863	}
3864
3865out:
3866	return ret;
3867}
3868EXPORT_SYMBOL_GPL(regulator_set_voltage_rdev);
3869
3870static int regulator_limit_voltage_step(struct regulator_dev *rdev,
3871					int *current_uV, int *min_uV)
3872{
3873	struct regulation_constraints *constraints = rdev->constraints;
3874
3875	/* Limit voltage change only if necessary */
3876	if (!constraints->max_uV_step || !_regulator_is_enabled(rdev))
3877		return 1;
3878
3879	if (*current_uV < 0) {
3880		*current_uV = regulator_get_voltage_rdev(rdev);
3881
3882		if (*current_uV < 0)
3883			return *current_uV;
3884	}
3885
3886	if (abs(*current_uV - *min_uV) <= constraints->max_uV_step)
3887		return 1;
3888
3889	/* Clamp target voltage within the given step */
3890	if (*current_uV < *min_uV)
3891		*min_uV = min(*current_uV + constraints->max_uV_step,
3892			      *min_uV);
3893	else
3894		*min_uV = max(*current_uV - constraints->max_uV_step,
3895			      *min_uV);
3896
3897	return 0;
3898}
3899
3900static int regulator_get_optimal_voltage(struct regulator_dev *rdev,
3901					 int *current_uV,
3902					 int *min_uV, int *max_uV,
3903					 suspend_state_t state,
3904					 int n_coupled)
3905{
3906	struct coupling_desc *c_desc = &rdev->coupling_desc;
3907	struct regulator_dev **c_rdevs = c_desc->coupled_rdevs;
3908	struct regulation_constraints *constraints = rdev->constraints;
3909	int desired_min_uV = 0, desired_max_uV = INT_MAX;
3910	int max_current_uV = 0, min_current_uV = INT_MAX;
3911	int highest_min_uV = 0, target_uV, possible_uV;
3912	int i, ret, max_spread;
3913	bool done;
3914
3915	*current_uV = -1;
3916
3917	/*
3918	 * If there are no coupled regulators, simply set the voltage
3919	 * demanded by consumers.
3920	 */
3921	if (n_coupled == 1) {
3922		/*
3923		 * If consumers don't provide any demands, set voltage
3924		 * to min_uV
3925		 */
3926		desired_min_uV = constraints->min_uV;
3927		desired_max_uV = constraints->max_uV;
3928
3929		ret = regulator_check_consumers(rdev,
3930						&desired_min_uV,
3931						&desired_max_uV, state);
3932		if (ret < 0)
3933			return ret;
3934
3935		possible_uV = desired_min_uV;
3936		done = true;
3937
3938		goto finish;
3939	}
3940
3941	/* Find highest min desired voltage */
3942	for (i = 0; i < n_coupled; i++) {
3943		int tmp_min = 0;
3944		int tmp_max = INT_MAX;
3945
3946		lockdep_assert_held_once(&c_rdevs[i]->mutex.base);
3947
3948		ret = regulator_check_consumers(c_rdevs[i],
3949						&tmp_min,
3950						&tmp_max, state);
3951		if (ret < 0)
3952			return ret;
3953
3954		ret = regulator_check_voltage(c_rdevs[i], &tmp_min, &tmp_max);
3955		if (ret < 0)
3956			return ret;
3957
3958		highest_min_uV = max(highest_min_uV, tmp_min);
3959
3960		if (i == 0) {
3961			desired_min_uV = tmp_min;
3962			desired_max_uV = tmp_max;
 
3963		}
3964	}
3965
3966	max_spread = constraints->max_spread[0];
3967
3968	/*
3969	 * Let target_uV be equal to the desired one if possible.
3970	 * If not, set it to minimum voltage, allowed by other coupled
3971	 * regulators.
3972	 */
3973	target_uV = max(desired_min_uV, highest_min_uV - max_spread);
3974
3975	/*
3976	 * Find min and max voltages, which currently aren't violating
3977	 * max_spread.
3978	 */
3979	for (i = 1; i < n_coupled; i++) {
3980		int tmp_act;
3981
3982		if (!_regulator_is_enabled(c_rdevs[i]))
3983			continue;
3984
3985		tmp_act = regulator_get_voltage_rdev(c_rdevs[i]);
3986		if (tmp_act < 0)
3987			return tmp_act;
3988
3989		min_current_uV = min(tmp_act, min_current_uV);
3990		max_current_uV = max(tmp_act, max_current_uV);
3991	}
3992
3993	/* There aren't any other regulators enabled */
3994	if (max_current_uV == 0) {
3995		possible_uV = target_uV;
3996	} else {
3997		/*
3998		 * Correct target voltage, so as it currently isn't
3999		 * violating max_spread
4000		 */
4001		possible_uV = max(target_uV, max_current_uV - max_spread);
4002		possible_uV = min(possible_uV, min_current_uV + max_spread);
4003	}
4004
4005	if (possible_uV > desired_max_uV)
4006		return -EINVAL;
4007
4008	done = (possible_uV == target_uV);
4009	desired_min_uV = possible_uV;
4010
4011finish:
4012	/* Apply max_uV_step constraint if necessary */
4013	if (state == PM_SUSPEND_ON) {
4014		ret = regulator_limit_voltage_step(rdev, current_uV,
4015						   &desired_min_uV);
4016		if (ret < 0)
4017			return ret;
4018
4019		if (ret == 0)
4020			done = false;
4021	}
4022
4023	/* Set current_uV if wasn't done earlier in the code and if necessary */
4024	if (n_coupled > 1 && *current_uV == -1) {
4025
4026		if (_regulator_is_enabled(rdev)) {
4027			ret = regulator_get_voltage_rdev(rdev);
4028			if (ret < 0)
4029				return ret;
 
 
 
 
4030
4031			*current_uV = ret;
 
 
4032		} else {
4033			*current_uV = desired_min_uV;
4034		}
 
 
4035	}
4036
4037	*min_uV = desired_min_uV;
4038	*max_uV = desired_max_uV;
4039
4040	return done;
4041}
4042
4043int regulator_do_balance_voltage(struct regulator_dev *rdev,
4044				 suspend_state_t state, bool skip_coupled)
4045{
4046	struct regulator_dev **c_rdevs;
4047	struct regulator_dev *best_rdev;
4048	struct coupling_desc *c_desc = &rdev->coupling_desc;
4049	int i, ret, n_coupled, best_min_uV, best_max_uV, best_c_rdev;
4050	unsigned int delta, best_delta;
4051	unsigned long c_rdev_done = 0;
4052	bool best_c_rdev_done;
4053
4054	c_rdevs = c_desc->coupled_rdevs;
4055	n_coupled = skip_coupled ? 1 : c_desc->n_coupled;
4056
4057	/*
4058	 * Find the best possible voltage change on each loop. Leave the loop
4059	 * if there isn't any possible change.
4060	 */
4061	do {
4062		best_c_rdev_done = false;
4063		best_delta = 0;
4064		best_min_uV = 0;
4065		best_max_uV = 0;
4066		best_c_rdev = 0;
4067		best_rdev = NULL;
4068
4069		/*
4070		 * Find highest difference between optimal voltage
4071		 * and current voltage.
4072		 */
4073		for (i = 0; i < n_coupled; i++) {
4074			/*
4075			 * optimal_uV is the best voltage that can be set for
4076			 * i-th regulator at the moment without violating
4077			 * max_spread constraint in order to balance
4078			 * the coupled voltages.
4079			 */
4080			int optimal_uV = 0, optimal_max_uV = 0, current_uV = 0;
4081
4082			if (test_bit(i, &c_rdev_done))
4083				continue;
4084
4085			ret = regulator_get_optimal_voltage(c_rdevs[i],
4086							    &current_uV,
4087							    &optimal_uV,
4088							    &optimal_max_uV,
4089							    state, n_coupled);
4090			if (ret < 0)
4091				goto out;
4092
4093			delta = abs(optimal_uV - current_uV);
4094
4095			if (delta && best_delta <= delta) {
4096				best_c_rdev_done = ret;
4097				best_delta = delta;
4098				best_rdev = c_rdevs[i];
4099				best_min_uV = optimal_uV;
4100				best_max_uV = optimal_max_uV;
4101				best_c_rdev = i;
4102			}
4103		}
4104
4105		/* Nothing to change, return successfully */
4106		if (!best_rdev) {
4107			ret = 0;
4108			goto out;
4109		}
4110
4111		ret = regulator_set_voltage_rdev(best_rdev, best_min_uV,
4112						 best_max_uV, state);
4113
4114		if (ret < 0)
4115			goto out;
4116
4117		if (best_c_rdev_done)
4118			set_bit(best_c_rdev, &c_rdev_done);
 
4119
4120	} while (n_coupled > 1);
4121
4122out:
4123	return ret;
4124}
4125
4126static int regulator_balance_voltage(struct regulator_dev *rdev,
4127				     suspend_state_t state)
4128{
4129	struct coupling_desc *c_desc = &rdev->coupling_desc;
4130	struct regulator_coupler *coupler = c_desc->coupler;
4131	bool skip_coupled = false;
4132
4133	/*
4134	 * If system is in a state other than PM_SUSPEND_ON, don't check
4135	 * other coupled regulators.
4136	 */
4137	if (state != PM_SUSPEND_ON)
4138		skip_coupled = true;
4139
4140	if (c_desc->n_resolved < c_desc->n_coupled) {
4141		rdev_err(rdev, "Not all coupled regulators registered\n");
4142		return -EPERM;
4143	}
4144
4145	/* Invoke custom balancer for customized couplers */
4146	if (coupler && coupler->balance_voltage)
4147		return coupler->balance_voltage(coupler, rdev, state);
4148
4149	return regulator_do_balance_voltage(rdev, state, skip_coupled);
4150}
4151
4152/**
4153 * regulator_set_voltage - set regulator output voltage
4154 * @regulator: regulator source
4155 * @min_uV: Minimum required voltage in uV
4156 * @max_uV: Maximum acceptable voltage in uV
4157 *
4158 * Sets a voltage regulator to the desired output voltage. This can be set
4159 * during any regulator state. IOW, regulator can be disabled or enabled.
4160 *
4161 * If the regulator is enabled then the voltage will change to the new value
4162 * immediately otherwise if the regulator is disabled the regulator will
4163 * output at the new voltage when enabled.
4164 *
4165 * NOTE: If the regulator is shared between several devices then the lowest
4166 * request voltage that meets the system constraints will be used.
4167 * Regulator system constraints must be set for this regulator before
4168 * calling this function otherwise this call will fail.
4169 */
4170int regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV)
4171{
4172	struct ww_acquire_ctx ww_ctx;
4173	int ret;
4174
4175	regulator_lock_dependent(regulator->rdev, &ww_ctx);
4176
4177	ret = regulator_set_voltage_unlocked(regulator, min_uV, max_uV,
4178					     PM_SUSPEND_ON);
4179
4180	regulator_unlock_dependent(regulator->rdev, &ww_ctx);
4181
4182	return ret;
4183}
4184EXPORT_SYMBOL_GPL(regulator_set_voltage);
4185
4186static inline int regulator_suspend_toggle(struct regulator_dev *rdev,
4187					   suspend_state_t state, bool en)
4188{
4189	struct regulator_state *rstate;
4190
4191	rstate = regulator_get_suspend_state(rdev, state);
4192	if (rstate == NULL)
4193		return -EINVAL;
4194
4195	if (!rstate->changeable)
4196		return -EPERM;
4197
4198	rstate->enabled = (en) ? ENABLE_IN_SUSPEND : DISABLE_IN_SUSPEND;
4199
4200	return 0;
4201}
4202
4203int regulator_suspend_enable(struct regulator_dev *rdev,
4204				    suspend_state_t state)
4205{
4206	return regulator_suspend_toggle(rdev, state, true);
4207}
4208EXPORT_SYMBOL_GPL(regulator_suspend_enable);
4209
4210int regulator_suspend_disable(struct regulator_dev *rdev,
4211				     suspend_state_t state)
4212{
4213	struct regulator *regulator;
4214	struct regulator_voltage *voltage;
4215
4216	/*
4217	 * if any consumer wants this regulator device keeping on in
4218	 * suspend states, don't set it as disabled.
4219	 */
4220	list_for_each_entry(regulator, &rdev->consumer_list, list) {
4221		voltage = &regulator->voltage[state];
4222		if (voltage->min_uV || voltage->max_uV)
4223			return 0;
4224	}
4225
4226	return regulator_suspend_toggle(rdev, state, false);
4227}
4228EXPORT_SYMBOL_GPL(regulator_suspend_disable);
4229
4230static int _regulator_set_suspend_voltage(struct regulator *regulator,
4231					  int min_uV, int max_uV,
4232					  suspend_state_t state)
4233{
4234	struct regulator_dev *rdev = regulator->rdev;
4235	struct regulator_state *rstate;
4236
4237	rstate = regulator_get_suspend_state(rdev, state);
4238	if (rstate == NULL)
4239		return -EINVAL;
4240
4241	if (rstate->min_uV == rstate->max_uV) {
4242		rdev_err(rdev, "The suspend voltage can't be changed!\n");
4243		return -EPERM;
 
 
4244	}
4245
4246	return regulator_set_voltage_unlocked(regulator, min_uV, max_uV, state);
4247}
4248
4249int regulator_set_suspend_voltage(struct regulator *regulator, int min_uV,
4250				  int max_uV, suspend_state_t state)
4251{
4252	struct ww_acquire_ctx ww_ctx;
4253	int ret;
4254
4255	/* PM_SUSPEND_ON is handled by regulator_set_voltage() */
4256	if (regulator_check_states(state) || state == PM_SUSPEND_ON)
4257		return -EINVAL;
4258
4259	regulator_lock_dependent(regulator->rdev, &ww_ctx);
4260
4261	ret = _regulator_set_suspend_voltage(regulator, min_uV,
4262					     max_uV, state);
 
4263
4264	regulator_unlock_dependent(regulator->rdev, &ww_ctx);
4265
 
 
4266	return ret;
4267}
4268EXPORT_SYMBOL_GPL(regulator_set_suspend_voltage);
4269
4270/**
4271 * regulator_set_voltage_time - get raise/fall time
4272 * @regulator: regulator source
4273 * @old_uV: starting voltage in microvolts
4274 * @new_uV: target voltage in microvolts
4275 *
4276 * Provided with the starting and ending voltage, this function attempts to
4277 * calculate the time in microseconds required to rise or fall to this new
4278 * voltage.
4279 */
4280int regulator_set_voltage_time(struct regulator *regulator,
4281			       int old_uV, int new_uV)
4282{
4283	struct regulator_dev *rdev = regulator->rdev;
4284	const struct regulator_ops *ops = rdev->desc->ops;
4285	int old_sel = -1;
4286	int new_sel = -1;
4287	int voltage;
4288	int i;
4289
4290	if (ops->set_voltage_time)
4291		return ops->set_voltage_time(rdev, old_uV, new_uV);
4292	else if (!ops->set_voltage_time_sel)
4293		return _regulator_set_voltage_time(rdev, old_uV, new_uV);
4294
4295	/* Currently requires operations to do this */
4296	if (!ops->list_voltage || !rdev->desc->n_voltages)
 
4297		return -EINVAL;
4298
4299	for (i = 0; i < rdev->desc->n_voltages; i++) {
4300		/* We only look for exact voltage matches here */
4301		if (i < rdev->desc->linear_min_sel)
4302			continue;
4303
4304		if (old_sel >= 0 && new_sel >= 0)
4305			break;
4306
4307		voltage = regulator_list_voltage(regulator, i);
4308		if (voltage < 0)
4309			return -EINVAL;
4310		if (voltage == 0)
4311			continue;
4312		if (voltage == old_uV)
4313			old_sel = i;
4314		if (voltage == new_uV)
4315			new_sel = i;
4316	}
4317
4318	if (old_sel < 0 || new_sel < 0)
4319		return -EINVAL;
4320
4321	return ops->set_voltage_time_sel(rdev, old_sel, new_sel);
4322}
4323EXPORT_SYMBOL_GPL(regulator_set_voltage_time);
4324
4325/**
4326 * regulator_set_voltage_time_sel - get raise/fall time
4327 * @rdev: regulator source device
4328 * @old_selector: selector for starting voltage
4329 * @new_selector: selector for target voltage
4330 *
4331 * Provided with the starting and target voltage selectors, this function
4332 * returns time in microseconds required to rise or fall to this new voltage
4333 *
4334 * Drivers providing ramp_delay in regulation_constraints can use this as their
4335 * set_voltage_time_sel() operation.
4336 */
4337int regulator_set_voltage_time_sel(struct regulator_dev *rdev,
4338				   unsigned int old_selector,
4339				   unsigned int new_selector)
4340{
4341	int old_volt, new_volt;
4342
4343	/* sanity check */
4344	if (!rdev->desc->ops->list_voltage)
4345		return -EINVAL;
4346
4347	old_volt = rdev->desc->ops->list_voltage(rdev, old_selector);
4348	new_volt = rdev->desc->ops->list_voltage(rdev, new_selector);
4349
4350	if (rdev->desc->ops->set_voltage_time)
4351		return rdev->desc->ops->set_voltage_time(rdev, old_volt,
4352							 new_volt);
4353	else
4354		return _regulator_set_voltage_time(rdev, old_volt, new_volt);
4355}
4356EXPORT_SYMBOL_GPL(regulator_set_voltage_time_sel);
4357
4358int regulator_sync_voltage_rdev(struct regulator_dev *rdev)
4359{
4360	int ret;
4361
4362	regulator_lock(rdev);
4363
4364	if (!rdev->desc->ops->set_voltage &&
4365	    !rdev->desc->ops->set_voltage_sel) {
4366		ret = -EINVAL;
4367		goto out;
4368	}
4369
4370	/* balance only, if regulator is coupled */
4371	if (rdev->coupling_desc.n_coupled > 1)
4372		ret = regulator_balance_voltage(rdev, PM_SUSPEND_ON);
4373	else
4374		ret = -EOPNOTSUPP;
4375
4376out:
4377	regulator_unlock(rdev);
4378	return ret;
4379}
4380
4381/**
4382 * regulator_sync_voltage - re-apply last regulator output voltage
4383 * @regulator: regulator source
4384 *
4385 * Re-apply the last configured voltage.  This is intended to be used
4386 * where some external control source the consumer is cooperating with
4387 * has caused the configured voltage to change.
4388 */
4389int regulator_sync_voltage(struct regulator *regulator)
4390{
4391	struct regulator_dev *rdev = regulator->rdev;
4392	struct regulator_voltage *voltage = &regulator->voltage[PM_SUSPEND_ON];
4393	int ret, min_uV, max_uV;
4394
4395	if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_VOLTAGE))
4396		return 0;
4397
4398	regulator_lock(rdev);
4399
4400	if (!rdev->desc->ops->set_voltage &&
4401	    !rdev->desc->ops->set_voltage_sel) {
4402		ret = -EINVAL;
4403		goto out;
4404	}
4405
4406	/* This is only going to work if we've had a voltage configured. */
4407	if (!voltage->min_uV && !voltage->max_uV) {
4408		ret = -EINVAL;
4409		goto out;
4410	}
4411
4412	min_uV = voltage->min_uV;
4413	max_uV = voltage->max_uV;
4414
4415	/* This should be a paranoia check... */
4416	ret = regulator_check_voltage(rdev, &min_uV, &max_uV);
4417	if (ret < 0)
4418		goto out;
4419
4420	ret = regulator_check_consumers(rdev, &min_uV, &max_uV, 0);
4421	if (ret < 0)
4422		goto out;
4423
4424	/* balance only, if regulator is coupled */
4425	if (rdev->coupling_desc.n_coupled > 1)
4426		ret = regulator_balance_voltage(rdev, PM_SUSPEND_ON);
4427	else
4428		ret = _regulator_do_set_voltage(rdev, min_uV, max_uV);
4429
4430out:
4431	regulator_unlock(rdev);
4432	return ret;
4433}
4434EXPORT_SYMBOL_GPL(regulator_sync_voltage);
4435
4436int regulator_get_voltage_rdev(struct regulator_dev *rdev)
4437{
4438	int sel, ret;
4439	bool bypassed;
4440
4441	if (rdev->desc->ops->get_bypass) {
4442		ret = rdev->desc->ops->get_bypass(rdev, &bypassed);
4443		if (ret < 0)
4444			return ret;
4445		if (bypassed) {
4446			/* if bypassed the regulator must have a supply */
4447			if (!rdev->supply) {
4448				rdev_err(rdev,
4449					 "bypassed regulator has no supply!\n");
4450				return -EPROBE_DEFER;
4451			}
4452
4453			return regulator_get_voltage_rdev(rdev->supply->rdev);
4454		}
4455	}
4456
4457	if (rdev->desc->ops->get_voltage_sel) {
4458		sel = rdev->desc->ops->get_voltage_sel(rdev);
4459		if (sel < 0)
4460			return sel;
4461		ret = rdev->desc->ops->list_voltage(rdev, sel);
4462	} else if (rdev->desc->ops->get_voltage) {
4463		ret = rdev->desc->ops->get_voltage(rdev);
4464	} else if (rdev->desc->ops->list_voltage) {
4465		ret = rdev->desc->ops->list_voltage(rdev, 0);
4466	} else if (rdev->desc->fixed_uV && (rdev->desc->n_voltages == 1)) {
4467		ret = rdev->desc->fixed_uV;
4468	} else if (rdev->supply) {
4469		ret = regulator_get_voltage_rdev(rdev->supply->rdev);
4470	} else if (rdev->supply_name) {
4471		return -EPROBE_DEFER;
4472	} else {
4473		return -EINVAL;
4474	}
4475
4476	if (ret < 0)
4477		return ret;
4478	return ret - rdev->constraints->uV_offset;
4479}
4480EXPORT_SYMBOL_GPL(regulator_get_voltage_rdev);
4481
4482/**
4483 * regulator_get_voltage - get regulator output voltage
4484 * @regulator: regulator source
4485 *
4486 * This returns the current regulator voltage in uV.
4487 *
4488 * NOTE: If the regulator is disabled it will return the voltage value. This
4489 * function should not be used to determine regulator state.
4490 */
4491int regulator_get_voltage(struct regulator *regulator)
4492{
4493	struct ww_acquire_ctx ww_ctx;
4494	int ret;
4495
4496	regulator_lock_dependent(regulator->rdev, &ww_ctx);
4497	ret = regulator_get_voltage_rdev(regulator->rdev);
4498	regulator_unlock_dependent(regulator->rdev, &ww_ctx);
 
 
4499
4500	return ret;
4501}
4502EXPORT_SYMBOL_GPL(regulator_get_voltage);
4503
4504/**
4505 * regulator_set_current_limit - set regulator output current limit
4506 * @regulator: regulator source
4507 * @min_uA: Minimum supported current in uA
4508 * @max_uA: Maximum supported current in uA
4509 *
4510 * Sets current sink to the desired output current. This can be set during
4511 * any regulator state. IOW, regulator can be disabled or enabled.
4512 *
4513 * If the regulator is enabled then the current will change to the new value
4514 * immediately otherwise if the regulator is disabled the regulator will
4515 * output at the new current when enabled.
4516 *
4517 * NOTE: Regulator system constraints must be set for this regulator before
4518 * calling this function otherwise this call will fail.
4519 */
4520int regulator_set_current_limit(struct regulator *regulator,
4521			       int min_uA, int max_uA)
4522{
4523	struct regulator_dev *rdev = regulator->rdev;
4524	int ret;
4525
4526	regulator_lock(rdev);
4527
4528	/* sanity check */
4529	if (!rdev->desc->ops->set_current_limit) {
4530		ret = -EINVAL;
4531		goto out;
4532	}
4533
4534	/* constraints check */
4535	ret = regulator_check_current_limit(rdev, &min_uA, &max_uA);
4536	if (ret < 0)
4537		goto out;
4538
4539	ret = rdev->desc->ops->set_current_limit(rdev, min_uA, max_uA);
4540out:
4541	regulator_unlock(rdev);
4542	return ret;
4543}
4544EXPORT_SYMBOL_GPL(regulator_set_current_limit);
4545
4546static int _regulator_get_current_limit_unlocked(struct regulator_dev *rdev)
4547{
4548	/* sanity check */
4549	if (!rdev->desc->ops->get_current_limit)
4550		return -EINVAL;
4551
4552	return rdev->desc->ops->get_current_limit(rdev);
4553}
4554
4555static int _regulator_get_current_limit(struct regulator_dev *rdev)
4556{
4557	int ret;
4558
4559	regulator_lock(rdev);
4560	ret = _regulator_get_current_limit_unlocked(rdev);
4561	regulator_unlock(rdev);
 
 
 
 
4562
 
 
 
4563	return ret;
4564}
4565
4566/**
4567 * regulator_get_current_limit - get regulator output current
4568 * @regulator: regulator source
4569 *
4570 * This returns the current supplied by the specified current sink in uA.
4571 *
4572 * NOTE: If the regulator is disabled it will return the current value. This
4573 * function should not be used to determine regulator state.
4574 */
4575int regulator_get_current_limit(struct regulator *regulator)
4576{
4577	return _regulator_get_current_limit(regulator->rdev);
4578}
4579EXPORT_SYMBOL_GPL(regulator_get_current_limit);
4580
4581/**
4582 * regulator_set_mode - set regulator operating mode
4583 * @regulator: regulator source
4584 * @mode: operating mode - one of the REGULATOR_MODE constants
4585 *
4586 * Set regulator operating mode to increase regulator efficiency or improve
4587 * regulation performance.
4588 *
4589 * NOTE: Regulator system constraints must be set for this regulator before
4590 * calling this function otherwise this call will fail.
4591 */
4592int regulator_set_mode(struct regulator *regulator, unsigned int mode)
4593{
4594	struct regulator_dev *rdev = regulator->rdev;
4595	int ret;
4596	int regulator_curr_mode;
4597
4598	regulator_lock(rdev);
4599
4600	/* sanity check */
4601	if (!rdev->desc->ops->set_mode) {
4602		ret = -EINVAL;
4603		goto out;
4604	}
4605
4606	/* return if the same mode is requested */
4607	if (rdev->desc->ops->get_mode) {
4608		regulator_curr_mode = rdev->desc->ops->get_mode(rdev);
4609		if (regulator_curr_mode == mode) {
4610			ret = 0;
4611			goto out;
4612		}
4613	}
4614
4615	/* constraints check */
4616	ret = regulator_mode_constrain(rdev, &mode);
4617	if (ret < 0)
4618		goto out;
4619
4620	ret = rdev->desc->ops->set_mode(rdev, mode);
4621out:
4622	regulator_unlock(rdev);
4623	return ret;
4624}
4625EXPORT_SYMBOL_GPL(regulator_set_mode);
4626
4627static unsigned int _regulator_get_mode_unlocked(struct regulator_dev *rdev)
4628{
4629	/* sanity check */
4630	if (!rdev->desc->ops->get_mode)
4631		return -EINVAL;
4632
4633	return rdev->desc->ops->get_mode(rdev);
4634}
4635
4636static unsigned int _regulator_get_mode(struct regulator_dev *rdev)
4637{
4638	int ret;
4639
4640	regulator_lock(rdev);
4641	ret = _regulator_get_mode_unlocked(rdev);
4642	regulator_unlock(rdev);
 
 
 
 
4643
 
 
 
4644	return ret;
4645}
4646
4647/**
4648 * regulator_get_mode - get regulator operating mode
4649 * @regulator: regulator source
4650 *
4651 * Get the current regulator operating mode.
4652 */
4653unsigned int regulator_get_mode(struct regulator *regulator)
4654{
4655	return _regulator_get_mode(regulator->rdev);
4656}
4657EXPORT_SYMBOL_GPL(regulator_get_mode);
4658
4659static int rdev_get_cached_err_flags(struct regulator_dev *rdev)
4660{
4661	int ret = 0;
4662
4663	if (rdev->use_cached_err) {
4664		spin_lock(&rdev->err_lock);
4665		ret = rdev->cached_err;
4666		spin_unlock(&rdev->err_lock);
4667	}
4668	return ret;
4669}
4670
4671static int _regulator_get_error_flags(struct regulator_dev *rdev,
4672					unsigned int *flags)
4673{
4674	int cached_flags, ret = 0;
4675
4676	regulator_lock(rdev);
4677
4678	cached_flags = rdev_get_cached_err_flags(rdev);
4679
4680	if (rdev->desc->ops->get_error_flags)
4681		ret = rdev->desc->ops->get_error_flags(rdev, flags);
4682	else if (!rdev->use_cached_err)
4683		ret = -EINVAL;
4684
4685	*flags |= cached_flags;
4686
4687	regulator_unlock(rdev);
4688
4689	return ret;
4690}
4691
4692/**
4693 * regulator_get_error_flags - get regulator error information
4694 * @regulator: regulator source
4695 * @flags: pointer to store error flags
4696 *
4697 * Get the current regulator error information.
4698 */
4699int regulator_get_error_flags(struct regulator *regulator,
4700				unsigned int *flags)
4701{
4702	return _regulator_get_error_flags(regulator->rdev, flags);
4703}
4704EXPORT_SYMBOL_GPL(regulator_get_error_flags);
4705
4706/**
4707 * regulator_set_load - set regulator load
4708 * @regulator: regulator source
4709 * @uA_load: load current
4710 *
4711 * Notifies the regulator core of a new device load. This is then used by
4712 * DRMS (if enabled by constraints) to set the most efficient regulator
4713 * operating mode for the new regulator loading.
4714 *
4715 * Consumer devices notify their supply regulator of the maximum power
4716 * they will require (can be taken from device datasheet in the power
4717 * consumption tables) when they change operational status and hence power
4718 * state. Examples of operational state changes that can affect power
4719 * consumption are :-
4720 *
4721 *    o Device is opened / closed.
4722 *    o Device I/O is about to begin or has just finished.
4723 *    o Device is idling in between work.
4724 *
4725 * This information is also exported via sysfs to userspace.
4726 *
4727 * DRMS will sum the total requested load on the regulator and change
4728 * to the most efficient operating mode if platform constraints allow.
4729 *
4730 * NOTE: when a regulator consumer requests to have a regulator
4731 * disabled then any load that consumer requested no longer counts
4732 * toward the total requested load.  If the regulator is re-enabled
4733 * then the previously requested load will start counting again.
4734 *
4735 * If a regulator is an always-on regulator then an individual consumer's
4736 * load will still be removed if that consumer is fully disabled.
4737 *
4738 * On error a negative errno is returned.
4739 */
4740int regulator_set_load(struct regulator *regulator, int uA_load)
4741{
4742	struct regulator_dev *rdev = regulator->rdev;
4743	int old_uA_load;
4744	int ret = 0;
 
 
 
4745
4746	regulator_lock(rdev);
4747	old_uA_load = regulator->uA_load;
 
 
4748	regulator->uA_load = uA_load;
4749	if (regulator->enable_count && old_uA_load != uA_load) {
4750		ret = drms_uA_update(rdev);
4751		if (ret < 0)
4752			regulator->uA_load = old_uA_load;
4753	}
4754	regulator_unlock(rdev);
4755
4756	return ret;
4757}
4758EXPORT_SYMBOL_GPL(regulator_set_load);
4759
4760/**
4761 * regulator_allow_bypass - allow the regulator to go into bypass mode
4762 *
4763 * @regulator: Regulator to configure
4764 * @enable: enable or disable bypass mode
4765 *
4766 * Allow the regulator to go into bypass mode if all other consumers
4767 * for the regulator also enable bypass mode and the machine
4768 * constraints allow this.  Bypass mode means that the regulator is
4769 * simply passing the input directly to the output with no regulation.
4770 */
4771int regulator_allow_bypass(struct regulator *regulator, bool enable)
4772{
4773	struct regulator_dev *rdev = regulator->rdev;
4774	const char *name = rdev_get_name(rdev);
4775	int ret = 0;
4776
4777	if (!rdev->desc->ops->set_bypass)
4778		return 0;
4779
4780	if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_BYPASS))
4781		return 0;
4782
4783	regulator_lock(rdev);
4784
4785	if (enable && !regulator->bypass) {
4786		rdev->bypass_count++;
4787
4788		if (rdev->bypass_count == rdev->open_count) {
4789			trace_regulator_bypass_enable(name);
4790
4791			ret = rdev->desc->ops->set_bypass(rdev, enable);
4792			if (ret != 0)
4793				rdev->bypass_count--;
4794			else
4795				trace_regulator_bypass_enable_complete(name);
4796		}
4797
4798	} else if (!enable && regulator->bypass) {
4799		rdev->bypass_count--;
4800
4801		if (rdev->bypass_count != rdev->open_count) {
4802			trace_regulator_bypass_disable(name);
 
 
 
4803
4804			ret = rdev->desc->ops->set_bypass(rdev, enable);
4805			if (ret != 0)
4806				rdev->bypass_count++;
4807			else
4808				trace_regulator_bypass_disable_complete(name);
4809		}
4810	}
4811
4812	if (ret == 0)
4813		regulator->bypass = enable;
 
 
 
 
 
 
 
 
4814
4815	regulator_unlock(rdev);
 
 
 
 
 
 
 
 
 
 
 
 
4816
 
 
 
 
 
 
 
 
4817	return ret;
4818}
4819EXPORT_SYMBOL_GPL(regulator_allow_bypass);
4820
4821/**
4822 * regulator_register_notifier - register regulator event notifier
4823 * @regulator: regulator source
4824 * @nb: notifier block
4825 *
4826 * Register notifier block to receive regulator events.
4827 */
4828int regulator_register_notifier(struct regulator *regulator,
4829			      struct notifier_block *nb)
4830{
4831	return blocking_notifier_chain_register(&regulator->rdev->notifier,
4832						nb);
4833}
4834EXPORT_SYMBOL_GPL(regulator_register_notifier);
4835
4836/**
4837 * regulator_unregister_notifier - unregister regulator event notifier
4838 * @regulator: regulator source
4839 * @nb: notifier block
4840 *
4841 * Unregister regulator event notifier block.
4842 */
4843int regulator_unregister_notifier(struct regulator *regulator,
4844				struct notifier_block *nb)
4845{
4846	return blocking_notifier_chain_unregister(&regulator->rdev->notifier,
4847						  nb);
4848}
4849EXPORT_SYMBOL_GPL(regulator_unregister_notifier);
4850
4851/* notify regulator consumers and downstream regulator consumers.
4852 * Note mutex must be held by caller.
4853 */
4854static int _notifier_call_chain(struct regulator_dev *rdev,
4855				  unsigned long event, void *data)
4856{
4857	/* call rdev chain first */
4858	int ret =  blocking_notifier_call_chain(&rdev->notifier, event, data);
4859
4860	if (IS_REACHABLE(CONFIG_REGULATOR_NETLINK_EVENTS)) {
4861		struct device *parent = rdev->dev.parent;
4862		const char *rname = rdev_get_name(rdev);
4863		char name[32];
4864
4865		/* Avoid duplicate debugfs directory names */
4866		if (parent && rname == rdev->desc->name) {
4867			snprintf(name, sizeof(name), "%s-%s", dev_name(parent),
4868				 rname);
4869			rname = name;
4870		}
4871		reg_generate_netlink_event(rname, event);
4872	}
4873
4874	return ret;
4875}
4876
4877int _regulator_bulk_get(struct device *dev, int num_consumers,
4878			struct regulator_bulk_data *consumers, enum regulator_get_type get_type)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4879{
4880	int i;
4881	int ret;
4882
4883	for (i = 0; i < num_consumers; i++)
4884		consumers[i].consumer = NULL;
4885
4886	for (i = 0; i < num_consumers; i++) {
4887		consumers[i].consumer = _regulator_get(dev,
4888						       consumers[i].supply, get_type);
4889		if (IS_ERR(consumers[i].consumer)) {
4890			ret = dev_err_probe(dev, PTR_ERR(consumers[i].consumer),
4891					    "Failed to get supply '%s'",
4892					    consumers[i].supply);
4893			consumers[i].consumer = NULL;
4894			goto err;
4895		}
4896
4897		if (consumers[i].init_load_uA > 0) {
4898			ret = regulator_set_load(consumers[i].consumer,
4899						 consumers[i].init_load_uA);
4900			if (ret) {
4901				i++;
4902				goto err;
4903			}
4904		}
4905	}
4906
4907	return 0;
4908
4909err:
4910	while (--i >= 0)
4911		regulator_put(consumers[i].consumer);
4912
4913	return ret;
4914}
4915
4916/**
4917 * regulator_bulk_get - get multiple regulator consumers
4918 *
4919 * @dev:           Device to supply
4920 * @num_consumers: Number of consumers to register
4921 * @consumers:     Configuration of consumers; clients are stored here.
4922 *
4923 * @return 0 on success, an errno on failure.
4924 *
4925 * This helper function allows drivers to get several regulator
4926 * consumers in one operation.  If any of the regulators cannot be
4927 * acquired then any regulators that were allocated will be freed
4928 * before returning to the caller.
4929 */
4930int regulator_bulk_get(struct device *dev, int num_consumers,
4931		       struct regulator_bulk_data *consumers)
4932{
4933	return _regulator_bulk_get(dev, num_consumers, consumers, NORMAL_GET);
4934}
4935EXPORT_SYMBOL_GPL(regulator_bulk_get);
4936
4937static void regulator_bulk_enable_async(void *data, async_cookie_t cookie)
4938{
4939	struct regulator_bulk_data *bulk = data;
4940
4941	bulk->ret = regulator_enable(bulk->consumer);
4942}
4943
4944/**
4945 * regulator_bulk_enable - enable multiple regulator consumers
4946 *
4947 * @num_consumers: Number of consumers
4948 * @consumers:     Consumer data; clients are stored here.
4949 * @return         0 on success, an errno on failure
4950 *
4951 * This convenience API allows consumers to enable multiple regulator
4952 * clients in a single API call.  If any consumers cannot be enabled
4953 * then any others that were enabled will be disabled again prior to
4954 * return.
4955 */
4956int regulator_bulk_enable(int num_consumers,
4957			  struct regulator_bulk_data *consumers)
4958{
4959	ASYNC_DOMAIN_EXCLUSIVE(async_domain);
4960	int i;
4961	int ret = 0;
4962
4963	for (i = 0; i < num_consumers; i++) {
4964		async_schedule_domain(regulator_bulk_enable_async,
4965				      &consumers[i], &async_domain);
4966	}
4967
4968	async_synchronize_full_domain(&async_domain);
4969
4970	/* If any consumer failed we need to unwind any that succeeded */
4971	for (i = 0; i < num_consumers; i++) {
4972		if (consumers[i].ret != 0) {
4973			ret = consumers[i].ret;
4974			goto err;
4975		}
4976	}
4977
4978	return 0;
4979
4980err:
4981	for (i = 0; i < num_consumers; i++) {
4982		if (consumers[i].ret < 0)
4983			pr_err("Failed to enable %s: %pe\n", consumers[i].supply,
4984			       ERR_PTR(consumers[i].ret));
4985		else
4986			regulator_disable(consumers[i].consumer);
4987	}
 
 
4988
4989	return ret;
4990}
4991EXPORT_SYMBOL_GPL(regulator_bulk_enable);
4992
4993/**
4994 * regulator_bulk_disable - disable multiple regulator consumers
4995 *
4996 * @num_consumers: Number of consumers
4997 * @consumers:     Consumer data; clients are stored here.
4998 * @return         0 on success, an errno on failure
4999 *
5000 * This convenience API allows consumers to disable multiple regulator
5001 * clients in a single API call.  If any consumers cannot be disabled
5002 * then any others that were disabled will be enabled again prior to
5003 * return.
5004 */
5005int regulator_bulk_disable(int num_consumers,
5006			   struct regulator_bulk_data *consumers)
5007{
5008	int i;
5009	int ret, r;
5010
5011	for (i = num_consumers - 1; i >= 0; --i) {
5012		ret = regulator_disable(consumers[i].consumer);
5013		if (ret != 0)
5014			goto err;
5015	}
5016
5017	return 0;
5018
5019err:
5020	pr_err("Failed to disable %s: %pe\n", consumers[i].supply, ERR_PTR(ret));
5021	for (++i; i < num_consumers; ++i) {
5022		r = regulator_enable(consumers[i].consumer);
5023		if (r != 0)
5024			pr_err("Failed to re-enable %s: %pe\n",
5025			       consumers[i].supply, ERR_PTR(r));
5026	}
5027
5028	return ret;
5029}
5030EXPORT_SYMBOL_GPL(regulator_bulk_disable);
5031
5032/**
5033 * regulator_bulk_force_disable - force disable multiple regulator consumers
5034 *
5035 * @num_consumers: Number of consumers
5036 * @consumers:     Consumer data; clients are stored here.
5037 * @return         0 on success, an errno on failure
5038 *
5039 * This convenience API allows consumers to forcibly disable multiple regulator
5040 * clients in a single API call.
5041 * NOTE: This should be used for situations when device damage will
5042 * likely occur if the regulators are not disabled (e.g. over temp).
5043 * Although regulator_force_disable function call for some consumers can
5044 * return error numbers, the function is called for all consumers.
5045 */
5046int regulator_bulk_force_disable(int num_consumers,
5047			   struct regulator_bulk_data *consumers)
5048{
5049	int i;
5050	int ret = 0;
5051
5052	for (i = 0; i < num_consumers; i++) {
5053		consumers[i].ret =
5054			    regulator_force_disable(consumers[i].consumer);
5055
5056		/* Store first error for reporting */
5057		if (consumers[i].ret && !ret)
5058			ret = consumers[i].ret;
5059	}
5060
5061	return ret;
5062}
5063EXPORT_SYMBOL_GPL(regulator_bulk_force_disable);
5064
5065/**
5066 * regulator_bulk_free - free multiple regulator consumers
5067 *
5068 * @num_consumers: Number of consumers
5069 * @consumers:     Consumer data; clients are stored here.
5070 *
5071 * This convenience API allows consumers to free multiple regulator
5072 * clients in a single API call.
5073 */
5074void regulator_bulk_free(int num_consumers,
5075			 struct regulator_bulk_data *consumers)
5076{
5077	int i;
5078
5079	for (i = 0; i < num_consumers; i++) {
5080		regulator_put(consumers[i].consumer);
5081		consumers[i].consumer = NULL;
5082	}
5083}
5084EXPORT_SYMBOL_GPL(regulator_bulk_free);
5085
5086/**
5087 * regulator_handle_critical - Handle events for system-critical regulators.
5088 * @rdev: The regulator device.
5089 * @event: The event being handled.
5090 *
5091 * This function handles critical events such as under-voltage, over-current,
5092 * and unknown errors for regulators deemed system-critical. On detecting such
5093 * events, it triggers a hardware protection shutdown with a defined timeout.
5094 */
5095static void regulator_handle_critical(struct regulator_dev *rdev,
5096				      unsigned long event)
5097{
5098	const char *reason = NULL;
5099
5100	if (!rdev->constraints->system_critical)
5101		return;
5102
5103	switch (event) {
5104	case REGULATOR_EVENT_UNDER_VOLTAGE:
5105		reason = "System critical regulator: voltage drop detected";
5106		break;
5107	case REGULATOR_EVENT_OVER_CURRENT:
5108		reason = "System critical regulator: over-current detected";
5109		break;
5110	case REGULATOR_EVENT_FAIL:
5111		reason = "System critical regulator: unknown error";
5112	}
5113
5114	if (!reason)
5115		return;
5116
5117	hw_protection_shutdown(reason,
5118			       rdev->constraints->uv_less_critical_window_ms);
5119}
5120
5121/**
5122 * regulator_notifier_call_chain - call regulator event notifier
5123 * @rdev: regulator source
5124 * @event: notifier block
5125 * @data: callback-specific data.
5126 *
5127 * Called by regulator drivers to notify clients a regulator event has
5128 * occurred.
 
5129 */
5130int regulator_notifier_call_chain(struct regulator_dev *rdev,
5131				  unsigned long event, void *data)
5132{
5133	regulator_handle_critical(rdev, event);
5134
5135	_notifier_call_chain(rdev, event, data);
5136	return NOTIFY_DONE;
5137
5138}
5139EXPORT_SYMBOL_GPL(regulator_notifier_call_chain);
5140
5141/**
5142 * regulator_mode_to_status - convert a regulator mode into a status
5143 *
5144 * @mode: Mode to convert
5145 *
5146 * Convert a regulator mode into a status.
5147 */
5148int regulator_mode_to_status(unsigned int mode)
5149{
5150	switch (mode) {
5151	case REGULATOR_MODE_FAST:
5152		return REGULATOR_STATUS_FAST;
5153	case REGULATOR_MODE_NORMAL:
5154		return REGULATOR_STATUS_NORMAL;
5155	case REGULATOR_MODE_IDLE:
5156		return REGULATOR_STATUS_IDLE;
5157	case REGULATOR_MODE_STANDBY:
5158		return REGULATOR_STATUS_STANDBY;
5159	default:
5160		return REGULATOR_STATUS_UNDEFINED;
5161	}
5162}
5163EXPORT_SYMBOL_GPL(regulator_mode_to_status);
5164
5165static struct attribute *regulator_dev_attrs[] = {
5166	&dev_attr_name.attr,
5167	&dev_attr_num_users.attr,
5168	&dev_attr_type.attr,
5169	&dev_attr_microvolts.attr,
5170	&dev_attr_microamps.attr,
5171	&dev_attr_opmode.attr,
5172	&dev_attr_state.attr,
5173	&dev_attr_status.attr,
5174	&dev_attr_bypass.attr,
5175	&dev_attr_requested_microamps.attr,
5176	&dev_attr_min_microvolts.attr,
5177	&dev_attr_max_microvolts.attr,
5178	&dev_attr_min_microamps.attr,
5179	&dev_attr_max_microamps.attr,
5180	&dev_attr_under_voltage.attr,
5181	&dev_attr_over_current.attr,
5182	&dev_attr_regulation_out.attr,
5183	&dev_attr_fail.attr,
5184	&dev_attr_over_temp.attr,
5185	&dev_attr_under_voltage_warn.attr,
5186	&dev_attr_over_current_warn.attr,
5187	&dev_attr_over_voltage_warn.attr,
5188	&dev_attr_over_temp_warn.attr,
5189	&dev_attr_suspend_standby_state.attr,
5190	&dev_attr_suspend_mem_state.attr,
5191	&dev_attr_suspend_disk_state.attr,
5192	&dev_attr_suspend_standby_microvolts.attr,
5193	&dev_attr_suspend_mem_microvolts.attr,
5194	&dev_attr_suspend_disk_microvolts.attr,
5195	&dev_attr_suspend_standby_mode.attr,
5196	&dev_attr_suspend_mem_mode.attr,
5197	&dev_attr_suspend_disk_mode.attr,
5198	NULL
5199};
5200
5201/*
5202 * To avoid cluttering sysfs (and memory) with useless state, only
5203 * create attributes that can be meaningfully displayed.
5204 */
5205static umode_t regulator_attr_is_visible(struct kobject *kobj,
5206					 struct attribute *attr, int idx)
5207{
5208	struct device *dev = kobj_to_dev(kobj);
5209	struct regulator_dev *rdev = dev_to_rdev(dev);
5210	const struct regulator_ops *ops = rdev->desc->ops;
5211	umode_t mode = attr->mode;
5212
5213	/* these three are always present */
5214	if (attr == &dev_attr_name.attr ||
5215	    attr == &dev_attr_num_users.attr ||
5216	    attr == &dev_attr_type.attr)
5217		return mode;
5218
5219	/* some attributes need specific methods to be displayed */
5220	if (attr == &dev_attr_microvolts.attr) {
5221		if ((ops->get_voltage && ops->get_voltage(rdev) >= 0) ||
5222		    (ops->get_voltage_sel && ops->get_voltage_sel(rdev) >= 0) ||
5223		    (ops->list_voltage && ops->list_voltage(rdev, 0) >= 0) ||
5224		    (rdev->desc->fixed_uV && rdev->desc->n_voltages == 1))
5225			return mode;
5226		return 0;
5227	}
5228
5229	if (attr == &dev_attr_microamps.attr)
5230		return ops->get_current_limit ? mode : 0;
5231
5232	if (attr == &dev_attr_opmode.attr)
5233		return ops->get_mode ? mode : 0;
5234
5235	if (attr == &dev_attr_state.attr)
5236		return (rdev->ena_pin || ops->is_enabled) ? mode : 0;
5237
5238	if (attr == &dev_attr_status.attr)
5239		return ops->get_status ? mode : 0;
5240
5241	if (attr == &dev_attr_bypass.attr)
5242		return ops->get_bypass ? mode : 0;
5243
5244	if (attr == &dev_attr_under_voltage.attr ||
5245	    attr == &dev_attr_over_current.attr ||
5246	    attr == &dev_attr_regulation_out.attr ||
5247	    attr == &dev_attr_fail.attr ||
5248	    attr == &dev_attr_over_temp.attr ||
5249	    attr == &dev_attr_under_voltage_warn.attr ||
5250	    attr == &dev_attr_over_current_warn.attr ||
5251	    attr == &dev_attr_over_voltage_warn.attr ||
5252	    attr == &dev_attr_over_temp_warn.attr)
5253		return ops->get_error_flags ? mode : 0;
 
 
 
 
 
5254
5255	/* constraints need specific supporting methods */
5256	if (attr == &dev_attr_min_microvolts.attr ||
5257	    attr == &dev_attr_max_microvolts.attr)
5258		return (ops->set_voltage || ops->set_voltage_sel) ? mode : 0;
5259
5260	if (attr == &dev_attr_min_microamps.attr ||
5261	    attr == &dev_attr_max_microamps.attr)
5262		return ops->set_current_limit ? mode : 0;
5263
5264	if (attr == &dev_attr_suspend_standby_state.attr ||
5265	    attr == &dev_attr_suspend_mem_state.attr ||
5266	    attr == &dev_attr_suspend_disk_state.attr)
5267		return mode;
5268
5269	if (attr == &dev_attr_suspend_standby_microvolts.attr ||
5270	    attr == &dev_attr_suspend_mem_microvolts.attr ||
5271	    attr == &dev_attr_suspend_disk_microvolts.attr)
5272		return ops->set_suspend_voltage ? mode : 0;
5273
5274	if (attr == &dev_attr_suspend_standby_mode.attr ||
5275	    attr == &dev_attr_suspend_mem_mode.attr ||
5276	    attr == &dev_attr_suspend_disk_mode.attr)
5277		return ops->set_suspend_mode ? mode : 0;
5278
5279	return mode;
5280}
5281
5282static const struct attribute_group regulator_dev_group = {
5283	.attrs = regulator_dev_attrs,
5284	.is_visible = regulator_attr_is_visible,
5285};
5286
5287static const struct attribute_group *regulator_dev_groups[] = {
5288	&regulator_dev_group,
5289	NULL
5290};
5291
5292static void regulator_dev_release(struct device *dev)
5293{
5294	struct regulator_dev *rdev = dev_get_drvdata(dev);
 
 
 
 
 
 
5295
5296	debugfs_remove_recursive(rdev->debugfs);
5297	kfree(rdev->constraints);
5298	of_node_put(rdev->dev.of_node);
5299	kfree(rdev);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5300}
5301
5302static void rdev_init_debugfs(struct regulator_dev *rdev)
5303{
5304	struct device *parent = rdev->dev.parent;
5305	const char *rname = rdev_get_name(rdev);
5306	char name[NAME_MAX];
5307
5308	/* Avoid duplicate debugfs directory names */
5309	if (parent && rname == rdev->desc->name) {
5310		snprintf(name, sizeof(name), "%s-%s", dev_name(parent),
5311			 rname);
5312		rname = name;
5313	}
5314
5315	rdev->debugfs = debugfs_create_dir(rname, debugfs_root);
5316	if (IS_ERR(rdev->debugfs))
5317		rdev_dbg(rdev, "Failed to create debugfs directory\n");
5318
5319	debugfs_create_u32("use_count", 0444, rdev->debugfs,
5320			   &rdev->use_count);
5321	debugfs_create_u32("open_count", 0444, rdev->debugfs,
5322			   &rdev->open_count);
5323	debugfs_create_u32("bypass_count", 0444, rdev->debugfs,
5324			   &rdev->bypass_count);
5325}
5326
5327static int regulator_register_resolve_supply(struct device *dev, void *data)
5328{
5329	struct regulator_dev *rdev = dev_to_rdev(dev);
5330
5331	if (regulator_resolve_supply(rdev))
5332		rdev_dbg(rdev, "unable to resolve supply\n");
5333
5334	return 0;
5335}
5336
5337int regulator_coupler_register(struct regulator_coupler *coupler)
5338{
5339	mutex_lock(&regulator_list_mutex);
5340	list_add_tail(&coupler->list, &regulator_coupler_list);
5341	mutex_unlock(&regulator_list_mutex);
5342
5343	return 0;
5344}
5345
5346static struct regulator_coupler *
5347regulator_find_coupler(struct regulator_dev *rdev)
5348{
5349	struct regulator_coupler *coupler;
5350	int err;
5351
5352	/*
5353	 * Note that regulators are appended to the list and the generic
5354	 * coupler is registered first, hence it will be attached at last
5355	 * if nobody cared.
5356	 */
5357	list_for_each_entry_reverse(coupler, &regulator_coupler_list, list) {
5358		err = coupler->attach_regulator(coupler, rdev);
5359		if (!err) {
5360			if (!coupler->balance_voltage &&
5361			    rdev->coupling_desc.n_coupled > 2)
5362				goto err_unsupported;
5363
5364			return coupler;
5365		}
5366
5367		if (err < 0)
5368			return ERR_PTR(err);
5369
5370		if (err == 1)
5371			continue;
5372
5373		break;
5374	}
5375
5376	return ERR_PTR(-EINVAL);
5377
5378err_unsupported:
5379	if (coupler->detach_regulator)
5380		coupler->detach_regulator(coupler, rdev);
5381
5382	rdev_err(rdev,
5383		"Voltage balancing for multiple regulator couples is unimplemented\n");
5384
5385	return ERR_PTR(-EPERM);
5386}
5387
5388static void regulator_resolve_coupling(struct regulator_dev *rdev)
5389{
5390	struct regulator_coupler *coupler = rdev->coupling_desc.coupler;
5391	struct coupling_desc *c_desc = &rdev->coupling_desc;
5392	int n_coupled = c_desc->n_coupled;
5393	struct regulator_dev *c_rdev;
5394	int i;
5395
5396	for (i = 1; i < n_coupled; i++) {
5397		/* already resolved */
5398		if (c_desc->coupled_rdevs[i])
5399			continue;
5400
5401		c_rdev = of_parse_coupled_regulator(rdev, i - 1);
5402
5403		if (!c_rdev)
5404			continue;
5405
5406		if (c_rdev->coupling_desc.coupler != coupler) {
5407			rdev_err(rdev, "coupler mismatch with %s\n",
5408				 rdev_get_name(c_rdev));
5409			return;
5410		}
5411
5412		c_desc->coupled_rdevs[i] = c_rdev;
5413		c_desc->n_resolved++;
5414
5415		regulator_resolve_coupling(c_rdev);
5416	}
5417}
5418
5419static void regulator_remove_coupling(struct regulator_dev *rdev)
5420{
5421	struct regulator_coupler *coupler = rdev->coupling_desc.coupler;
5422	struct coupling_desc *__c_desc, *c_desc = &rdev->coupling_desc;
5423	struct regulator_dev *__c_rdev, *c_rdev;
5424	unsigned int __n_coupled, n_coupled;
5425	int i, k;
5426	int err;
5427
5428	n_coupled = c_desc->n_coupled;
5429
5430	for (i = 1; i < n_coupled; i++) {
5431		c_rdev = c_desc->coupled_rdevs[i];
5432
5433		if (!c_rdev)
5434			continue;
5435
5436		regulator_lock(c_rdev);
5437
5438		__c_desc = &c_rdev->coupling_desc;
5439		__n_coupled = __c_desc->n_coupled;
5440
5441		for (k = 1; k < __n_coupled; k++) {
5442			__c_rdev = __c_desc->coupled_rdevs[k];
5443
5444			if (__c_rdev == rdev) {
5445				__c_desc->coupled_rdevs[k] = NULL;
5446				__c_desc->n_resolved--;
5447				break;
5448			}
5449		}
5450
5451		regulator_unlock(c_rdev);
5452
5453		c_desc->coupled_rdevs[i] = NULL;
5454		c_desc->n_resolved--;
5455	}
5456
5457	if (coupler && coupler->detach_regulator) {
5458		err = coupler->detach_regulator(coupler, rdev);
5459		if (err)
5460			rdev_err(rdev, "failed to detach from coupler: %pe\n",
5461				 ERR_PTR(err));
5462	}
5463
5464	kfree(rdev->coupling_desc.coupled_rdevs);
5465	rdev->coupling_desc.coupled_rdevs = NULL;
5466}
5467
5468static int regulator_init_coupling(struct regulator_dev *rdev)
5469{
5470	struct regulator_dev **coupled;
5471	int err, n_phandles;
5472
5473	if (!IS_ENABLED(CONFIG_OF))
5474		n_phandles = 0;
5475	else
5476		n_phandles = of_get_n_coupled(rdev);
5477
5478	coupled = kcalloc(n_phandles + 1, sizeof(*coupled), GFP_KERNEL);
5479	if (!coupled)
5480		return -ENOMEM;
5481
5482	rdev->coupling_desc.coupled_rdevs = coupled;
5483
5484	/*
5485	 * Every regulator should always have coupling descriptor filled with
5486	 * at least pointer to itself.
5487	 */
5488	rdev->coupling_desc.coupled_rdevs[0] = rdev;
5489	rdev->coupling_desc.n_coupled = n_phandles + 1;
5490	rdev->coupling_desc.n_resolved++;
5491
5492	/* regulator isn't coupled */
5493	if (n_phandles == 0)
5494		return 0;
5495
5496	if (!of_check_coupling_data(rdev))
5497		return -EPERM;
5498
5499	mutex_lock(&regulator_list_mutex);
5500	rdev->coupling_desc.coupler = regulator_find_coupler(rdev);
5501	mutex_unlock(&regulator_list_mutex);
5502
5503	if (IS_ERR(rdev->coupling_desc.coupler)) {
5504		err = PTR_ERR(rdev->coupling_desc.coupler);
5505		rdev_err(rdev, "failed to get coupler: %pe\n", ERR_PTR(err));
5506		return err;
5507	}
5508
5509	return 0;
5510}
5511
5512static int generic_coupler_attach(struct regulator_coupler *coupler,
5513				  struct regulator_dev *rdev)
5514{
5515	if (rdev->coupling_desc.n_coupled > 2) {
5516		rdev_err(rdev,
5517			 "Voltage balancing for multiple regulator couples is unimplemented\n");
5518		return -EPERM;
5519	}
5520
5521	if (!rdev->constraints->always_on) {
5522		rdev_err(rdev,
5523			 "Coupling of a non always-on regulator is unimplemented\n");
5524		return -ENOTSUPP;
5525	}
5526
5527	return 0;
5528}
5529
5530static struct regulator_coupler generic_regulator_coupler = {
5531	.attach_regulator = generic_coupler_attach,
5532};
5533
5534/**
5535 * regulator_register - register regulator
5536 * @dev: the device that drive the regulator
5537 * @regulator_desc: regulator to register
5538 * @cfg: runtime configuration for regulator
 
 
5539 *
5540 * Called by regulator drivers to register a regulator.
5541 * Returns a valid pointer to struct regulator_dev on success
5542 * or an ERR_PTR() on error.
5543 */
5544struct regulator_dev *
5545regulator_register(struct device *dev,
5546		   const struct regulator_desc *regulator_desc,
5547		   const struct regulator_config *cfg)
5548{
5549	const struct regulator_init_data *init_data;
5550	struct regulator_config *config = NULL;
5551	static atomic_t regulator_no = ATOMIC_INIT(-1);
5552	struct regulator_dev *rdev;
5553	bool dangling_cfg_gpiod = false;
5554	bool dangling_of_gpiod = false;
5555	int ret, i;
5556	bool resolved_early = false;
5557
5558	if (cfg == NULL)
5559		return ERR_PTR(-EINVAL);
5560	if (cfg->ena_gpiod)
5561		dangling_cfg_gpiod = true;
5562	if (regulator_desc == NULL) {
5563		ret = -EINVAL;
5564		goto rinse;
5565	}
5566
5567	WARN_ON(!dev || !cfg->dev);
5568
5569	if (regulator_desc->name == NULL || regulator_desc->ops == NULL) {
5570		ret = -EINVAL;
5571		goto rinse;
5572	}
5573
5574	if (regulator_desc->type != REGULATOR_VOLTAGE &&
5575	    regulator_desc->type != REGULATOR_CURRENT) {
5576		ret = -EINVAL;
5577		goto rinse;
5578	}
 
5579
5580	/* Only one of each should be implemented */
5581	WARN_ON(regulator_desc->ops->get_voltage &&
5582		regulator_desc->ops->get_voltage_sel);
5583	WARN_ON(regulator_desc->ops->set_voltage &&
5584		regulator_desc->ops->set_voltage_sel);
5585
5586	/* If we're using selectors we must implement list_voltage. */
5587	if (regulator_desc->ops->get_voltage_sel &&
5588	    !regulator_desc->ops->list_voltage) {
5589		ret = -EINVAL;
5590		goto rinse;
5591	}
5592	if (regulator_desc->ops->set_voltage_sel &&
5593	    !regulator_desc->ops->list_voltage) {
5594		ret = -EINVAL;
5595		goto rinse;
5596	}
5597
5598	rdev = kzalloc(sizeof(struct regulator_dev), GFP_KERNEL);
5599	if (rdev == NULL) {
5600		ret = -ENOMEM;
5601		goto rinse;
5602	}
5603	device_initialize(&rdev->dev);
5604	dev_set_drvdata(&rdev->dev, rdev);
5605	rdev->dev.class = &regulator_class;
5606	spin_lock_init(&rdev->err_lock);
5607
5608	/*
5609	 * Duplicate the config so the driver could override it after
5610	 * parsing init data.
5611	 */
5612	config = kmemdup(cfg, sizeof(*cfg), GFP_KERNEL);
5613	if (config == NULL) {
5614		ret = -ENOMEM;
5615		goto clean;
5616	}
5617
5618	init_data = regulator_of_get_init_data(dev, regulator_desc, config,
5619					       &rdev->dev.of_node);
5620
5621	/*
5622	 * Sometimes not all resources are probed already so we need to take
5623	 * that into account. This happens most the time if the ena_gpiod comes
5624	 * from a gpio extender or something else.
5625	 */
5626	if (PTR_ERR(init_data) == -EPROBE_DEFER) {
5627		ret = -EPROBE_DEFER;
5628		goto clean;
5629	}
5630
5631	/*
5632	 * We need to keep track of any GPIO descriptor coming from the
5633	 * device tree until we have handled it over to the core. If the
5634	 * config that was passed in to this function DOES NOT contain
5635	 * a descriptor, and the config after this call DOES contain
5636	 * a descriptor, we definitely got one from parsing the device
5637	 * tree.
5638	 */
5639	if (!cfg->ena_gpiod && config->ena_gpiod)
5640		dangling_of_gpiod = true;
5641	if (!init_data) {
5642		init_data = config->init_data;
5643		rdev->dev.of_node = of_node_get(config->of_node);
5644	}
5645
5646	ww_mutex_init(&rdev->mutex, &regulator_ww_class);
5647	rdev->reg_data = config->driver_data;
5648	rdev->owner = regulator_desc->owner;
5649	rdev->desc = regulator_desc;
5650	if (config->regmap)
5651		rdev->regmap = config->regmap;
5652	else if (dev_get_regmap(dev, NULL))
5653		rdev->regmap = dev_get_regmap(dev, NULL);
5654	else if (dev->parent)
5655		rdev->regmap = dev_get_regmap(dev->parent, NULL);
5656	INIT_LIST_HEAD(&rdev->consumer_list);
5657	INIT_LIST_HEAD(&rdev->list);
5658	BLOCKING_INIT_NOTIFIER_HEAD(&rdev->notifier);
5659	INIT_DELAYED_WORK(&rdev->disable_work, regulator_disable_work);
5660
5661	if (init_data && init_data->supply_regulator)
5662		rdev->supply_name = init_data->supply_regulator;
5663	else if (regulator_desc->supply_name)
5664		rdev->supply_name = regulator_desc->supply_name;
 
 
5665
5666	/* register with sysfs */
5667	rdev->dev.parent = config->dev;
5668	dev_set_name(&rdev->dev, "regulator.%lu",
5669		    (unsigned long) atomic_inc_return(&regulator_no));
5670
5671	/* set regulator constraints */
5672	if (init_data)
5673		rdev->constraints = kmemdup(&init_data->constraints,
5674					    sizeof(*rdev->constraints),
5675					    GFP_KERNEL);
5676	else
5677		rdev->constraints = kzalloc(sizeof(*rdev->constraints),
5678					    GFP_KERNEL);
5679	if (!rdev->constraints) {
5680		ret = -ENOMEM;
5681		goto wash;
5682	}
5683
5684	if ((rdev->supply_name && !rdev->supply) &&
5685		(rdev->constraints->always_on ||
5686		 rdev->constraints->boot_on)) {
5687		ret = regulator_resolve_supply(rdev);
5688		if (ret)
5689			rdev_dbg(rdev, "unable to resolve supply early: %pe\n",
5690					 ERR_PTR(ret));
5691
5692		resolved_early = true;
5693	}
 
 
5694
5695	/* perform any regulator specific init */
5696	if (init_data && init_data->regulator_init) {
5697		ret = init_data->regulator_init(rdev->reg_data);
5698		if (ret < 0)
5699			goto wash;
5700	}
5701
5702	if (config->ena_gpiod) {
5703		ret = regulator_ena_gpio_request(rdev, config);
5704		if (ret != 0) {
5705			rdev_err(rdev, "Failed to request enable GPIO: %pe\n",
5706				 ERR_PTR(ret));
5707			goto wash;
 
 
 
 
5708		}
5709		/* The regulator core took over the GPIO descriptor */
5710		dangling_cfg_gpiod = false;
5711		dangling_of_gpiod = false;
5712	}
5713
5714	ret = set_machine_constraints(rdev);
5715	if (ret == -EPROBE_DEFER && !resolved_early) {
5716		/* Regulator might be in bypass mode and so needs its supply
5717		 * to set the constraints
5718		 */
5719		/* FIXME: this currently triggers a chicken-and-egg problem
5720		 * when creating -SUPPLY symlink in sysfs to a regulator
5721		 * that is just being created
5722		 */
5723		rdev_dbg(rdev, "will resolve supply early: %s\n",
5724			 rdev->supply_name);
5725		ret = regulator_resolve_supply(rdev);
5726		if (!ret)
5727			ret = set_machine_constraints(rdev);
5728		else
5729			rdev_dbg(rdev, "unable to resolve supply early: %pe\n",
5730				 ERR_PTR(ret));
5731	}
5732	if (ret < 0)
5733		goto wash;
5734
5735	ret = regulator_init_coupling(rdev);
5736	if (ret < 0)
5737		goto wash;
 
5738
5739	/* add consumers devices */
5740	if (init_data) {
5741		for (i = 0; i < init_data->num_consumer_supplies; i++) {
5742			ret = set_consumer_device_supply(rdev,
5743				init_data->consumer_supplies[i].dev_name,
 
 
 
5744				init_data->consumer_supplies[i].supply);
5745			if (ret < 0) {
5746				dev_err(dev, "Failed to set supply %s\n",
5747					init_data->consumer_supplies[i].supply);
5748				goto unset_supplies;
5749			}
5750		}
5751	}
5752
5753	if (!rdev->desc->ops->get_voltage &&
5754	    !rdev->desc->ops->list_voltage &&
5755	    !rdev->desc->fixed_uV)
5756		rdev->is_switch = true;
5757
5758	ret = device_add(&rdev->dev);
5759	if (ret != 0)
5760		goto unset_supplies;
5761
5762	rdev_init_debugfs(rdev);
5763
5764	/* try to resolve regulators coupling since a new one was registered */
5765	mutex_lock(&regulator_list_mutex);
5766	regulator_resolve_coupling(rdev);
5767	mutex_unlock(&regulator_list_mutex);
5768
5769	/* try to resolve regulators supply since a new one was registered */
5770	class_for_each_device(&regulator_class, NULL, NULL,
5771			      regulator_register_resolve_supply);
5772	kfree(config);
5773	return rdev;
5774
5775unset_supplies:
5776	mutex_lock(&regulator_list_mutex);
5777	unset_regulator_supplies(rdev);
5778	regulator_remove_coupling(rdev);
5779	mutex_unlock(&regulator_list_mutex);
5780wash:
5781	regulator_put(rdev->supply);
5782	kfree(rdev->coupling_desc.coupled_rdevs);
5783	mutex_lock(&regulator_list_mutex);
5784	regulator_ena_gpio_free(rdev);
5785	mutex_unlock(&regulator_list_mutex);
5786clean:
5787	if (dangling_of_gpiod)
5788		gpiod_put(config->ena_gpiod);
5789	kfree(config);
5790	put_device(&rdev->dev);
5791rinse:
5792	if (dangling_cfg_gpiod)
5793		gpiod_put(cfg->ena_gpiod);
5794	return ERR_PTR(ret);
5795}
5796EXPORT_SYMBOL_GPL(regulator_register);
5797
5798/**
5799 * regulator_unregister - unregister regulator
5800 * @rdev: regulator to unregister
5801 *
5802 * Called by regulator drivers to unregister a regulator.
5803 */
5804void regulator_unregister(struct regulator_dev *rdev)
5805{
5806	if (rdev == NULL)
5807		return;
5808
5809	if (rdev->supply) {
5810		while (rdev->use_count--)
5811			regulator_disable(rdev->supply);
5812		regulator_put(rdev->supply);
5813	}
5814
5815	flush_work(&rdev->disable_work.work);
5816
5817	mutex_lock(&regulator_list_mutex);
5818
 
 
5819	WARN_ON(rdev->open_count);
5820	regulator_remove_coupling(rdev);
5821	unset_regulator_supplies(rdev);
5822	list_del(&rdev->list);
5823	regulator_ena_gpio_free(rdev);
 
5824	device_unregister(&rdev->dev);
5825
5826	mutex_unlock(&regulator_list_mutex);
5827}
5828EXPORT_SYMBOL_GPL(regulator_unregister);
5829
5830#ifdef CONFIG_SUSPEND
5831/**
5832 * regulator_suspend - prepare regulators for system wide suspend
5833 * @dev: ``&struct device`` pointer that is passed to _regulator_suspend()
5834 *
5835 * Configure each regulator with it's suspend operating parameters for state.
 
5836 */
5837static int regulator_suspend(struct device *dev)
5838{
5839	struct regulator_dev *rdev = dev_to_rdev(dev);
5840	suspend_state_t state = pm_suspend_target_state;
5841	int ret;
5842	const struct regulator_state *rstate;
5843
5844	rstate = regulator_get_suspend_state_check(rdev, state);
5845	if (!rstate)
5846		return 0;
 
 
 
5847
5848	regulator_lock(rdev);
5849	ret = __suspend_set_state(rdev, rstate);
5850	regulator_unlock(rdev);
5851
 
 
 
 
 
 
 
5852	return ret;
5853}
 
5854
5855static int regulator_resume(struct device *dev)
 
 
 
 
 
 
5856{
5857	suspend_state_t state = pm_suspend_target_state;
5858	struct regulator_dev *rdev = dev_to_rdev(dev);
5859	struct regulator_state *rstate;
5860	int ret = 0;
5861
5862	rstate = regulator_get_suspend_state(rdev, state);
5863	if (rstate == NULL)
5864		return 0;
5865
5866	/* Avoid grabbing the lock if we don't need to */
5867	if (!rdev->desc->ops->resume)
5868		return 0;
5869
5870	regulator_lock(rdev);
5871
5872	if (rstate->enabled == ENABLE_IN_SUSPEND ||
5873	    rstate->enabled == DISABLE_IN_SUSPEND)
5874		ret = rdev->desc->ops->resume(rdev);
5875
5876	regulator_unlock(rdev);
 
 
5877
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5878	return ret;
5879}
5880#else /* !CONFIG_SUSPEND */
5881
5882#define regulator_suspend	NULL
5883#define regulator_resume	NULL
5884
5885#endif /* !CONFIG_SUSPEND */
5886
5887#ifdef CONFIG_PM
5888static const struct dev_pm_ops __maybe_unused regulator_pm_ops = {
5889	.suspend	= regulator_suspend,
5890	.resume		= regulator_resume,
5891};
5892#endif
5893
5894struct class regulator_class = {
5895	.name = "regulator",
5896	.dev_release = regulator_dev_release,
5897	.dev_groups = regulator_dev_groups,
5898#ifdef CONFIG_PM
5899	.pm = &regulator_pm_ops,
5900#endif
5901};
5902/**
5903 * regulator_has_full_constraints - the system has fully specified constraints
5904 *
5905 * Calling this function will cause the regulator API to disable all
5906 * regulators which have a zero use count and don't have an always_on
5907 * constraint in a late_initcall.
5908 *
5909 * The intention is that this will become the default behaviour in a
5910 * future kernel release so users are encouraged to use this facility
5911 * now.
5912 */
5913void regulator_has_full_constraints(void)
5914{
5915	has_full_constraints = 1;
5916}
5917EXPORT_SYMBOL_GPL(regulator_has_full_constraints);
5918
5919/**
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5920 * rdev_get_drvdata - get rdev regulator driver data
5921 * @rdev: regulator
5922 *
5923 * Get rdev regulator driver private data. This call can be used in the
5924 * regulator driver context.
5925 */
5926void *rdev_get_drvdata(struct regulator_dev *rdev)
5927{
5928	return rdev->reg_data;
5929}
5930EXPORT_SYMBOL_GPL(rdev_get_drvdata);
5931
5932/**
5933 * regulator_get_drvdata - get regulator driver data
5934 * @regulator: regulator
5935 *
5936 * Get regulator driver private data. This call can be used in the consumer
5937 * driver context when non API regulator specific functions need to be called.
5938 */
5939void *regulator_get_drvdata(struct regulator *regulator)
5940{
5941	return regulator->rdev->reg_data;
5942}
5943EXPORT_SYMBOL_GPL(regulator_get_drvdata);
5944
5945/**
5946 * regulator_set_drvdata - set regulator driver data
5947 * @regulator: regulator
5948 * @data: data
5949 */
5950void regulator_set_drvdata(struct regulator *regulator, void *data)
5951{
5952	regulator->rdev->reg_data = data;
5953}
5954EXPORT_SYMBOL_GPL(regulator_set_drvdata);
5955
5956/**
5957 * rdev_get_id - get regulator ID
5958 * @rdev: regulator
5959 */
5960int rdev_get_id(struct regulator_dev *rdev)
5961{
5962	return rdev->desc->id;
5963}
5964EXPORT_SYMBOL_GPL(rdev_get_id);
5965
5966struct device *rdev_get_dev(struct regulator_dev *rdev)
5967{
5968	return &rdev->dev;
5969}
5970EXPORT_SYMBOL_GPL(rdev_get_dev);
5971
5972struct regmap *rdev_get_regmap(struct regulator_dev *rdev)
5973{
5974	return rdev->regmap;
5975}
5976EXPORT_SYMBOL_GPL(rdev_get_regmap);
5977
5978void *regulator_get_init_drvdata(struct regulator_init_data *reg_init_data)
5979{
5980	return reg_init_data->driver_data;
5981}
5982EXPORT_SYMBOL_GPL(regulator_get_init_drvdata);
5983
5984#ifdef CONFIG_DEBUG_FS
5985static int supply_map_show(struct seq_file *sf, void *data)
5986{
5987	struct regulator_map *map;
5988
5989	list_for_each_entry(map, &regulator_map_list, list) {
5990		seq_printf(sf, "%s -> %s.%s\n",
5991				rdev_get_name(map->regulator), map->dev_name,
5992				map->supply);
5993	}
5994
5995	return 0;
5996}
5997DEFINE_SHOW_ATTRIBUTE(supply_map);
5998
5999struct summary_data {
6000	struct seq_file *s;
6001	struct regulator_dev *parent;
6002	int level;
6003};
6004
6005static void regulator_summary_show_subtree(struct seq_file *s,
6006					   struct regulator_dev *rdev,
6007					   int level);
6008
6009static int regulator_summary_show_children(struct device *dev, void *data)
6010{
6011	struct regulator_dev *rdev = dev_to_rdev(dev);
6012	struct summary_data *summary_data = data;
6013
6014	if (rdev->supply && rdev->supply->rdev == summary_data->parent)
6015		regulator_summary_show_subtree(summary_data->s, rdev,
6016					       summary_data->level + 1);
6017
6018	return 0;
6019}
6020
6021static void regulator_summary_show_subtree(struct seq_file *s,
6022					   struct regulator_dev *rdev,
6023					   int level)
6024{
6025	struct regulation_constraints *c;
6026	struct regulator *consumer;
6027	struct summary_data summary_data;
6028	unsigned int opmode;
6029
6030	if (!rdev)
6031		return;
6032
6033	opmode = _regulator_get_mode_unlocked(rdev);
6034	seq_printf(s, "%*s%-*s %3d %4d %6d %7s ",
6035		   level * 3 + 1, "",
6036		   30 - level * 3, rdev_get_name(rdev),
6037		   rdev->use_count, rdev->open_count, rdev->bypass_count,
6038		   regulator_opmode_to_str(opmode));
6039
6040	seq_printf(s, "%5dmV ", regulator_get_voltage_rdev(rdev) / 1000);
6041	seq_printf(s, "%5dmA ",
6042		   _regulator_get_current_limit_unlocked(rdev) / 1000);
6043
6044	c = rdev->constraints;
6045	if (c) {
6046		switch (rdev->desc->type) {
6047		case REGULATOR_VOLTAGE:
6048			seq_printf(s, "%5dmV %5dmV ",
6049				   c->min_uV / 1000, c->max_uV / 1000);
6050			break;
6051		case REGULATOR_CURRENT:
6052			seq_printf(s, "%5dmA %5dmA ",
6053				   c->min_uA / 1000, c->max_uA / 1000);
6054			break;
6055		}
6056	}
6057
6058	seq_puts(s, "\n");
6059
6060	list_for_each_entry(consumer, &rdev->consumer_list, list) {
6061		if (consumer->dev && consumer->dev->class == &regulator_class)
6062			continue;
6063
6064		seq_printf(s, "%*s%-*s ",
6065			   (level + 1) * 3 + 1, "",
6066			   30 - (level + 1) * 3,
6067			   consumer->supply_name ? consumer->supply_name :
6068			   consumer->dev ? dev_name(consumer->dev) : "deviceless");
6069
6070		switch (rdev->desc->type) {
6071		case REGULATOR_VOLTAGE:
6072			seq_printf(s, "%3d %33dmA%c%5dmV %5dmV",
6073				   consumer->enable_count,
6074				   consumer->uA_load / 1000,
6075				   consumer->uA_load && !consumer->enable_count ?
6076				   '*' : ' ',
6077				   consumer->voltage[PM_SUSPEND_ON].min_uV / 1000,
6078				   consumer->voltage[PM_SUSPEND_ON].max_uV / 1000);
6079			break;
6080		case REGULATOR_CURRENT:
6081			break;
6082		}
6083
6084		seq_puts(s, "\n");
6085	}
6086
6087	summary_data.s = s;
6088	summary_data.level = level;
6089	summary_data.parent = rdev;
6090
6091	class_for_each_device(&regulator_class, NULL, &summary_data,
6092			      regulator_summary_show_children);
6093}
6094
6095struct summary_lock_data {
6096	struct ww_acquire_ctx *ww_ctx;
6097	struct regulator_dev **new_contended_rdev;
6098	struct regulator_dev **old_contended_rdev;
6099};
6100
6101static int regulator_summary_lock_one(struct device *dev, void *data)
6102{
6103	struct regulator_dev *rdev = dev_to_rdev(dev);
6104	struct summary_lock_data *lock_data = data;
6105	int ret = 0;
6106
6107	if (rdev != *lock_data->old_contended_rdev) {
6108		ret = regulator_lock_nested(rdev, lock_data->ww_ctx);
6109
6110		if (ret == -EDEADLK)
6111			*lock_data->new_contended_rdev = rdev;
6112		else
6113			WARN_ON_ONCE(ret);
6114	} else {
6115		*lock_data->old_contended_rdev = NULL;
6116	}
6117
6118	return ret;
6119}
6120
6121static int regulator_summary_unlock_one(struct device *dev, void *data)
6122{
6123	struct regulator_dev *rdev = dev_to_rdev(dev);
6124	struct summary_lock_data *lock_data = data;
6125
6126	if (lock_data) {
6127		if (rdev == *lock_data->new_contended_rdev)
6128			return -EDEADLK;
6129	}
6130
6131	regulator_unlock(rdev);
6132
6133	return 0;
6134}
6135
6136static int regulator_summary_lock_all(struct ww_acquire_ctx *ww_ctx,
6137				      struct regulator_dev **new_contended_rdev,
6138				      struct regulator_dev **old_contended_rdev)
6139{
6140	struct summary_lock_data lock_data;
6141	int ret;
6142
6143	lock_data.ww_ctx = ww_ctx;
6144	lock_data.new_contended_rdev = new_contended_rdev;
6145	lock_data.old_contended_rdev = old_contended_rdev;
6146
6147	ret = class_for_each_device(&regulator_class, NULL, &lock_data,
6148				    regulator_summary_lock_one);
6149	if (ret)
6150		class_for_each_device(&regulator_class, NULL, &lock_data,
6151				      regulator_summary_unlock_one);
6152
6153	return ret;
6154}
6155
6156static void regulator_summary_lock(struct ww_acquire_ctx *ww_ctx)
6157{
6158	struct regulator_dev *new_contended_rdev = NULL;
6159	struct regulator_dev *old_contended_rdev = NULL;
6160	int err;
6161
6162	mutex_lock(&regulator_list_mutex);
6163
6164	ww_acquire_init(ww_ctx, &regulator_ww_class);
6165
6166	do {
6167		if (new_contended_rdev) {
6168			ww_mutex_lock_slow(&new_contended_rdev->mutex, ww_ctx);
6169			old_contended_rdev = new_contended_rdev;
6170			old_contended_rdev->ref_cnt++;
6171			old_contended_rdev->mutex_owner = current;
6172		}
6173
6174		err = regulator_summary_lock_all(ww_ctx,
6175						 &new_contended_rdev,
6176						 &old_contended_rdev);
6177
6178		if (old_contended_rdev)
6179			regulator_unlock(old_contended_rdev);
6180
6181	} while (err == -EDEADLK);
6182
6183	ww_acquire_done(ww_ctx);
6184}
6185
6186static void regulator_summary_unlock(struct ww_acquire_ctx *ww_ctx)
6187{
6188	class_for_each_device(&regulator_class, NULL, NULL,
6189			      regulator_summary_unlock_one);
6190	ww_acquire_fini(ww_ctx);
6191
6192	mutex_unlock(&regulator_list_mutex);
6193}
6194
6195static int regulator_summary_show_roots(struct device *dev, void *data)
6196{
6197	struct regulator_dev *rdev = dev_to_rdev(dev);
6198	struct seq_file *s = data;
6199
6200	if (!rdev->supply)
6201		regulator_summary_show_subtree(s, rdev, 0);
6202
6203	return 0;
6204}
6205
6206static int regulator_summary_show(struct seq_file *s, void *data)
6207{
6208	struct ww_acquire_ctx ww_ctx;
6209
6210	seq_puts(s, " regulator                      use open bypass  opmode voltage current     min     max\n");
6211	seq_puts(s, "---------------------------------------------------------------------------------------\n");
6212
6213	regulator_summary_lock(&ww_ctx);
6214
6215	class_for_each_device(&regulator_class, NULL, s,
6216			      regulator_summary_show_roots);
6217
6218	regulator_summary_unlock(&ww_ctx);
6219
6220	return 0;
6221}
6222DEFINE_SHOW_ATTRIBUTE(regulator_summary);
6223#endif /* CONFIG_DEBUG_FS */
6224
6225static int __init regulator_init(void)
6226{
6227	int ret;
6228
6229	ret = class_register(&regulator_class);
6230
6231	debugfs_root = debugfs_create_dir("regulator", NULL);
6232	if (IS_ERR(debugfs_root))
6233		pr_debug("regulator: Failed to create debugfs directory\n");
6234
6235#ifdef CONFIG_DEBUG_FS
6236	debugfs_create_file("supply_map", 0444, debugfs_root, NULL,
6237			    &supply_map_fops);
6238
6239	debugfs_create_file("regulator_summary", 0444, debugfs_root,
6240			    NULL, &regulator_summary_fops);
6241#endif
6242	regulator_dummy_init();
6243
6244	regulator_coupler_register(&generic_regulator_coupler);
6245
6246	return ret;
6247}
6248
6249/* init early to allow our consumers to complete system booting */
6250core_initcall(regulator_init);
6251
6252static int regulator_late_cleanup(struct device *dev, void *data)
6253{
6254	struct regulator_dev *rdev = dev_to_rdev(dev);
6255	struct regulation_constraints *c = rdev->constraints;
6256	int ret;
6257
6258	if (c && c->always_on)
6259		return 0;
6260
6261	if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_STATUS))
6262		return 0;
6263
6264	regulator_lock(rdev);
 
 
 
 
 
 
6265
6266	if (rdev->use_count)
6267		goto unlock;
6268
6269	/* If reading the status failed, assume that it's off. */
6270	if (_regulator_is_enabled(rdev) <= 0)
6271		goto unlock;
6272
6273	if (have_full_constraints()) {
6274		/* We log since this may kill the system if it goes
6275		 * wrong.
6276		 */
6277		rdev_info(rdev, "disabling\n");
6278		ret = _regulator_do_disable(rdev);
6279		if (ret != 0)
6280			rdev_err(rdev, "couldn't disable: %pe\n", ERR_PTR(ret));
6281	} else {
6282		/* The intention is that in future we will
6283		 * assume that full constraints are provided
6284		 * so warn even if we aren't going to do
6285		 * anything here.
6286		 */
6287		rdev_warn(rdev, "incomplete constraints, leaving on\n");
6288	}
6289
6290unlock:
6291	regulator_unlock(rdev);
6292
6293	return 0;
6294}
 
 
 
6295
6296static bool regulator_ignore_unused;
6297static int __init regulator_ignore_unused_setup(char *__unused)
6298{
6299	regulator_ignore_unused = true;
6300	return 1;
6301}
6302__setup("regulator_ignore_unused", regulator_ignore_unused_setup);
6303
6304static void regulator_init_complete_work_function(struct work_struct *work)
6305{
6306	/*
6307	 * Regulators may had failed to resolve their input supplies
6308	 * when were registered, either because the input supply was
6309	 * not registered yet or because its parent device was not
6310	 * bound yet. So attempt to resolve the input supplies for
6311	 * pending regulators before trying to disable unused ones.
6312	 */
6313	class_for_each_device(&regulator_class, NULL, NULL,
6314			      regulator_register_resolve_supply);
 
 
 
 
 
6315
6316	/*
6317	 * For debugging purposes, it may be useful to prevent unused
6318	 * regulators from being disabled.
6319	 */
6320	if (regulator_ignore_unused) {
6321		pr_warn("regulator: Not disabling unused regulators\n");
6322		return;
6323	}
6324
6325	/* If we have a full configuration then disable any regulators
6326	 * we have permission to change the status for and which are
6327	 * not in use or always_on.  This is effectively the default
6328	 * for DT and ACPI as they have full constraints.
6329	 */
6330	class_for_each_device(&regulator_class, NULL, NULL,
6331			      regulator_late_cleanup);
6332}
6333
6334static DECLARE_DELAYED_WORK(regulator_init_complete_work,
6335			    regulator_init_complete_work_function);
6336
6337static int __init regulator_init_complete(void)
6338{
6339	/*
6340	 * Since DT doesn't provide an idiomatic mechanism for
6341	 * enabling full constraints and since it's much more natural
6342	 * with DT to provide them just assume that a DT enabled
6343	 * system has full constraints.
6344	 */
6345	if (of_have_populated_dt())
6346		has_full_constraints = true;
6347
6348	/*
6349	 * We punt completion for an arbitrary amount of time since
6350	 * systems like distros will load many drivers from userspace
6351	 * so consumers might not always be ready yet, this is
6352	 * particularly an issue with laptops where this might bounce
6353	 * the display off then on.  Ideally we'd get a notification
6354	 * from userspace when this happens but we don't so just wait
6355	 * a bit and hope we waited long enough.  It'd be better if
6356	 * we'd only do this on systems that need it, and a kernel
6357	 * command line option might be useful.
6358	 */
6359	schedule_delayed_work(&regulator_init_complete_work,
6360			      msecs_to_jiffies(30000));
6361
6362	return 0;
6363}
6364late_initcall_sync(regulator_init_complete);
v3.1
   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/async.h>
  24#include <linux/err.h>
  25#include <linux/mutex.h>
  26#include <linux/suspend.h>
  27#include <linux/delay.h>
 
 
 
 
 
  28#include <linux/regulator/consumer.h>
 
  29#include <linux/regulator/driver.h>
  30#include <linux/regulator/machine.h>
 
  31
  32#define CREATE_TRACE_POINTS
  33#include <trace/events/regulator.h>
  34
  35#include "dummy.h"
 
 
  36
  37#define rdev_crit(rdev, fmt, ...)					\
  38	pr_crit("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
  39#define rdev_err(rdev, fmt, ...)					\
  40	pr_err("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
  41#define rdev_warn(rdev, fmt, ...)					\
  42	pr_warn("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
  43#define rdev_info(rdev, fmt, ...)					\
  44	pr_info("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
  45#define rdev_dbg(rdev, fmt, ...)					\
  46	pr_debug("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
  47
  48static DEFINE_MUTEX(regulator_list_mutex);
  49static LIST_HEAD(regulator_list);
  50static LIST_HEAD(regulator_map_list);
 
 
 
  51static bool has_full_constraints;
  52static bool board_wants_dummy_regulator;
  53
  54#ifdef CONFIG_DEBUG_FS
  55static struct dentry *debugfs_root;
  56#endif
  57
  58/*
  59 * struct regulator_map
  60 *
  61 * Used to provide symbolic supply names to devices.
  62 */
  63struct regulator_map {
  64	struct list_head list;
  65	const char *dev_name;   /* The dev_name() for the consumer */
  66	const char *supply;
  67	struct regulator_dev *regulator;
  68};
  69
  70/*
  71 * struct regulator
 
 
 
 
 
 
 
 
 
 
 
 
  72 *
  73 * One for each consumer device.
  74 */
  75struct regulator {
  76	struct device *dev;
  77	struct list_head list;
  78	int uA_load;
  79	int min_uV;
  80	int max_uV;
  81	char *supply_name;
  82	struct device_attribute dev_attr;
  83	struct regulator_dev *rdev;
  84#ifdef CONFIG_DEBUG_FS
  85	struct dentry *debugfs;
  86#endif
  87};
  88
  89static int _regulator_is_enabled(struct regulator_dev *rdev);
  90static int _regulator_disable(struct regulator_dev *rdev);
  91static int _regulator_get_voltage(struct regulator_dev *rdev);
  92static int _regulator_get_current_limit(struct regulator_dev *rdev);
  93static unsigned int _regulator_get_mode(struct regulator_dev *rdev);
  94static void _notifier_call_chain(struct regulator_dev *rdev,
  95				  unsigned long event, void *data);
  96static int _regulator_do_set_voltage(struct regulator_dev *rdev,
  97				     int min_uV, int max_uV);
 
 
  98static struct regulator *create_regulator(struct regulator_dev *rdev,
  99					  struct device *dev,
 100					  const char *supply_name);
 
 
 101
 102static const char *rdev_get_name(struct regulator_dev *rdev)
 103{
 104	if (rdev->constraints && rdev->constraints->name)
 105		return rdev->constraints->name;
 106	else if (rdev->desc->name)
 107		return rdev->desc->name;
 108	else
 109		return "";
 110}
 
 111
 112/* gets the regulator for a given consumer device */
 113static struct regulator *get_device_regulator(struct device *dev)
 114{
 115	struct regulator *regulator = NULL;
 116	struct regulator_dev *rdev;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 117
 118	mutex_lock(&regulator_list_mutex);
 119	list_for_each_entry(rdev, &regulator_list, list) {
 120		mutex_lock(&rdev->mutex);
 121		list_for_each_entry(regulator, &rdev->consumer_list, list) {
 122			if (regulator->dev == dev) {
 123				mutex_unlock(&rdev->mutex);
 124				mutex_unlock(&regulator_list_mutex);
 125				return regulator;
 126			}
 127		}
 128		mutex_unlock(&rdev->mutex);
 129	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 130	mutex_unlock(&regulator_list_mutex);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 131	return NULL;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 132}
 133
 134/* Platform voltage constraint check */
 135static int regulator_check_voltage(struct regulator_dev *rdev,
 136				   int *min_uV, int *max_uV)
 137{
 138	BUG_ON(*min_uV > *max_uV);
 139
 140	if (!rdev->constraints) {
 141		rdev_err(rdev, "no constraints\n");
 142		return -ENODEV;
 143	}
 144	if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) {
 145		rdev_err(rdev, "operation not allowed\n");
 146		return -EPERM;
 147	}
 148
 149	if (*max_uV > rdev->constraints->max_uV)
 150		*max_uV = rdev->constraints->max_uV;
 151	if (*min_uV < rdev->constraints->min_uV)
 152		*min_uV = rdev->constraints->min_uV;
 153
 154	if (*min_uV > *max_uV) {
 155		rdev_err(rdev, "unsupportable voltage range: %d-%duV\n",
 156			 *min_uV, *max_uV);
 157		return -EINVAL;
 158	}
 159
 160	return 0;
 161}
 162
 
 
 
 
 
 
 163/* Make sure we select a voltage that suits the needs of all
 164 * regulator consumers
 165 */
 166static int regulator_check_consumers(struct regulator_dev *rdev,
 167				     int *min_uV, int *max_uV)
 
 168{
 169	struct regulator *regulator;
 
 170
 171	list_for_each_entry(regulator, &rdev->consumer_list, list) {
 
 172		/*
 173		 * Assume consumers that didn't say anything are OK
 174		 * with anything in the constraint range.
 175		 */
 176		if (!regulator->min_uV && !regulator->max_uV)
 177			continue;
 178
 179		if (*max_uV > regulator->max_uV)
 180			*max_uV = regulator->max_uV;
 181		if (*min_uV < regulator->min_uV)
 182			*min_uV = regulator->min_uV;
 183	}
 184
 185	if (*min_uV > *max_uV)
 
 
 186		return -EINVAL;
 
 187
 188	return 0;
 189}
 190
 191/* current constraint check */
 192static int regulator_check_current_limit(struct regulator_dev *rdev,
 193					int *min_uA, int *max_uA)
 194{
 195	BUG_ON(*min_uA > *max_uA);
 196
 197	if (!rdev->constraints) {
 198		rdev_err(rdev, "no constraints\n");
 199		return -ENODEV;
 200	}
 201	if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_CURRENT)) {
 202		rdev_err(rdev, "operation not allowed\n");
 203		return -EPERM;
 204	}
 205
 206	if (*max_uA > rdev->constraints->max_uA)
 207		*max_uA = rdev->constraints->max_uA;
 208	if (*min_uA < rdev->constraints->min_uA)
 209		*min_uA = rdev->constraints->min_uA;
 210
 211	if (*min_uA > *max_uA) {
 212		rdev_err(rdev, "unsupportable current range: %d-%duA\n",
 213			 *min_uA, *max_uA);
 214		return -EINVAL;
 215	}
 216
 217	return 0;
 218}
 219
 220/* operating mode constraint check */
 221static int regulator_mode_constrain(struct regulator_dev *rdev, int *mode)
 
 222{
 223	switch (*mode) {
 224	case REGULATOR_MODE_FAST:
 225	case REGULATOR_MODE_NORMAL:
 226	case REGULATOR_MODE_IDLE:
 227	case REGULATOR_MODE_STANDBY:
 228		break;
 229	default:
 230		rdev_err(rdev, "invalid mode %x specified\n", *mode);
 231		return -EINVAL;
 232	}
 233
 234	if (!rdev->constraints) {
 235		rdev_err(rdev, "no constraints\n");
 236		return -ENODEV;
 237	}
 238	if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_MODE)) {
 239		rdev_err(rdev, "operation not allowed\n");
 240		return -EPERM;
 241	}
 242
 243	/* The modes are bitmasks, the most power hungry modes having
 244	 * the lowest values. If the requested mode isn't supported
 245	 * try higher modes. */
 
 246	while (*mode) {
 247		if (rdev->constraints->valid_modes_mask & *mode)
 248			return 0;
 249		*mode /= 2;
 250	}
 251
 252	return -EINVAL;
 253}
 254
 255/* dynamic regulator mode switching constraint check */
 256static int regulator_check_drms(struct regulator_dev *rdev)
 257{
 258	if (!rdev->constraints) {
 259		rdev_err(rdev, "no constraints\n");
 260		return -ENODEV;
 261	}
 262	if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_DRMS)) {
 263		rdev_err(rdev, "operation not allowed\n");
 264		return -EPERM;
 
 
 
 
 
 265	}
 266	return 0;
 267}
 268
 269static ssize_t device_requested_uA_show(struct device *dev,
 270			     struct device_attribute *attr, char *buf)
 271{
 272	struct regulator *regulator;
 
 
 
 
 273
 274	regulator = get_device_regulator(dev);
 275	if (regulator == NULL)
 276		return 0;
 
 
 
 
 
 
 
 
 277
 278	return sprintf(buf, "%d\n", regulator->uA_load);
 279}
 280
 281static ssize_t regulator_uV_show(struct device *dev,
 282				struct device_attribute *attr, char *buf)
 283{
 284	struct regulator_dev *rdev = dev_get_drvdata(dev);
 285	ssize_t ret;
 286
 287	mutex_lock(&rdev->mutex);
 288	ret = sprintf(buf, "%d\n", _regulator_get_voltage(rdev));
 289	mutex_unlock(&rdev->mutex);
 290
 291	return ret;
 
 
 292}
 293static DEVICE_ATTR(microvolts, 0444, regulator_uV_show, NULL);
 294
 295static ssize_t regulator_uA_show(struct device *dev,
 296				struct device_attribute *attr, char *buf)
 297{
 298	struct regulator_dev *rdev = dev_get_drvdata(dev);
 299
 300	return sprintf(buf, "%d\n", _regulator_get_current_limit(rdev));
 301}
 302static DEVICE_ATTR(microamps, 0444, regulator_uA_show, NULL);
 303
 304static ssize_t regulator_name_show(struct device *dev,
 305			     struct device_attribute *attr, char *buf)
 306{
 307	struct regulator_dev *rdev = dev_get_drvdata(dev);
 308
 309	return sprintf(buf, "%s\n", rdev_get_name(rdev));
 310}
 
 311
 312static ssize_t regulator_print_opmode(char *buf, int mode)
 313{
 314	switch (mode) {
 315	case REGULATOR_MODE_FAST:
 316		return sprintf(buf, "fast\n");
 317	case REGULATOR_MODE_NORMAL:
 318		return sprintf(buf, "normal\n");
 319	case REGULATOR_MODE_IDLE:
 320		return sprintf(buf, "idle\n");
 321	case REGULATOR_MODE_STANDBY:
 322		return sprintf(buf, "standby\n");
 323	}
 324	return sprintf(buf, "unknown\n");
 
 
 
 
 
 325}
 326
 327static ssize_t regulator_opmode_show(struct device *dev,
 328				    struct device_attribute *attr, char *buf)
 329{
 330	struct regulator_dev *rdev = dev_get_drvdata(dev);
 331
 332	return regulator_print_opmode(buf, _regulator_get_mode(rdev));
 333}
 334static DEVICE_ATTR(opmode, 0444, regulator_opmode_show, NULL);
 335
 336static ssize_t regulator_print_state(char *buf, int state)
 337{
 338	if (state > 0)
 339		return sprintf(buf, "enabled\n");
 340	else if (state == 0)
 341		return sprintf(buf, "disabled\n");
 342	else
 343		return sprintf(buf, "unknown\n");
 344}
 345
 346static ssize_t regulator_state_show(struct device *dev,
 347				   struct device_attribute *attr, char *buf)
 348{
 349	struct regulator_dev *rdev = dev_get_drvdata(dev);
 350	ssize_t ret;
 351
 352	mutex_lock(&rdev->mutex);
 353	ret = regulator_print_state(buf, _regulator_is_enabled(rdev));
 354	mutex_unlock(&rdev->mutex);
 355
 356	return ret;
 357}
 358static DEVICE_ATTR(state, 0444, regulator_state_show, NULL);
 359
 360static ssize_t regulator_status_show(struct device *dev,
 361				   struct device_attribute *attr, char *buf)
 362{
 363	struct regulator_dev *rdev = dev_get_drvdata(dev);
 364	int status;
 365	char *label;
 366
 367	status = rdev->desc->ops->get_status(rdev);
 368	if (status < 0)
 369		return status;
 370
 371	switch (status) {
 372	case REGULATOR_STATUS_OFF:
 373		label = "off";
 374		break;
 375	case REGULATOR_STATUS_ON:
 376		label = "on";
 377		break;
 378	case REGULATOR_STATUS_ERROR:
 379		label = "error";
 380		break;
 381	case REGULATOR_STATUS_FAST:
 382		label = "fast";
 383		break;
 384	case REGULATOR_STATUS_NORMAL:
 385		label = "normal";
 386		break;
 387	case REGULATOR_STATUS_IDLE:
 388		label = "idle";
 389		break;
 390	case REGULATOR_STATUS_STANDBY:
 391		label = "standby";
 392		break;
 
 
 
 
 
 
 393	default:
 394		return -ERANGE;
 395	}
 396
 397	return sprintf(buf, "%s\n", label);
 398}
 399static DEVICE_ATTR(status, 0444, regulator_status_show, NULL);
 400
 401static ssize_t regulator_min_uA_show(struct device *dev,
 402				    struct device_attribute *attr, char *buf)
 403{
 404	struct regulator_dev *rdev = dev_get_drvdata(dev);
 405
 406	if (!rdev->constraints)
 407		return sprintf(buf, "constraint not defined\n");
 408
 409	return sprintf(buf, "%d\n", rdev->constraints->min_uA);
 410}
 411static DEVICE_ATTR(min_microamps, 0444, regulator_min_uA_show, NULL);
 412
 413static ssize_t regulator_max_uA_show(struct device *dev,
 414				    struct device_attribute *attr, char *buf)
 415{
 416	struct regulator_dev *rdev = dev_get_drvdata(dev);
 417
 418	if (!rdev->constraints)
 419		return sprintf(buf, "constraint not defined\n");
 420
 421	return sprintf(buf, "%d\n", rdev->constraints->max_uA);
 422}
 423static DEVICE_ATTR(max_microamps, 0444, regulator_max_uA_show, NULL);
 424
 425static ssize_t regulator_min_uV_show(struct device *dev,
 426				    struct device_attribute *attr, char *buf)
 427{
 428	struct regulator_dev *rdev = dev_get_drvdata(dev);
 429
 430	if (!rdev->constraints)
 431		return sprintf(buf, "constraint not defined\n");
 432
 433	return sprintf(buf, "%d\n", rdev->constraints->min_uV);
 434}
 435static DEVICE_ATTR(min_microvolts, 0444, regulator_min_uV_show, NULL);
 436
 437static ssize_t regulator_max_uV_show(struct device *dev,
 438				    struct device_attribute *attr, char *buf)
 439{
 440	struct regulator_dev *rdev = dev_get_drvdata(dev);
 441
 442	if (!rdev->constraints)
 443		return sprintf(buf, "constraint not defined\n");
 444
 445	return sprintf(buf, "%d\n", rdev->constraints->max_uV);
 446}
 447static DEVICE_ATTR(max_microvolts, 0444, regulator_max_uV_show, NULL);
 448
 449static ssize_t regulator_total_uA_show(struct device *dev,
 450				      struct device_attribute *attr, char *buf)
 451{
 452	struct regulator_dev *rdev = dev_get_drvdata(dev);
 453	struct regulator *regulator;
 454	int uA = 0;
 455
 456	mutex_lock(&rdev->mutex);
 457	list_for_each_entry(regulator, &rdev->consumer_list, list)
 458		uA += regulator->uA_load;
 459	mutex_unlock(&rdev->mutex);
 
 
 460	return sprintf(buf, "%d\n", uA);
 461}
 462static DEVICE_ATTR(requested_microamps, 0444, regulator_total_uA_show, NULL);
 463
 464static ssize_t regulator_num_users_show(struct device *dev,
 465				      struct device_attribute *attr, char *buf)
 466{
 467	struct regulator_dev *rdev = dev_get_drvdata(dev);
 468	return sprintf(buf, "%d\n", rdev->use_count);
 469}
 
 470
 471static ssize_t regulator_type_show(struct device *dev,
 472				  struct device_attribute *attr, char *buf)
 473{
 474	struct regulator_dev *rdev = dev_get_drvdata(dev);
 475
 476	switch (rdev->desc->type) {
 477	case REGULATOR_VOLTAGE:
 478		return sprintf(buf, "voltage\n");
 479	case REGULATOR_CURRENT:
 480		return sprintf(buf, "current\n");
 481	}
 482	return sprintf(buf, "unknown\n");
 483}
 
 484
 485static ssize_t regulator_suspend_mem_uV_show(struct device *dev,
 486				struct device_attribute *attr, char *buf)
 487{
 488	struct regulator_dev *rdev = dev_get_drvdata(dev);
 489
 490	return sprintf(buf, "%d\n", rdev->constraints->state_mem.uV);
 491}
 492static DEVICE_ATTR(suspend_mem_microvolts, 0444,
 493		regulator_suspend_mem_uV_show, NULL);
 494
 495static ssize_t regulator_suspend_disk_uV_show(struct device *dev,
 496				struct device_attribute *attr, char *buf)
 497{
 498	struct regulator_dev *rdev = dev_get_drvdata(dev);
 499
 500	return sprintf(buf, "%d\n", rdev->constraints->state_disk.uV);
 501}
 502static DEVICE_ATTR(suspend_disk_microvolts, 0444,
 503		regulator_suspend_disk_uV_show, NULL);
 504
 505static ssize_t regulator_suspend_standby_uV_show(struct device *dev,
 506				struct device_attribute *attr, char *buf)
 507{
 508	struct regulator_dev *rdev = dev_get_drvdata(dev);
 509
 510	return sprintf(buf, "%d\n", rdev->constraints->state_standby.uV);
 511}
 512static DEVICE_ATTR(suspend_standby_microvolts, 0444,
 513		regulator_suspend_standby_uV_show, NULL);
 514
 515static ssize_t regulator_suspend_mem_mode_show(struct device *dev,
 516				struct device_attribute *attr, char *buf)
 517{
 518	struct regulator_dev *rdev = dev_get_drvdata(dev);
 519
 520	return regulator_print_opmode(buf,
 521		rdev->constraints->state_mem.mode);
 522}
 523static DEVICE_ATTR(suspend_mem_mode, 0444,
 524		regulator_suspend_mem_mode_show, NULL);
 525
 526static ssize_t regulator_suspend_disk_mode_show(struct device *dev,
 527				struct device_attribute *attr, char *buf)
 528{
 529	struct regulator_dev *rdev = dev_get_drvdata(dev);
 530
 531	return regulator_print_opmode(buf,
 532		rdev->constraints->state_disk.mode);
 533}
 534static DEVICE_ATTR(suspend_disk_mode, 0444,
 535		regulator_suspend_disk_mode_show, NULL);
 536
 537static ssize_t regulator_suspend_standby_mode_show(struct device *dev,
 538				struct device_attribute *attr, char *buf)
 539{
 540	struct regulator_dev *rdev = dev_get_drvdata(dev);
 541
 542	return regulator_print_opmode(buf,
 543		rdev->constraints->state_standby.mode);
 544}
 545static DEVICE_ATTR(suspend_standby_mode, 0444,
 546		regulator_suspend_standby_mode_show, NULL);
 547
 548static ssize_t regulator_suspend_mem_state_show(struct device *dev,
 549				   struct device_attribute *attr, char *buf)
 550{
 551	struct regulator_dev *rdev = dev_get_drvdata(dev);
 552
 553	return regulator_print_state(buf,
 554			rdev->constraints->state_mem.enabled);
 555}
 556static DEVICE_ATTR(suspend_mem_state, 0444,
 557		regulator_suspend_mem_state_show, NULL);
 558
 559static ssize_t regulator_suspend_disk_state_show(struct device *dev,
 560				   struct device_attribute *attr, char *buf)
 561{
 562	struct regulator_dev *rdev = dev_get_drvdata(dev);
 563
 564	return regulator_print_state(buf,
 565			rdev->constraints->state_disk.enabled);
 566}
 567static DEVICE_ATTR(suspend_disk_state, 0444,
 568		regulator_suspend_disk_state_show, NULL);
 569
 570static ssize_t regulator_suspend_standby_state_show(struct device *dev,
 571				   struct device_attribute *attr, char *buf)
 572{
 573	struct regulator_dev *rdev = dev_get_drvdata(dev);
 574
 575	return regulator_print_state(buf,
 576			rdev->constraints->state_standby.enabled);
 577}
 578static DEVICE_ATTR(suspend_standby_state, 0444,
 579		regulator_suspend_standby_state_show, NULL);
 
 
 
 
 
 
 
 580
 
 581
 582/*
 583 * These are the only attributes are present for all regulators.
 584 * Other attributes are a function of regulator functionality.
 585 */
 586static struct device_attribute regulator_dev_attrs[] = {
 587	__ATTR(name, 0444, regulator_name_show, NULL),
 588	__ATTR(num_users, 0444, regulator_num_users_show, NULL),
 589	__ATTR(type, 0444, regulator_type_show, NULL),
 590	__ATTR_NULL,
 591};
 592
 593static void regulator_dev_release(struct device *dev)
 594{
 595	struct regulator_dev *rdev = dev_get_drvdata(dev);
 596	kfree(rdev);
 597}
 
 598
 599static struct class regulator_class = {
 600	.name = "regulator",
 601	.dev_release = regulator_dev_release,
 602	.dev_attrs = regulator_dev_attrs,
 603};
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 604
 605/* Calculate the new optimum regulator operating mode based on the new total
 606 * consumer load. All locks held by caller */
 607static void drms_uA_update(struct regulator_dev *rdev)
 
 608{
 609	struct regulator *sibling;
 610	int current_uA = 0, output_uV, input_uV, err;
 611	unsigned int mode;
 612
 613	err = regulator_check_drms(rdev);
 614	if (err < 0 || !rdev->desc->ops->get_optimum_mode ||
 615	    (!rdev->desc->ops->get_voltage &&
 616	     !rdev->desc->ops->get_voltage_sel) ||
 617	    !rdev->desc->ops->set_mode)
 618		return;
 
 
 619
 620	/* get output voltage */
 621	output_uV = _regulator_get_voltage(rdev);
 622	if (output_uV <= 0)
 623		return;
 624
 625	/* get input voltage */
 626	input_uV = 0;
 627	if (rdev->supply)
 628		input_uV = _regulator_get_voltage(rdev);
 629	if (input_uV <= 0)
 630		input_uV = rdev->constraints->input_uV;
 631	if (input_uV <= 0)
 632		return;
 633
 634	/* calc total requested load */
 635	list_for_each_entry(sibling, &rdev->consumer_list, list)
 636		current_uA += sibling->uA_load;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 637
 638	/* now get the optimum mode for our new total regulator load */
 639	mode = rdev->desc->ops->get_optimum_mode(rdev, input_uV,
 640						  output_uV, current_uA);
 
 
 
 641
 642	/* check the new mode is allowed */
 643	err = regulator_mode_constrain(rdev, &mode);
 644	if (err == 0)
 645		rdev->desc->ops->set_mode(rdev, mode);
 646}
 
 647
 648static int suspend_set_state(struct regulator_dev *rdev,
 649	struct regulator_state *rstate)
 650{
 651	int ret = 0;
 652	bool can_set_state;
 653
 654	can_set_state = rdev->desc->ops->set_suspend_enable &&
 655		rdev->desc->ops->set_suspend_disable;
 
 
 
 
 
 656
 657	/* If we have no suspend mode configration don't set anything;
 658	 * only warn if the driver actually makes the suspend mode
 659	 * configurable.
 660	 */
 661	if (!rstate->enabled && !rstate->disabled) {
 662		if (can_set_state)
 663			rdev_warn(rdev, "No configuration\n");
 664		return 0;
 665	}
 666
 667	if (rstate->enabled && rstate->disabled) {
 668		rdev_err(rdev, "invalid configuration\n");
 669		return -EINVAL;
 670	}
 671
 672	if (!can_set_state) {
 673		rdev_err(rdev, "no way to set suspend state\n");
 674		return -EINVAL;
 675	}
 676
 677	if (rstate->enabled)
 
 678		ret = rdev->desc->ops->set_suspend_enable(rdev);
 679	else
 
 680		ret = rdev->desc->ops->set_suspend_disable(rdev);
 
 
 
 681	if (ret < 0) {
 682		rdev_err(rdev, "failed to enabled/disable\n");
 683		return ret;
 684	}
 685
 686	if (rdev->desc->ops->set_suspend_voltage && rstate->uV > 0) {
 687		ret = rdev->desc->ops->set_suspend_voltage(rdev, rstate->uV);
 688		if (ret < 0) {
 689			rdev_err(rdev, "failed to set voltage\n");
 690			return ret;
 691		}
 692	}
 693
 694	if (rdev->desc->ops->set_suspend_mode && rstate->mode > 0) {
 695		ret = rdev->desc->ops->set_suspend_mode(rdev, rstate->mode);
 696		if (ret < 0) {
 697			rdev_err(rdev, "failed to set mode\n");
 698			return ret;
 699		}
 700	}
 
 701	return ret;
 702}
 703
 704/* locks held by caller */
 705static int suspend_prepare(struct regulator_dev *rdev, suspend_state_t state)
 706{
 707	if (!rdev->constraints)
 708		return -EINVAL;
 
 
 
 
 709
 710	switch (state) {
 711	case PM_SUSPEND_STANDBY:
 712		return suspend_set_state(rdev,
 713			&rdev->constraints->state_standby);
 714	case PM_SUSPEND_MEM:
 715		return suspend_set_state(rdev,
 716			&rdev->constraints->state_mem);
 717	case PM_SUSPEND_MAX:
 718		return suspend_set_state(rdev,
 719			&rdev->constraints->state_disk);
 720	default:
 721		return -EINVAL;
 722	}
 723}
 724
 725static void print_constraints(struct regulator_dev *rdev)
 
 726{
 727	struct regulation_constraints *constraints = rdev->constraints;
 728	char buf[80] = "";
 
 729	int count = 0;
 730	int ret;
 731
 732	if (constraints->min_uV && constraints->max_uV) {
 733		if (constraints->min_uV == constraints->max_uV)
 734			count += sprintf(buf + count, "%d mV ",
 735					 constraints->min_uV / 1000);
 736		else
 737			count += sprintf(buf + count, "%d <--> %d mV ",
 738					 constraints->min_uV / 1000,
 739					 constraints->max_uV / 1000);
 
 740	}
 741
 742	if (!constraints->min_uV ||
 743	    constraints->min_uV != constraints->max_uV) {
 744		ret = _regulator_get_voltage(rdev);
 745		if (ret > 0)
 746			count += sprintf(buf + count, "at %d mV ", ret / 1000);
 
 747	}
 748
 749	if (constraints->uV_offset)
 750		count += sprintf(buf, "%dmV offset ",
 751				 constraints->uV_offset / 1000);
 752
 753	if (constraints->min_uA && constraints->max_uA) {
 754		if (constraints->min_uA == constraints->max_uA)
 755			count += sprintf(buf + count, "%d mA ",
 756					 constraints->min_uA / 1000);
 757		else
 758			count += sprintf(buf + count, "%d <--> %d mA ",
 759					 constraints->min_uA / 1000,
 760					 constraints->max_uA / 1000);
 
 761	}
 762
 763	if (!constraints->min_uA ||
 764	    constraints->min_uA != constraints->max_uA) {
 765		ret = _regulator_get_current_limit(rdev);
 766		if (ret > 0)
 767			count += sprintf(buf + count, "at %d mA ", ret / 1000);
 
 768	}
 769
 770	if (constraints->valid_modes_mask & REGULATOR_MODE_FAST)
 771		count += sprintf(buf + count, "fast ");
 772	if (constraints->valid_modes_mask & REGULATOR_MODE_NORMAL)
 773		count += sprintf(buf + count, "normal ");
 774	if (constraints->valid_modes_mask & REGULATOR_MODE_IDLE)
 775		count += sprintf(buf + count, "idle ");
 776	if (constraints->valid_modes_mask & REGULATOR_MODE_STANDBY)
 777		count += sprintf(buf + count, "standby");
 778
 779	rdev_info(rdev, "%s\n", buf);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 780}
 781
 782static int machine_constraints_voltage(struct regulator_dev *rdev,
 783	struct regulation_constraints *constraints)
 784{
 785	struct regulator_ops *ops = rdev->desc->ops;
 786	int ret;
 787
 788	/* do we need to apply the constraint voltage */
 789	if (rdev->constraints->apply_uV &&
 790	    rdev->constraints->min_uV == rdev->constraints->max_uV) {
 791		ret = _regulator_do_set_voltage(rdev,
 792						rdev->constraints->min_uV,
 793						rdev->constraints->max_uV);
 794		if (ret < 0) {
 795			rdev_err(rdev, "failed to apply %duV constraint\n",
 796				 rdev->constraints->min_uV);
 797			return ret;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 798		}
 799	}
 800
 801	/* constrain machine-level voltage specs to fit
 802	 * the actual range supported by this regulator.
 803	 */
 804	if (ops->list_voltage && rdev->desc->n_voltages) {
 805		int	count = rdev->desc->n_voltages;
 806		int	i;
 807		int	min_uV = INT_MAX;
 808		int	max_uV = INT_MIN;
 809		int	cmin = constraints->min_uV;
 810		int	cmax = constraints->max_uV;
 811
 812		/* it's safe to autoconfigure fixed-voltage supplies
 813		   and the constraints are used by list_voltage. */
 
 814		if (count == 1 && !cmin) {
 815			cmin = 1;
 816			cmax = INT_MAX;
 817			constraints->min_uV = cmin;
 818			constraints->max_uV = cmax;
 819		}
 820
 821		/* voltage constraints are optional */
 822		if ((cmin == 0) && (cmax == 0))
 823			return 0;
 824
 825		/* else require explicit machine-level constraints */
 826		if (cmin <= 0 || cmax <= 0 || cmax < cmin) {
 827			rdev_err(rdev, "invalid voltage constraints\n");
 828			return -EINVAL;
 829		}
 830
 
 
 
 
 831		/* initial: [cmin..cmax] valid, [min_uV..max_uV] not */
 832		for (i = 0; i < count; i++) {
 833			int	value;
 834
 835			value = ops->list_voltage(rdev, i);
 836			if (value <= 0)
 837				continue;
 838
 839			/* maybe adjust [min_uV..max_uV] */
 840			if (value >= cmin && value < min_uV)
 841				min_uV = value;
 842			if (value <= cmax && value > max_uV)
 843				max_uV = value;
 844		}
 845
 846		/* final: [min_uV..max_uV] valid iff constraints valid */
 847		if (max_uV < min_uV) {
 848			rdev_err(rdev, "unsupportable voltage constraints\n");
 
 
 849			return -EINVAL;
 850		}
 851
 852		/* use regulator's subset of machine constraints */
 853		if (constraints->min_uV < min_uV) {
 854			rdev_dbg(rdev, "override min_uV, %d -> %d\n",
 855				 constraints->min_uV, min_uV);
 856			constraints->min_uV = min_uV;
 857		}
 858		if (constraints->max_uV > max_uV) {
 859			rdev_dbg(rdev, "override max_uV, %d -> %d\n",
 860				 constraints->max_uV, max_uV);
 861			constraints->max_uV = max_uV;
 862		}
 863	}
 864
 865	return 0;
 866}
 867
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 868/**
 869 * set_machine_constraints - sets regulator constraints
 870 * @rdev: regulator source
 871 * @constraints: constraints to apply
 872 *
 873 * Allows platform initialisation code to define and constrain
 874 * regulator circuits e.g. valid voltage/current ranges, etc.  NOTE:
 875 * Constraints *must* be set by platform code in order for some
 876 * regulator operations to proceed i.e. set_voltage, set_current_limit,
 877 * set_mode.
 878 */
 879static int set_machine_constraints(struct regulator_dev *rdev,
 880	const struct regulation_constraints *constraints)
 881{
 882	int ret = 0;
 883	struct regulator_ops *ops = rdev->desc->ops;
 884
 885	rdev->constraints = kmemdup(constraints, sizeof(*constraints),
 886				    GFP_KERNEL);
 887	if (!rdev->constraints)
 888		return -ENOMEM;
 889
 890	ret = machine_constraints_voltage(rdev, rdev->constraints);
 891	if (ret != 0)
 892		goto out;
 
 
 
 
 
 
 
 
 
 893
 894	/* do we need to setup our suspend state */
 895	if (constraints->initial_state) {
 896		ret = suspend_prepare(rdev, rdev->constraints->initial_state);
 897		if (ret < 0) {
 898			rdev_err(rdev, "failed to set suspend state\n");
 899			goto out;
 900		}
 901	}
 902
 903	if (constraints->initial_mode) {
 904		if (!ops->set_mode) {
 905			rdev_err(rdev, "no set_mode operation\n");
 906			ret = -EINVAL;
 907			goto out;
 908		}
 909
 910		ret = ops->set_mode(rdev, rdev->constraints->initial_mode);
 911		if (ret < 0) {
 912			rdev_err(rdev, "failed to set initial mode: %d\n", ret);
 913			goto out;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 914		}
 915	}
 916
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 917	/* If the constraints say the regulator should be on at this point
 918	 * and we have control then make sure it is enabled.
 919	 */
 920	if ((rdev->constraints->always_on || rdev->constraints->boot_on) &&
 921	    ops->enable) {
 922		ret = ops->enable(rdev);
 923		if (ret < 0) {
 924			rdev_err(rdev, "failed to enable\n");
 925			goto out;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 926		}
 
 
 
 
 
 927	}
 928
 929	print_constraints(rdev);
 930	return 0;
 931out:
 932	kfree(rdev->constraints);
 933	rdev->constraints = NULL;
 934	return ret;
 935}
 936
 937/**
 938 * set_supply - set regulator supply regulator
 939 * @rdev: regulator name
 940 * @supply_rdev: supply regulator name
 941 *
 942 * Called by platform initialisation code to set the supply regulator for this
 943 * regulator. This ensures that a regulators supply will also be enabled by the
 944 * core if it's child is enabled.
 945 */
 946static int set_supply(struct regulator_dev *rdev,
 947		      struct regulator_dev *supply_rdev)
 948{
 949	int err;
 950
 951	rdev_info(rdev, "supplied by %s\n", rdev_get_name(supply_rdev));
 
 
 
 952
 953	rdev->supply = create_regulator(supply_rdev, &rdev->dev, "SUPPLY");
 954	if (IS_ERR(rdev->supply)) {
 955		err = PTR_ERR(rdev->supply);
 956		rdev->supply = NULL;
 957		return err;
 958	}
 
 959
 960	return 0;
 961}
 962
 963/**
 964 * set_consumer_device_supply - Bind a regulator to a symbolic supply
 965 * @rdev:         regulator source
 966 * @consumer_dev: device the supply applies to
 967 * @consumer_dev_name: dev_name() string for device supply applies to
 968 * @supply:       symbolic name for supply
 969 *
 970 * Allows platform initialisation code to map physical regulator
 971 * sources to symbolic names for supplies for use by devices.  Devices
 972 * should use these symbolic names to request regulators, avoiding the
 973 * need to provide board-specific regulator names as platform data.
 974 *
 975 * Only one of consumer_dev and consumer_dev_name may be specified.
 976 */
 977static int set_consumer_device_supply(struct regulator_dev *rdev,
 978	struct device *consumer_dev, const char *consumer_dev_name,
 979	const char *supply)
 980{
 981	struct regulator_map *node;
 982	int has_dev;
 983
 984	if (consumer_dev && consumer_dev_name)
 985		return -EINVAL;
 986
 987	if (!consumer_dev_name && consumer_dev)
 988		consumer_dev_name = dev_name(consumer_dev);
 989
 990	if (supply == NULL)
 991		return -EINVAL;
 992
 993	if (consumer_dev_name != NULL)
 994		has_dev = 1;
 995	else
 996		has_dev = 0;
 997
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 998	list_for_each_entry(node, &regulator_map_list, list) {
 999		if (node->dev_name && consumer_dev_name) {
1000			if (strcmp(node->dev_name, consumer_dev_name) != 0)
1001				continue;
1002		} else if (node->dev_name || consumer_dev_name) {
1003			continue;
1004		}
1005
1006		if (strcmp(node->supply, supply) != 0)
1007			continue;
1008
1009		dev_dbg(consumer_dev, "%s/%s is '%s' supply; fail %s/%s\n",
1010			dev_name(&node->regulator->dev),
1011			node->regulator->desc->name,
1012			supply,
1013			dev_name(&rdev->dev), rdev_get_name(rdev));
1014		return -EBUSY;
 
1015	}
1016
1017	node = kzalloc(sizeof(struct regulator_map), GFP_KERNEL);
1018	if (node == NULL)
1019		return -ENOMEM;
1020
1021	node->regulator = rdev;
1022	node->supply = supply;
1023
1024	if (has_dev) {
1025		node->dev_name = kstrdup(consumer_dev_name, GFP_KERNEL);
1026		if (node->dev_name == NULL) {
1027			kfree(node);
1028			return -ENOMEM;
1029		}
1030	}
1031
1032	list_add(&node->list, &regulator_map_list);
1033	return 0;
1034}
1035
1036static void unset_regulator_supplies(struct regulator_dev *rdev)
1037{
1038	struct regulator_map *node, *n;
1039
1040	list_for_each_entry_safe(node, n, &regulator_map_list, list) {
1041		if (rdev == node->regulator) {
1042			list_del(&node->list);
1043			kfree(node->dev_name);
1044			kfree(node);
1045		}
1046	}
1047}
1048
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1049#define REG_STR_SIZE	64
1050
1051static struct regulator *create_regulator(struct regulator_dev *rdev,
1052					  struct device *dev,
1053					  const char *supply_name)
1054{
1055	struct regulator *regulator;
1056	char buf[REG_STR_SIZE];
1057	int err, size;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1058
1059	regulator = kzalloc(sizeof(*regulator), GFP_KERNEL);
1060	if (regulator == NULL)
 
1061		return NULL;
 
1062
1063	mutex_lock(&rdev->mutex);
1064	regulator->rdev = rdev;
 
 
1065	list_add(&regulator->list, &rdev->consumer_list);
1066
1067	if (dev) {
1068		/* create a 'requested_microamps_name' sysfs entry */
1069		size = scnprintf(buf, REG_STR_SIZE,
1070				 "microamps_requested_%s-%s",
1071				 dev_name(dev), supply_name);
1072		if (size >= REG_STR_SIZE)
1073			goto overflow_err;
1074
1075		regulator->dev = dev;
1076		sysfs_attr_init(&regulator->dev_attr.attr);
1077		regulator->dev_attr.attr.name = kstrdup(buf, GFP_KERNEL);
1078		if (regulator->dev_attr.attr.name == NULL)
1079			goto attr_name_err;
1080
1081		regulator->dev_attr.attr.mode = 0444;
1082		regulator->dev_attr.show = device_requested_uA_show;
1083		err = device_create_file(dev, &regulator->dev_attr);
1084		if (err < 0) {
1085			rdev_warn(rdev, "could not add regulator_dev requested microamps sysfs entry\n");
1086			goto attr_name_err;
1087		}
1088
1089		/* also add a link to the device sysfs entry */
1090		size = scnprintf(buf, REG_STR_SIZE, "%s-%s",
1091				 dev->kobj.name, supply_name);
1092		if (size >= REG_STR_SIZE)
1093			goto attr_err;
1094
1095		regulator->supply_name = kstrdup(buf, GFP_KERNEL);
1096		if (regulator->supply_name == NULL)
1097			goto attr_err;
1098
1099		err = sysfs_create_link(&rdev->dev.kobj, &dev->kobj,
1100					buf);
1101		if (err) {
1102			rdev_warn(rdev, "could not add device link %s err %d\n",
1103				  dev->kobj.name, err);
1104			goto link_name_err;
1105		}
1106	} else {
1107		regulator->supply_name = kstrdup(supply_name, GFP_KERNEL);
1108		if (regulator->supply_name == NULL)
1109			goto attr_err;
1110	}
1111
1112#ifdef CONFIG_DEBUG_FS
1113	regulator->debugfs = debugfs_create_dir(regulator->supply_name,
1114						rdev->debugfs);
1115	if (IS_ERR_OR_NULL(regulator->debugfs)) {
1116		rdev_warn(rdev, "Failed to create debugfs directory\n");
1117		regulator->debugfs = NULL;
1118	} else {
1119		debugfs_create_u32("uA_load", 0444, regulator->debugfs,
1120				   &regulator->uA_load);
1121		debugfs_create_u32("min_uV", 0444, regulator->debugfs,
1122				   &regulator->min_uV);
1123		debugfs_create_u32("max_uV", 0444, regulator->debugfs,
1124				   &regulator->max_uV);
1125	}
1126#endif
 
 
 
 
 
 
 
1127
1128	mutex_unlock(&rdev->mutex);
1129	return regulator;
1130link_name_err:
1131	kfree(regulator->supply_name);
1132attr_err:
1133	device_remove_file(regulator->dev, &regulator->dev_attr);
1134attr_name_err:
1135	kfree(regulator->dev_attr.attr.name);
1136overflow_err:
1137	list_del(&regulator->list);
1138	kfree(regulator);
1139	mutex_unlock(&rdev->mutex);
 
 
 
 
 
 
 
 
 
 
1140	return NULL;
1141}
1142
1143static int _regulator_get_enable_time(struct regulator_dev *rdev)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1144{
1145	if (!rdev->desc->ops->enable_time)
1146		return 0;
1147	return rdev->desc->ops->enable_time(rdev);
 
 
1148}
1149
1150/* Internal regulator request function */
1151static struct regulator *_regulator_get(struct device *dev, const char *id,
1152					int exclusive)
 
 
 
 
 
 
 
 
 
 
 
1153{
1154	struct regulator_dev *rdev;
 
1155	struct regulator_map *map;
1156	struct regulator *regulator = ERR_PTR(-ENODEV);
1157	const char *devname = NULL;
1158	int ret;
1159
1160	if (id == NULL) {
1161		pr_err("get() with no identifier\n");
1162		return regulator;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1163	}
1164
 
1165	if (dev)
1166		devname = dev_name(dev);
1167
1168	mutex_lock(&regulator_list_mutex);
1169
1170	list_for_each_entry(map, &regulator_map_list, list) {
1171		/* If the mapping has a device set up it must match */
1172		if (map->dev_name &&
1173		    (!devname || strcmp(map->dev_name, devname)))
1174			continue;
1175
1176		if (strcmp(map->supply, id) == 0) {
1177			rdev = map->regulator;
1178			goto found;
 
1179		}
1180	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1181
1182	if (board_wants_dummy_regulator) {
1183		rdev = dummy_regulator_rdev;
1184		goto found;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1185	}
1186
1187#ifdef CONFIG_REGULATOR_DUMMY
1188	if (!devname)
1189		devname = "deviceless";
 
 
 
 
 
 
 
1190
1191	/* If the board didn't flag that it was fully constrained then
1192	 * substitute in a dummy regulator so consumers can continue.
 
 
 
1193	 */
1194	if (!has_full_constraints) {
1195		pr_warn("%s supply %s not found, using dummy regulator\n",
1196			devname, id);
1197		rdev = dummy_regulator_rdev;
1198		goto found;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1199	}
1200#endif
1201
1202	mutex_unlock(&regulator_list_mutex);
1203	return regulator;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1204
1205found:
1206	if (rdev->exclusive) {
1207		regulator = ERR_PTR(-EPERM);
1208		goto out;
 
1209	}
1210
1211	if (exclusive && rdev->open_count) {
1212		regulator = ERR_PTR(-EBUSY);
1213		goto out;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1214	}
1215
1216	if (!try_module_get(rdev->owner))
1217		goto out;
 
 
 
1218
 
1219	regulator = create_regulator(rdev, dev, id);
 
1220	if (regulator == NULL) {
1221		regulator = ERR_PTR(-ENOMEM);
1222		module_put(rdev->owner);
 
 
1223	}
1224
1225	rdev->open_count++;
1226	if (exclusive) {
1227		rdev->exclusive = 1;
1228
1229		ret = _regulator_is_enabled(rdev);
1230		if (ret > 0)
1231			rdev->use_count = 1;
1232		else
 
1233			rdev->use_count = 0;
 
 
1234	}
1235
1236out:
1237	mutex_unlock(&regulator_list_mutex);
 
1238
1239	return regulator;
1240}
1241
1242/**
1243 * regulator_get - lookup and obtain a reference to a regulator.
1244 * @dev: device for regulator "consumer"
1245 * @id: Supply name or regulator ID.
1246 *
1247 * Returns a struct regulator corresponding to the regulator producer,
1248 * or IS_ERR() condition containing errno.
1249 *
1250 * Use of supply names configured via regulator_set_device_supply() is
1251 * strongly encouraged.  It is recommended that the supply name used
1252 * should match the name used for the supply and/or the relevant
1253 * device pins in the datasheet.
1254 */
1255struct regulator *regulator_get(struct device *dev, const char *id)
1256{
1257	return _regulator_get(dev, id, 0);
1258}
1259EXPORT_SYMBOL_GPL(regulator_get);
1260
1261/**
1262 * regulator_get_exclusive - obtain exclusive access to a regulator.
1263 * @dev: device for regulator "consumer"
1264 * @id: Supply name or regulator ID.
1265 *
1266 * Returns a struct regulator corresponding to the regulator producer,
1267 * or IS_ERR() condition containing errno.  Other consumers will be
1268 * unable to obtain this reference is held and the use count for the
1269 * regulator will be initialised to reflect the current state of the
1270 * regulator.
1271 *
1272 * This is intended for use by consumers which cannot tolerate shared
1273 * use of the regulator such as those which need to force the
1274 * regulator off for correct operation of the hardware they are
1275 * controlling.
1276 *
1277 * Use of supply names configured via regulator_set_device_supply() is
1278 * strongly encouraged.  It is recommended that the supply name used
1279 * should match the name used for the supply and/or the relevant
1280 * device pins in the datasheet.
1281 */
1282struct regulator *regulator_get_exclusive(struct device *dev, const char *id)
1283{
1284	return _regulator_get(dev, id, 1);
1285}
1286EXPORT_SYMBOL_GPL(regulator_get_exclusive);
1287
1288/**
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1289 * regulator_put - "free" the regulator source
1290 * @regulator: regulator source
1291 *
1292 * Note: drivers must ensure that all regulator_enable calls made on this
1293 * regulator source are balanced by regulator_disable calls prior to calling
1294 * this function.
1295 */
1296void regulator_put(struct regulator *regulator)
1297{
1298	struct regulator_dev *rdev;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1299
1300	if (regulator == NULL || IS_ERR(regulator))
1301		return;
1302
1303	mutex_lock(&regulator_list_mutex);
1304	rdev = regulator->rdev;
1305
1306#ifdef CONFIG_DEBUG_FS
1307	debugfs_remove_recursive(regulator->debugfs);
1308#endif
 
 
 
1309
1310	/* remove any sysfs entries */
1311	if (regulator->dev) {
1312		sysfs_remove_link(&rdev->dev.kobj, regulator->supply_name);
1313		device_remove_file(regulator->dev, &regulator->dev_attr);
1314		kfree(regulator->dev_attr.attr.name);
1315	}
1316	kfree(regulator->supply_name);
1317	list_del(&regulator->list);
1318	kfree(regulator);
1319
1320	rdev->open_count--;
1321	rdev->exclusive = 0;
 
 
 
 
 
 
 
1322
1323	module_put(rdev->owner);
1324	mutex_unlock(&regulator_list_mutex);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1325}
1326EXPORT_SYMBOL_GPL(regulator_put);
1327
1328static int _regulator_can_change_status(struct regulator_dev *rdev)
 
 
 
 
 
 
 
 
1329{
1330	if (!rdev->constraints)
1331		return 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1332
1333	if (rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_STATUS)
1334		return 1;
 
 
 
 
 
 
1335	else
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1336		return 0;
 
 
 
1337}
1338
1339/* locks held by regulator_enable() */
1340static int _regulator_enable(struct regulator_dev *rdev)
1341{
1342	int ret, delay;
1343
1344	/* check voltage and requested load before enabling */
1345	if (rdev->constraints &&
1346	    (rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_DRMS))
1347		drms_uA_update(rdev);
 
 
 
 
1348
1349	if (rdev->use_count == 0) {
1350		/* The regulator may on if it's not switchable or left on */
1351		ret = _regulator_is_enabled(rdev);
1352		if (ret == -EINVAL || ret == 0) {
1353			if (!_regulator_can_change_status(rdev))
1354				return -EPERM;
1355
1356			if (!rdev->desc->ops->enable)
1357				return -EINVAL;
 
 
 
 
1358
1359			/* Query before enabling in case configuration
1360			 * dependent.  */
1361			ret = _regulator_get_enable_time(rdev);
1362			if (ret >= 0) {
1363				delay = ret;
1364			} else {
1365				rdev_warn(rdev, "enable_time() failed: %d\n",
1366					   ret);
1367				delay = 0;
1368			}
1369
1370			trace_regulator_enable(rdev_get_name(rdev));
1371
1372			/* Allow the regulator to ramp; it would be useful
1373			 * to extend this for bulk operations so that the
1374			 * regulators can ramp together.  */
1375			ret = rdev->desc->ops->enable(rdev);
1376			if (ret < 0)
1377				return ret;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1378
1379			trace_regulator_enable_delay(rdev_get_name(rdev));
 
 
 
 
1380
1381			if (delay >= 1000) {
1382				mdelay(delay / 1000);
1383				udelay(delay % 1000);
1384			} else if (delay) {
1385				udelay(delay);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1386			}
1387
1388			trace_regulator_enable_complete(rdev_get_name(rdev));
 
 
1389
 
 
1390		} else if (ret < 0) {
1391			rdev_err(rdev, "is_enabled() failed: %d\n", ret);
1392			return ret;
1393		}
1394		/* Fallthrough on positive return values - already enabled */
1395	}
1396
1397	rdev->use_count++;
 
1398
1399	return 0;
 
 
 
 
 
 
 
 
 
1400}
1401
1402/**
1403 * regulator_enable - enable regulator output
1404 * @regulator: regulator source
1405 *
1406 * Request that the regulator be enabled with the regulator output at
1407 * the predefined voltage or current value.  Calls to regulator_enable()
1408 * must be balanced with calls to regulator_disable().
1409 *
1410 * NOTE: the output value can be set by other drivers, boot loader or may be
1411 * hardwired in the regulator.
1412 */
1413int regulator_enable(struct regulator *regulator)
1414{
1415	struct regulator_dev *rdev = regulator->rdev;
1416	int ret = 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1417
1418	if (rdev->supply) {
1419		ret = regulator_enable(rdev->supply);
1420		if (ret != 0)
1421			return ret;
1422	}
1423
1424	mutex_lock(&rdev->mutex);
1425	ret = _regulator_enable(rdev);
1426	mutex_unlock(&rdev->mutex);
1427
1428	if (ret != 0)
1429		regulator_disable(rdev->supply);
1430
1431	return ret;
1432}
1433EXPORT_SYMBOL_GPL(regulator_enable);
1434
1435/* locks held by regulator_disable() */
1436static int _regulator_disable(struct regulator_dev *rdev)
1437{
 
1438	int ret = 0;
1439
1440	if (WARN(rdev->use_count <= 0,
 
 
1441		 "unbalanced disables for %s\n", rdev_get_name(rdev)))
1442		return -EIO;
1443
1444	/* are we the last user and permitted to disable ? */
1445	if (rdev->use_count == 1 &&
1446	    (rdev->constraints && !rdev->constraints->always_on)) {
1447
1448		/* we are last user */
1449		if (_regulator_can_change_status(rdev) &&
1450		    rdev->desc->ops->disable) {
1451			trace_regulator_disable(rdev_get_name(rdev));
1452
1453			ret = rdev->desc->ops->disable(rdev);
1454			if (ret < 0) {
1455				rdev_err(rdev, "failed to disable\n");
1456				return ret;
 
 
 
 
 
 
 
 
 
 
 
1457			}
1458
1459			trace_regulator_disable_complete(rdev_get_name(rdev));
1460
1461			_notifier_call_chain(rdev, REGULATOR_EVENT_DISABLE,
1462					     NULL);
1463		}
 
1464
1465		rdev->use_count = 0;
1466	} else if (rdev->use_count > 1) {
1467
1468		if (rdev->constraints &&
1469			(rdev->constraints->valid_ops_mask &
1470			REGULATOR_CHANGE_DRMS))
1471			drms_uA_update(rdev);
1472
1473		rdev->use_count--;
1474	}
1475
1476	return ret;
1477}
1478
1479/**
1480 * regulator_disable - disable regulator output
1481 * @regulator: regulator source
1482 *
1483 * Disable the regulator output voltage or current.  Calls to
1484 * regulator_enable() must be balanced with calls to
1485 * regulator_disable().
1486 *
1487 * NOTE: this will only disable the regulator output if no other consumer
1488 * devices have it enabled, the regulator device supports disabling and
1489 * machine constraints permit this operation.
1490 */
1491int regulator_disable(struct regulator *regulator)
1492{
1493	struct regulator_dev *rdev = regulator->rdev;
1494	int ret = 0;
 
1495
1496	mutex_lock(&rdev->mutex);
1497	ret = _regulator_disable(rdev);
1498	mutex_unlock(&rdev->mutex);
1499
1500	if (ret == 0 && rdev->supply)
1501		regulator_disable(rdev->supply);
1502
1503	return ret;
1504}
1505EXPORT_SYMBOL_GPL(regulator_disable);
1506
1507/* locks held by regulator_force_disable() */
1508static int _regulator_force_disable(struct regulator_dev *rdev)
1509{
1510	int ret = 0;
1511
1512	/* force disable */
1513	if (rdev->desc->ops->disable) {
1514		/* ah well, who wants to live forever... */
1515		ret = rdev->desc->ops->disable(rdev);
1516		if (ret < 0) {
1517			rdev_err(rdev, "failed to force disable\n");
1518			return ret;
1519		}
1520		/* notify other consumers that power has been forced off */
 
1521		_notifier_call_chain(rdev, REGULATOR_EVENT_FORCE_DISABLE |
 
 
 
 
 
1522			REGULATOR_EVENT_DISABLE, NULL);
1523	}
1524
1525	return ret;
1526}
1527
1528/**
1529 * regulator_force_disable - force disable regulator output
1530 * @regulator: regulator source
1531 *
1532 * Forcibly disable the regulator output voltage or current.
1533 * NOTE: this *will* disable the regulator output even if other consumer
1534 * devices have it enabled. This should be used for situations when device
1535 * damage will likely occur if the regulator is not disabled (e.g. over temp).
1536 */
1537int regulator_force_disable(struct regulator *regulator)
1538{
1539	struct regulator_dev *rdev = regulator->rdev;
 
1540	int ret;
1541
1542	mutex_lock(&rdev->mutex);
1543	regulator->uA_load = 0;
1544	ret = _regulator_force_disable(regulator->rdev);
1545	mutex_unlock(&rdev->mutex);
1546
1547	if (rdev->supply)
1548		while (rdev->open_count--)
1549			regulator_disable(rdev->supply);
 
 
 
 
 
 
 
 
 
1550
1551	return ret;
1552}
1553EXPORT_SYMBOL_GPL(regulator_force_disable);
1554
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1555static int _regulator_is_enabled(struct regulator_dev *rdev)
1556{
 
 
 
 
1557	/* If we don't know then assume that the regulator is always on */
1558	if (!rdev->desc->ops->is_enabled)
1559		return 1;
1560
1561	return rdev->desc->ops->is_enabled(rdev);
1562}
1563
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1564/**
1565 * regulator_is_enabled - is the regulator output enabled
1566 * @regulator: regulator source
1567 *
1568 * Returns positive if the regulator driver backing the source/client
1569 * has requested that the device be enabled, zero if it hasn't, else a
1570 * negative errno code.
1571 *
1572 * Note that the device backing this regulator handle can have multiple
1573 * users, so it might be enabled even if regulator_enable() was never
1574 * called for this particular source.
1575 */
1576int regulator_is_enabled(struct regulator *regulator)
1577{
1578	int ret;
1579
1580	mutex_lock(&regulator->rdev->mutex);
 
 
 
1581	ret = _regulator_is_enabled(regulator->rdev);
1582	mutex_unlock(&regulator->rdev->mutex);
1583
1584	return ret;
1585}
1586EXPORT_SYMBOL_GPL(regulator_is_enabled);
1587
1588/**
1589 * regulator_count_voltages - count regulator_list_voltage() selectors
1590 * @regulator: regulator source
1591 *
1592 * Returns number of selectors, or negative errno.  Selectors are
1593 * numbered starting at zero, and typically correspond to bitfields
1594 * in hardware registers.
1595 */
1596int regulator_count_voltages(struct regulator *regulator)
1597{
1598	struct regulator_dev	*rdev = regulator->rdev;
1599
1600	return rdev->desc->n_voltages ? : -EINVAL;
 
 
 
 
 
 
1601}
1602EXPORT_SYMBOL_GPL(regulator_count_voltages);
1603
1604/**
1605 * regulator_list_voltage - enumerate supported voltages
1606 * @regulator: regulator source
1607 * @selector: identify voltage to list
1608 * Context: can sleep
1609 *
1610 * Returns a voltage that can be passed to @regulator_set_voltage(),
1611 * zero if this selector code can't be used on this system, or a
1612 * negative errno.
1613 */
1614int regulator_list_voltage(struct regulator *regulator, unsigned selector)
1615{
1616	struct regulator_dev	*rdev = regulator->rdev;
1617	struct regulator_ops	*ops = rdev->desc->ops;
1618	int			ret;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1619
1620	if (!ops->list_voltage || selector >= rdev->desc->n_voltages)
1621		return -EINVAL;
 
 
 
 
1622
1623	mutex_lock(&rdev->mutex);
1624	ret = ops->list_voltage(rdev, selector);
1625	mutex_unlock(&rdev->mutex);
1626
1627	if (ret > 0) {
1628		if (ret < rdev->constraints->min_uV)
1629			ret = 0;
1630		else if (ret > rdev->constraints->max_uV)
1631			ret = 0;
1632	}
 
 
 
 
1633
1634	return ret;
1635}
1636EXPORT_SYMBOL_GPL(regulator_list_voltage);
1637
1638/**
1639 * regulator_is_supported_voltage - check if a voltage range can be supported
1640 *
1641 * @regulator: Regulator to check.
1642 * @min_uV: Minimum required voltage in uV.
1643 * @max_uV: Maximum required voltage in uV.
1644 *
1645 * Returns a boolean or a negative error code.
1646 */
1647int regulator_is_supported_voltage(struct regulator *regulator,
1648				   int min_uV, int max_uV)
1649{
 
1650	int i, voltages, ret;
1651
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1652	ret = regulator_count_voltages(regulator);
1653	if (ret < 0)
1654		return ret;
1655	voltages = ret;
1656
1657	for (i = 0; i < voltages; i++) {
1658		ret = regulator_list_voltage(regulator, i);
1659
1660		if (ret >= min_uV && ret <= max_uV)
1661			return 1;
1662	}
1663
1664	return 0;
1665}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1666
1667static int _regulator_do_set_voltage(struct regulator_dev *rdev,
1668				     int min_uV, int max_uV)
1669{
1670	int ret;
1671	int delay = 0;
 
1672	unsigned int selector;
 
 
 
1673
1674	trace_regulator_set_voltage(rdev_get_name(rdev), min_uV, max_uV);
1675
1676	min_uV += rdev->constraints->uV_offset;
1677	max_uV += rdev->constraints->uV_offset;
1678
1679	if (rdev->desc->ops->set_voltage) {
1680		ret = rdev->desc->ops->set_voltage(rdev, min_uV, max_uV,
1681						   &selector);
1682
1683		if (rdev->desc->ops->list_voltage)
1684			selector = rdev->desc->ops->list_voltage(rdev,
1685								 selector);
1686		else
1687			selector = -1;
1688	} else if (rdev->desc->ops->set_voltage_sel) {
1689		int best_val = INT_MAX;
1690		int i;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1691
1692		selector = 0;
1693
1694		/* Find the smallest voltage that falls within the specified
1695		 * range.
 
 
 
 
 
 
1696		 */
1697		for (i = 0; i < rdev->desc->n_voltages; i++) {
1698			ret = rdev->desc->ops->list_voltage(rdev, i);
1699			if (ret < 0)
1700				continue;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1701
1702			if (ret < best_val && ret >= min_uV && ret <= max_uV) {
1703				best_val = ret;
1704				selector = i;
1705			}
1706		}
 
 
 
 
 
 
 
 
 
 
1707
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1708		/*
1709		 * If we can't obtain the old selector there is not enough
1710		 * info to call set_voltage_time_sel().
1711		 */
1712		if (rdev->desc->ops->set_voltage_time_sel &&
1713		    rdev->desc->ops->get_voltage_sel) {
1714			unsigned int old_selector = 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1715
1716			ret = rdev->desc->ops->get_voltage_sel(rdev);
 
1717			if (ret < 0)
1718				return ret;
1719			old_selector = ret;
1720			delay = rdev->desc->ops->set_voltage_time_sel(rdev,
1721						old_selector, selector);
1722		}
1723
1724		if (best_val != INT_MAX) {
1725			ret = rdev->desc->ops->set_voltage_sel(rdev, selector);
1726			selector = best_val;
1727		} else {
1728			ret = -EINVAL;
1729		}
1730	} else {
1731		ret = -EINVAL;
1732	}
1733
1734	/* Insert any necessary delays */
1735	if (delay >= 1000) {
1736		mdelay(delay / 1000);
1737		udelay(delay % 1000);
1738	} else if (delay) {
1739		udelay(delay);
1740	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1741
1742	if (ret == 0)
1743		_notifier_call_chain(rdev, REGULATOR_EVENT_VOLTAGE_CHANGE,
1744				     NULL);
1745
1746	trace_regulator_set_voltage_complete(rdev_get_name(rdev), selector);
1747
 
1748	return ret;
1749}
1750
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1751/**
1752 * regulator_set_voltage - set regulator output voltage
1753 * @regulator: regulator source
1754 * @min_uV: Minimum required voltage in uV
1755 * @max_uV: Maximum acceptable voltage in uV
1756 *
1757 * Sets a voltage regulator to the desired output voltage. This can be set
1758 * during any regulator state. IOW, regulator can be disabled or enabled.
1759 *
1760 * If the regulator is enabled then the voltage will change to the new value
1761 * immediately otherwise if the regulator is disabled the regulator will
1762 * output at the new voltage when enabled.
1763 *
1764 * NOTE: If the regulator is shared between several devices then the lowest
1765 * request voltage that meets the system constraints will be used.
1766 * Regulator system constraints must be set for this regulator before
1767 * calling this function otherwise this call will fail.
1768 */
1769int regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV)
1770{
1771	struct regulator_dev *rdev = regulator->rdev;
1772	int ret = 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1773
1774	mutex_lock(&rdev->mutex);
 
 
 
 
1775
1776	/* If we're setting the same range as last time the change
1777	 * should be a noop (some cpufreq implementations use the same
1778	 * voltage for multiple frequencies, for example).
1779	 */
1780	if (regulator->min_uV == min_uV && regulator->max_uV == max_uV)
1781		goto out;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1782
1783	/* sanity check */
1784	if (!rdev->desc->ops->set_voltage &&
1785	    !rdev->desc->ops->set_voltage_sel) {
1786		ret = -EINVAL;
1787		goto out;
1788	}
1789
1790	/* constraints check */
1791	ret = regulator_check_voltage(rdev, &min_uV, &max_uV);
1792	if (ret < 0)
1793		goto out;
1794	regulator->min_uV = min_uV;
1795	regulator->max_uV = max_uV;
 
 
 
 
 
 
 
 
1796
1797	ret = regulator_check_consumers(rdev, &min_uV, &max_uV);
1798	if (ret < 0)
1799		goto out;
1800
1801	ret = _regulator_do_set_voltage(rdev, min_uV, max_uV);
1802
1803out:
1804	mutex_unlock(&rdev->mutex);
1805	return ret;
1806}
1807EXPORT_SYMBOL_GPL(regulator_set_voltage);
1808
1809/**
1810 * regulator_set_voltage_time - get raise/fall time
1811 * @regulator: regulator source
1812 * @old_uV: starting voltage in microvolts
1813 * @new_uV: target voltage in microvolts
1814 *
1815 * Provided with the starting and ending voltage, this function attempts to
1816 * calculate the time in microseconds required to rise or fall to this new
1817 * voltage.
1818 */
1819int regulator_set_voltage_time(struct regulator *regulator,
1820			       int old_uV, int new_uV)
1821{
1822	struct regulator_dev	*rdev = regulator->rdev;
1823	struct regulator_ops	*ops = rdev->desc->ops;
1824	int old_sel = -1;
1825	int new_sel = -1;
1826	int voltage;
1827	int i;
1828
 
 
 
 
 
1829	/* Currently requires operations to do this */
1830	if (!ops->list_voltage || !ops->set_voltage_time_sel
1831	    || !rdev->desc->n_voltages)
1832		return -EINVAL;
1833
1834	for (i = 0; i < rdev->desc->n_voltages; i++) {
1835		/* We only look for exact voltage matches here */
 
 
 
 
 
 
1836		voltage = regulator_list_voltage(regulator, i);
1837		if (voltage < 0)
1838			return -EINVAL;
1839		if (voltage == 0)
1840			continue;
1841		if (voltage == old_uV)
1842			old_sel = i;
1843		if (voltage == new_uV)
1844			new_sel = i;
1845	}
1846
1847	if (old_sel < 0 || new_sel < 0)
1848		return -EINVAL;
1849
1850	return ops->set_voltage_time_sel(rdev, old_sel, new_sel);
1851}
1852EXPORT_SYMBOL_GPL(regulator_set_voltage_time);
1853
1854/**
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1855 * regulator_sync_voltage - re-apply last regulator output voltage
1856 * @regulator: regulator source
1857 *
1858 * Re-apply the last configured voltage.  This is intended to be used
1859 * where some external control source the consumer is cooperating with
1860 * has caused the configured voltage to change.
1861 */
1862int regulator_sync_voltage(struct regulator *regulator)
1863{
1864	struct regulator_dev *rdev = regulator->rdev;
 
1865	int ret, min_uV, max_uV;
1866
1867	mutex_lock(&rdev->mutex);
 
 
 
1868
1869	if (!rdev->desc->ops->set_voltage &&
1870	    !rdev->desc->ops->set_voltage_sel) {
1871		ret = -EINVAL;
1872		goto out;
1873	}
1874
1875	/* This is only going to work if we've had a voltage configured. */
1876	if (!regulator->min_uV && !regulator->max_uV) {
1877		ret = -EINVAL;
1878		goto out;
1879	}
1880
1881	min_uV = regulator->min_uV;
1882	max_uV = regulator->max_uV;
1883
1884	/* This should be a paranoia check... */
1885	ret = regulator_check_voltage(rdev, &min_uV, &max_uV);
1886	if (ret < 0)
1887		goto out;
1888
1889	ret = regulator_check_consumers(rdev, &min_uV, &max_uV);
1890	if (ret < 0)
1891		goto out;
1892
1893	ret = _regulator_do_set_voltage(rdev, min_uV, max_uV);
 
 
 
 
1894
1895out:
1896	mutex_unlock(&rdev->mutex);
1897	return ret;
1898}
1899EXPORT_SYMBOL_GPL(regulator_sync_voltage);
1900
1901static int _regulator_get_voltage(struct regulator_dev *rdev)
1902{
1903	int sel, ret;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1904
1905	if (rdev->desc->ops->get_voltage_sel) {
1906		sel = rdev->desc->ops->get_voltage_sel(rdev);
1907		if (sel < 0)
1908			return sel;
1909		ret = rdev->desc->ops->list_voltage(rdev, sel);
1910	} else if (rdev->desc->ops->get_voltage) {
1911		ret = rdev->desc->ops->get_voltage(rdev);
 
 
 
 
 
 
 
 
1912	} else {
1913		return -EINVAL;
1914	}
1915
1916	if (ret < 0)
1917		return ret;
1918	return ret - rdev->constraints->uV_offset;
1919}
 
1920
1921/**
1922 * regulator_get_voltage - get regulator output voltage
1923 * @regulator: regulator source
1924 *
1925 * This returns the current regulator voltage in uV.
1926 *
1927 * NOTE: If the regulator is disabled it will return the voltage value. This
1928 * function should not be used to determine regulator state.
1929 */
1930int regulator_get_voltage(struct regulator *regulator)
1931{
 
1932	int ret;
1933
1934	mutex_lock(&regulator->rdev->mutex);
1935
1936	ret = _regulator_get_voltage(regulator->rdev);
1937
1938	mutex_unlock(&regulator->rdev->mutex);
1939
1940	return ret;
1941}
1942EXPORT_SYMBOL_GPL(regulator_get_voltage);
1943
1944/**
1945 * regulator_set_current_limit - set regulator output current limit
1946 * @regulator: regulator source
1947 * @min_uA: Minimuum supported current in uA
1948 * @max_uA: Maximum supported current in uA
1949 *
1950 * Sets current sink to the desired output current. This can be set during
1951 * any regulator state. IOW, regulator can be disabled or enabled.
1952 *
1953 * If the regulator is enabled then the current will change to the new value
1954 * immediately otherwise if the regulator is disabled the regulator will
1955 * output at the new current when enabled.
1956 *
1957 * NOTE: Regulator system constraints must be set for this regulator before
1958 * calling this function otherwise this call will fail.
1959 */
1960int regulator_set_current_limit(struct regulator *regulator,
1961			       int min_uA, int max_uA)
1962{
1963	struct regulator_dev *rdev = regulator->rdev;
1964	int ret;
1965
1966	mutex_lock(&rdev->mutex);
1967
1968	/* sanity check */
1969	if (!rdev->desc->ops->set_current_limit) {
1970		ret = -EINVAL;
1971		goto out;
1972	}
1973
1974	/* constraints check */
1975	ret = regulator_check_current_limit(rdev, &min_uA, &max_uA);
1976	if (ret < 0)
1977		goto out;
1978
1979	ret = rdev->desc->ops->set_current_limit(rdev, min_uA, max_uA);
1980out:
1981	mutex_unlock(&rdev->mutex);
1982	return ret;
1983}
1984EXPORT_SYMBOL_GPL(regulator_set_current_limit);
1985
 
 
 
 
 
 
 
 
 
1986static int _regulator_get_current_limit(struct regulator_dev *rdev)
1987{
1988	int ret;
1989
1990	mutex_lock(&rdev->mutex);
1991
1992	/* sanity check */
1993	if (!rdev->desc->ops->get_current_limit) {
1994		ret = -EINVAL;
1995		goto out;
1996	}
1997
1998	ret = rdev->desc->ops->get_current_limit(rdev);
1999out:
2000	mutex_unlock(&rdev->mutex);
2001	return ret;
2002}
2003
2004/**
2005 * regulator_get_current_limit - get regulator output current
2006 * @regulator: regulator source
2007 *
2008 * This returns the current supplied by the specified current sink in uA.
2009 *
2010 * NOTE: If the regulator is disabled it will return the current value. This
2011 * function should not be used to determine regulator state.
2012 */
2013int regulator_get_current_limit(struct regulator *regulator)
2014{
2015	return _regulator_get_current_limit(regulator->rdev);
2016}
2017EXPORT_SYMBOL_GPL(regulator_get_current_limit);
2018
2019/**
2020 * regulator_set_mode - set regulator operating mode
2021 * @regulator: regulator source
2022 * @mode: operating mode - one of the REGULATOR_MODE constants
2023 *
2024 * Set regulator operating mode to increase regulator efficiency or improve
2025 * regulation performance.
2026 *
2027 * NOTE: Regulator system constraints must be set for this regulator before
2028 * calling this function otherwise this call will fail.
2029 */
2030int regulator_set_mode(struct regulator *regulator, unsigned int mode)
2031{
2032	struct regulator_dev *rdev = regulator->rdev;
2033	int ret;
2034	int regulator_curr_mode;
2035
2036	mutex_lock(&rdev->mutex);
2037
2038	/* sanity check */
2039	if (!rdev->desc->ops->set_mode) {
2040		ret = -EINVAL;
2041		goto out;
2042	}
2043
2044	/* return if the same mode is requested */
2045	if (rdev->desc->ops->get_mode) {
2046		regulator_curr_mode = rdev->desc->ops->get_mode(rdev);
2047		if (regulator_curr_mode == mode) {
2048			ret = 0;
2049			goto out;
2050		}
2051	}
2052
2053	/* constraints check */
2054	ret = regulator_mode_constrain(rdev, &mode);
2055	if (ret < 0)
2056		goto out;
2057
2058	ret = rdev->desc->ops->set_mode(rdev, mode);
2059out:
2060	mutex_unlock(&rdev->mutex);
2061	return ret;
2062}
2063EXPORT_SYMBOL_GPL(regulator_set_mode);
2064
 
 
 
 
 
 
 
 
 
2065static unsigned int _regulator_get_mode(struct regulator_dev *rdev)
2066{
2067	int ret;
2068
2069	mutex_lock(&rdev->mutex);
2070
2071	/* sanity check */
2072	if (!rdev->desc->ops->get_mode) {
2073		ret = -EINVAL;
2074		goto out;
2075	}
2076
2077	ret = rdev->desc->ops->get_mode(rdev);
2078out:
2079	mutex_unlock(&rdev->mutex);
2080	return ret;
2081}
2082
2083/**
2084 * regulator_get_mode - get regulator operating mode
2085 * @regulator: regulator source
2086 *
2087 * Get the current regulator operating mode.
2088 */
2089unsigned int regulator_get_mode(struct regulator *regulator)
2090{
2091	return _regulator_get_mode(regulator->rdev);
2092}
2093EXPORT_SYMBOL_GPL(regulator_get_mode);
2094
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2095/**
2096 * regulator_set_optimum_mode - set regulator optimum operating mode
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2097 * @regulator: regulator source
2098 * @uA_load: load current
2099 *
2100 * Notifies the regulator core of a new device load. This is then used by
2101 * DRMS (if enabled by constraints) to set the most efficient regulator
2102 * operating mode for the new regulator loading.
2103 *
2104 * Consumer devices notify their supply regulator of the maximum power
2105 * they will require (can be taken from device datasheet in the power
2106 * consumption tables) when they change operational status and hence power
2107 * state. Examples of operational state changes that can affect power
2108 * consumption are :-
2109 *
2110 *    o Device is opened / closed.
2111 *    o Device I/O is about to begin or has just finished.
2112 *    o Device is idling in between work.
2113 *
2114 * This information is also exported via sysfs to userspace.
2115 *
2116 * DRMS will sum the total requested load on the regulator and change
2117 * to the most efficient operating mode if platform constraints allow.
2118 *
2119 * Returns the new regulator mode or error.
 
 
 
 
 
 
 
 
2120 */
2121int regulator_set_optimum_mode(struct regulator *regulator, int uA_load)
2122{
2123	struct regulator_dev *rdev = regulator->rdev;
2124	struct regulator *consumer;
2125	int ret, output_uV, input_uV, total_uA_load = 0;
2126	unsigned int mode;
2127
2128	mutex_lock(&rdev->mutex);
2129
2130	/*
2131	 * first check to see if we can set modes at all, otherwise just
2132	 * tell the consumer everything is OK.
2133	 */
2134	regulator->uA_load = uA_load;
2135	ret = regulator_check_drms(rdev);
2136	if (ret < 0) {
2137		ret = 0;
2138		goto out;
2139	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2140
2141	if (!rdev->desc->ops->get_optimum_mode)
2142		goto out;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2143
2144	/*
2145	 * we can actually do this so any errors are indicators of
2146	 * potential real failure.
2147	 */
2148	ret = -EINVAL;
2149
2150	/* get output voltage */
2151	output_uV = _regulator_get_voltage(rdev);
2152	if (output_uV <= 0) {
2153		rdev_err(rdev, "invalid output voltage found\n");
2154		goto out;
 
2155	}
2156
2157	/* get input voltage */
2158	input_uV = 0;
2159	if (rdev->supply)
2160		input_uV = regulator_get_voltage(rdev->supply);
2161	if (input_uV <= 0)
2162		input_uV = rdev->constraints->input_uV;
2163	if (input_uV <= 0) {
2164		rdev_err(rdev, "invalid input voltage found\n");
2165		goto out;
2166	}
2167
2168	/* calc total requested load for this regulator */
2169	list_for_each_entry(consumer, &rdev->consumer_list, list)
2170		total_uA_load += consumer->uA_load;
2171
2172	mode = rdev->desc->ops->get_optimum_mode(rdev,
2173						 input_uV, output_uV,
2174						 total_uA_load);
2175	ret = regulator_mode_constrain(rdev, &mode);
2176	if (ret < 0) {
2177		rdev_err(rdev, "failed to get optimum mode @ %d uA %d -> %d uV\n",
2178			 total_uA_load, input_uV, output_uV);
2179		goto out;
2180	}
2181
2182	ret = rdev->desc->ops->set_mode(rdev, mode);
2183	if (ret < 0) {
2184		rdev_err(rdev, "failed to set optimum mode %x\n", mode);
2185		goto out;
2186	}
2187	ret = mode;
2188out:
2189	mutex_unlock(&rdev->mutex);
2190	return ret;
2191}
2192EXPORT_SYMBOL_GPL(regulator_set_optimum_mode);
2193
2194/**
2195 * regulator_register_notifier - register regulator event notifier
2196 * @regulator: regulator source
2197 * @nb: notifier block
2198 *
2199 * Register notifier block to receive regulator events.
2200 */
2201int regulator_register_notifier(struct regulator *regulator,
2202			      struct notifier_block *nb)
2203{
2204	return blocking_notifier_chain_register(&regulator->rdev->notifier,
2205						nb);
2206}
2207EXPORT_SYMBOL_GPL(regulator_register_notifier);
2208
2209/**
2210 * regulator_unregister_notifier - unregister regulator event notifier
2211 * @regulator: regulator source
2212 * @nb: notifier block
2213 *
2214 * Unregister regulator event notifier block.
2215 */
2216int regulator_unregister_notifier(struct regulator *regulator,
2217				struct notifier_block *nb)
2218{
2219	return blocking_notifier_chain_unregister(&regulator->rdev->notifier,
2220						  nb);
2221}
2222EXPORT_SYMBOL_GPL(regulator_unregister_notifier);
2223
2224/* notify regulator consumers and downstream regulator consumers.
2225 * Note mutex must be held by caller.
2226 */
2227static void _notifier_call_chain(struct regulator_dev *rdev,
2228				  unsigned long event, void *data)
2229{
2230	/* call rdev chain first */
2231	blocking_notifier_call_chain(&rdev->notifier, event, NULL);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2232}
2233
2234/**
2235 * regulator_bulk_get - get multiple regulator consumers
2236 *
2237 * @dev:           Device to supply
2238 * @num_consumers: Number of consumers to register
2239 * @consumers:     Configuration of consumers; clients are stored here.
2240 *
2241 * @return 0 on success, an errno on failure.
2242 *
2243 * This helper function allows drivers to get several regulator
2244 * consumers in one operation.  If any of the regulators cannot be
2245 * acquired then any regulators that were allocated will be freed
2246 * before returning to the caller.
2247 */
2248int regulator_bulk_get(struct device *dev, int num_consumers,
2249		       struct regulator_bulk_data *consumers)
2250{
2251	int i;
2252	int ret;
2253
2254	for (i = 0; i < num_consumers; i++)
2255		consumers[i].consumer = NULL;
2256
2257	for (i = 0; i < num_consumers; i++) {
2258		consumers[i].consumer = regulator_get(dev,
2259						      consumers[i].supply);
2260		if (IS_ERR(consumers[i].consumer)) {
2261			ret = PTR_ERR(consumers[i].consumer);
2262			dev_err(dev, "Failed to get supply '%s': %d\n",
2263				consumers[i].supply, ret);
2264			consumers[i].consumer = NULL;
2265			goto err;
2266		}
 
 
 
 
 
 
 
 
 
2267	}
2268
2269	return 0;
2270
2271err:
2272	for (i = 0; i < num_consumers && consumers[i].consumer; i++)
2273		regulator_put(consumers[i].consumer);
2274
2275	return ret;
2276}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2277EXPORT_SYMBOL_GPL(regulator_bulk_get);
2278
2279static void regulator_bulk_enable_async(void *data, async_cookie_t cookie)
2280{
2281	struct regulator_bulk_data *bulk = data;
2282
2283	bulk->ret = regulator_enable(bulk->consumer);
2284}
2285
2286/**
2287 * regulator_bulk_enable - enable multiple regulator consumers
2288 *
2289 * @num_consumers: Number of consumers
2290 * @consumers:     Consumer data; clients are stored here.
2291 * @return         0 on success, an errno on failure
2292 *
2293 * This convenience API allows consumers to enable multiple regulator
2294 * clients in a single API call.  If any consumers cannot be enabled
2295 * then any others that were enabled will be disabled again prior to
2296 * return.
2297 */
2298int regulator_bulk_enable(int num_consumers,
2299			  struct regulator_bulk_data *consumers)
2300{
2301	LIST_HEAD(async_domain);
2302	int i;
2303	int ret = 0;
2304
2305	for (i = 0; i < num_consumers; i++)
2306		async_schedule_domain(regulator_bulk_enable_async,
2307				      &consumers[i], &async_domain);
 
2308
2309	async_synchronize_full_domain(&async_domain);
2310
2311	/* If any consumer failed we need to unwind any that succeeded */
2312	for (i = 0; i < num_consumers; i++) {
2313		if (consumers[i].ret != 0) {
2314			ret = consumers[i].ret;
2315			goto err;
2316		}
2317	}
2318
2319	return 0;
2320
2321err:
2322	for (i = 0; i < num_consumers; i++)
2323		if (consumers[i].ret == 0)
 
 
 
2324			regulator_disable(consumers[i].consumer);
2325		else
2326			pr_err("Failed to enable %s: %d\n",
2327			       consumers[i].supply, consumers[i].ret);
2328
2329	return ret;
2330}
2331EXPORT_SYMBOL_GPL(regulator_bulk_enable);
2332
2333/**
2334 * regulator_bulk_disable - disable multiple regulator consumers
2335 *
2336 * @num_consumers: Number of consumers
2337 * @consumers:     Consumer data; clients are stored here.
2338 * @return         0 on success, an errno on failure
2339 *
2340 * This convenience API allows consumers to disable multiple regulator
2341 * clients in a single API call.  If any consumers cannot be enabled
2342 * then any others that were disabled will be disabled again prior to
2343 * return.
2344 */
2345int regulator_bulk_disable(int num_consumers,
2346			   struct regulator_bulk_data *consumers)
2347{
2348	int i;
2349	int ret;
2350
2351	for (i = 0; i < num_consumers; i++) {
2352		ret = regulator_disable(consumers[i].consumer);
2353		if (ret != 0)
2354			goto err;
2355	}
2356
2357	return 0;
2358
2359err:
2360	pr_err("Failed to disable %s: %d\n", consumers[i].supply, ret);
2361	for (--i; i >= 0; --i)
2362		regulator_enable(consumers[i].consumer);
 
 
 
 
2363
2364	return ret;
2365}
2366EXPORT_SYMBOL_GPL(regulator_bulk_disable);
2367
2368/**
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2369 * regulator_bulk_free - free multiple regulator consumers
2370 *
2371 * @num_consumers: Number of consumers
2372 * @consumers:     Consumer data; clients are stored here.
2373 *
2374 * This convenience API allows consumers to free multiple regulator
2375 * clients in a single API call.
2376 */
2377void regulator_bulk_free(int num_consumers,
2378			 struct regulator_bulk_data *consumers)
2379{
2380	int i;
2381
2382	for (i = 0; i < num_consumers; i++) {
2383		regulator_put(consumers[i].consumer);
2384		consumers[i].consumer = NULL;
2385	}
2386}
2387EXPORT_SYMBOL_GPL(regulator_bulk_free);
2388
2389/**
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2390 * regulator_notifier_call_chain - call regulator event notifier
2391 * @rdev: regulator source
2392 * @event: notifier block
2393 * @data: callback-specific data.
2394 *
2395 * Called by regulator drivers to notify clients a regulator event has
2396 * occurred. We also notify regulator clients downstream.
2397 * Note lock must be held by caller.
2398 */
2399int regulator_notifier_call_chain(struct regulator_dev *rdev,
2400				  unsigned long event, void *data)
2401{
 
 
2402	_notifier_call_chain(rdev, event, data);
2403	return NOTIFY_DONE;
2404
2405}
2406EXPORT_SYMBOL_GPL(regulator_notifier_call_chain);
2407
2408/**
2409 * regulator_mode_to_status - convert a regulator mode into a status
2410 *
2411 * @mode: Mode to convert
2412 *
2413 * Convert a regulator mode into a status.
2414 */
2415int regulator_mode_to_status(unsigned int mode)
2416{
2417	switch (mode) {
2418	case REGULATOR_MODE_FAST:
2419		return REGULATOR_STATUS_FAST;
2420	case REGULATOR_MODE_NORMAL:
2421		return REGULATOR_STATUS_NORMAL;
2422	case REGULATOR_MODE_IDLE:
2423		return REGULATOR_STATUS_IDLE;
2424	case REGULATOR_STATUS_STANDBY:
2425		return REGULATOR_STATUS_STANDBY;
2426	default:
2427		return 0;
2428	}
2429}
2430EXPORT_SYMBOL_GPL(regulator_mode_to_status);
2431
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2432/*
2433 * To avoid cluttering sysfs (and memory) with useless state, only
2434 * create attributes that can be meaningfully displayed.
2435 */
2436static int add_regulator_attributes(struct regulator_dev *rdev)
 
2437{
2438	struct device		*dev = &rdev->dev;
2439	struct regulator_ops	*ops = rdev->desc->ops;
2440	int			status = 0;
 
 
 
 
 
 
 
2441
2442	/* some attributes need specific methods to be displayed */
2443	if (ops->get_voltage || ops->get_voltage_sel) {
2444		status = device_create_file(dev, &dev_attr_microvolts);
2445		if (status < 0)
2446			return status;
2447	}
2448	if (ops->get_current_limit) {
2449		status = device_create_file(dev, &dev_attr_microamps);
2450		if (status < 0)
2451			return status;
2452	}
2453	if (ops->get_mode) {
2454		status = device_create_file(dev, &dev_attr_opmode);
2455		if (status < 0)
2456			return status;
2457	}
2458	if (ops->is_enabled) {
2459		status = device_create_file(dev, &dev_attr_state);
2460		if (status < 0)
2461			return status;
2462	}
2463	if (ops->get_status) {
2464		status = device_create_file(dev, &dev_attr_status);
2465		if (status < 0)
2466			return status;
2467	}
2468
2469	/* some attributes are type-specific */
2470	if (rdev->desc->type == REGULATOR_CURRENT) {
2471		status = device_create_file(dev, &dev_attr_requested_microamps);
2472		if (status < 0)
2473			return status;
2474	}
2475
2476	/* all the other attributes exist to support constraints;
2477	 * don't show them if there are no constraints, or if the
2478	 * relevant supporting methods are missing.
2479	 */
2480	if (!rdev->constraints)
2481		return status;
2482
2483	/* constraints need specific supporting methods */
2484	if (ops->set_voltage || ops->set_voltage_sel) {
2485		status = device_create_file(dev, &dev_attr_min_microvolts);
2486		if (status < 0)
2487			return status;
2488		status = device_create_file(dev, &dev_attr_max_microvolts);
2489		if (status < 0)
2490			return status;
2491	}
2492	if (ops->set_current_limit) {
2493		status = device_create_file(dev, &dev_attr_min_microamps);
2494		if (status < 0)
2495			return status;
2496		status = device_create_file(dev, &dev_attr_max_microamps);
2497		if (status < 0)
2498			return status;
2499	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2500
2501	/* suspend mode constraints need multiple supporting methods */
2502	if (!(ops->set_suspend_enable && ops->set_suspend_disable))
2503		return status;
 
2504
2505	status = device_create_file(dev, &dev_attr_suspend_standby_state);
2506	if (status < 0)
2507		return status;
2508	status = device_create_file(dev, &dev_attr_suspend_mem_state);
2509	if (status < 0)
2510		return status;
2511	status = device_create_file(dev, &dev_attr_suspend_disk_state);
2512	if (status < 0)
2513		return status;
2514
2515	if (ops->set_suspend_voltage) {
2516		status = device_create_file(dev,
2517				&dev_attr_suspend_standby_microvolts);
2518		if (status < 0)
2519			return status;
2520		status = device_create_file(dev,
2521				&dev_attr_suspend_mem_microvolts);
2522		if (status < 0)
2523			return status;
2524		status = device_create_file(dev,
2525				&dev_attr_suspend_disk_microvolts);
2526		if (status < 0)
2527			return status;
2528	}
2529
2530	if (ops->set_suspend_mode) {
2531		status = device_create_file(dev,
2532				&dev_attr_suspend_standby_mode);
2533		if (status < 0)
2534			return status;
2535		status = device_create_file(dev,
2536				&dev_attr_suspend_mem_mode);
2537		if (status < 0)
2538			return status;
2539		status = device_create_file(dev,
2540				&dev_attr_suspend_disk_mode);
2541		if (status < 0)
2542			return status;
2543	}
2544
2545	return status;
2546}
2547
2548static void rdev_init_debugfs(struct regulator_dev *rdev)
2549{
2550#ifdef CONFIG_DEBUG_FS
2551	rdev->debugfs = debugfs_create_dir(rdev_get_name(rdev), debugfs_root);
2552	if (IS_ERR(rdev->debugfs) || !rdev->debugfs) {
2553		rdev_warn(rdev, "Failed to create debugfs directory\n");
2554		rdev->debugfs = NULL;
2555		return;
 
 
 
2556	}
2557
 
 
 
 
2558	debugfs_create_u32("use_count", 0444, rdev->debugfs,
2559			   &rdev->use_count);
2560	debugfs_create_u32("open_count", 0444, rdev->debugfs,
2561			   &rdev->open_count);
2562#endif
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2563}
2564
 
 
 
 
2565/**
2566 * regulator_register - register regulator
 
2567 * @regulator_desc: regulator to register
2568 * @dev: struct device for the regulator
2569 * @init_data: platform provided init data, passed through by driver
2570 * @driver_data: private regulator data
2571 *
2572 * Called by regulator drivers to register a regulator.
2573 * Returns 0 on success.
 
2574 */
2575struct regulator_dev *regulator_register(struct regulator_desc *regulator_desc,
2576	struct device *dev, const struct regulator_init_data *init_data,
2577	void *driver_data)
2578{
2579	static atomic_t regulator_no = ATOMIC_INIT(0);
 
 
 
2580	struct regulator_dev *rdev;
 
 
2581	int ret, i;
 
2582
2583	if (regulator_desc == NULL)
2584		return ERR_PTR(-EINVAL);
 
 
 
 
 
 
 
 
2585
2586	if (regulator_desc->name == NULL || regulator_desc->ops == NULL)
2587		return ERR_PTR(-EINVAL);
 
 
2588
2589	if (regulator_desc->type != REGULATOR_VOLTAGE &&
2590	    regulator_desc->type != REGULATOR_CURRENT)
2591		return ERR_PTR(-EINVAL);
2592
2593	if (!init_data)
2594		return ERR_PTR(-EINVAL);
2595
2596	/* Only one of each should be implemented */
2597	WARN_ON(regulator_desc->ops->get_voltage &&
2598		regulator_desc->ops->get_voltage_sel);
2599	WARN_ON(regulator_desc->ops->set_voltage &&
2600		regulator_desc->ops->set_voltage_sel);
2601
2602	/* If we're using selectors we must implement list_voltage. */
2603	if (regulator_desc->ops->get_voltage_sel &&
2604	    !regulator_desc->ops->list_voltage) {
2605		return ERR_PTR(-EINVAL);
 
2606	}
2607	if (regulator_desc->ops->set_voltage_sel &&
2608	    !regulator_desc->ops->list_voltage) {
2609		return ERR_PTR(-EINVAL);
 
2610	}
2611
2612	rdev = kzalloc(sizeof(struct regulator_dev), GFP_KERNEL);
2613	if (rdev == NULL)
2614		return ERR_PTR(-ENOMEM);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2615
2616	mutex_lock(&regulator_list_mutex);
 
 
 
 
 
 
 
 
 
 
 
 
 
2617
2618	mutex_init(&rdev->mutex);
2619	rdev->reg_data = driver_data;
2620	rdev->owner = regulator_desc->owner;
2621	rdev->desc = regulator_desc;
 
 
 
 
 
 
2622	INIT_LIST_HEAD(&rdev->consumer_list);
2623	INIT_LIST_HEAD(&rdev->list);
2624	BLOCKING_INIT_NOTIFIER_HEAD(&rdev->notifier);
 
2625
2626	/* preform any regulator specific init */
2627	if (init_data->regulator_init) {
2628		ret = init_data->regulator_init(rdev->reg_data);
2629		if (ret < 0)
2630			goto clean;
2631	}
2632
2633	/* register with sysfs */
2634	rdev->dev.class = &regulator_class;
2635	rdev->dev.parent = dev;
2636	dev_set_name(&rdev->dev, "regulator.%d",
2637		     atomic_inc_return(&regulator_no) - 1);
2638	ret = device_register(&rdev->dev);
2639	if (ret != 0) {
2640		put_device(&rdev->dev);
2641		goto clean;
 
 
 
 
 
 
 
2642	}
2643
2644	dev_set_drvdata(&rdev->dev, rdev);
 
 
 
 
 
 
2645
2646	/* set regulator constraints */
2647	ret = set_machine_constraints(rdev, &init_data->constraints);
2648	if (ret < 0)
2649		goto scrub;
2650
2651	/* add attributes supported by this regulator */
2652	ret = add_regulator_attributes(rdev);
2653	if (ret < 0)
2654		goto scrub;
 
 
2655
2656	if (init_data->supply_regulator) {
2657		struct regulator_dev *r;
2658		int found = 0;
2659
2660		list_for_each_entry(r, &regulator_list, list) {
2661			if (strcmp(rdev_get_name(r),
2662				   init_data->supply_regulator) == 0) {
2663				found = 1;
2664				break;
2665			}
2666		}
 
 
 
 
2667
2668		if (!found) {
2669			dev_err(dev, "Failed to find supply %s\n",
2670				init_data->supply_regulator);
2671			ret = -ENODEV;
2672			goto scrub;
2673		}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2674
2675		ret = set_supply(rdev, r);
2676		if (ret < 0)
2677			goto scrub;
2678	}
2679
2680	/* add consumers devices */
2681	for (i = 0; i < init_data->num_consumer_supplies; i++) {
2682		ret = set_consumer_device_supply(rdev,
2683			init_data->consumer_supplies[i].dev,
2684			init_data->consumer_supplies[i].dev_name,
2685			init_data->consumer_supplies[i].supply);
2686		if (ret < 0) {
2687			dev_err(dev, "Failed to set supply %s\n",
2688				init_data->consumer_supplies[i].supply);
2689			goto unset_supplies;
 
 
 
 
2690		}
2691	}
2692
2693	list_add(&rdev->list, &regulator_list);
 
 
 
 
 
 
 
2694
2695	rdev_init_debugfs(rdev);
2696out:
 
 
 
2697	mutex_unlock(&regulator_list_mutex);
 
 
 
 
 
2698	return rdev;
2699
2700unset_supplies:
 
2701	unset_regulator_supplies(rdev);
2702
2703scrub:
2704	kfree(rdev->constraints);
2705	device_unregister(&rdev->dev);
2706	/* device core frees rdev */
2707	rdev = ERR_PTR(ret);
2708	goto out;
2709
2710clean:
2711	kfree(rdev);
2712	rdev = ERR_PTR(ret);
2713	goto out;
 
 
 
 
 
2714}
2715EXPORT_SYMBOL_GPL(regulator_register);
2716
2717/**
2718 * regulator_unregister - unregister regulator
2719 * @rdev: regulator to unregister
2720 *
2721 * Called by regulator drivers to unregister a regulator.
2722 */
2723void regulator_unregister(struct regulator_dev *rdev)
2724{
2725	if (rdev == NULL)
2726		return;
2727
 
 
 
 
 
 
 
 
2728	mutex_lock(&regulator_list_mutex);
2729#ifdef CONFIG_DEBUG_FS
2730	debugfs_remove_recursive(rdev->debugfs);
2731#endif
2732	WARN_ON(rdev->open_count);
 
2733	unset_regulator_supplies(rdev);
2734	list_del(&rdev->list);
2735	if (rdev->supply)
2736		regulator_put(rdev->supply);
2737	device_unregister(&rdev->dev);
2738	kfree(rdev->constraints);
2739	mutex_unlock(&regulator_list_mutex);
2740}
2741EXPORT_SYMBOL_GPL(regulator_unregister);
2742
 
2743/**
2744 * regulator_suspend_prepare - prepare regulators for system wide suspend
2745 * @state: system suspend state
2746 *
2747 * Configure each regulator with it's suspend operating parameters for state.
2748 * This will usually be called by machine suspend code prior to supending.
2749 */
2750int regulator_suspend_prepare(suspend_state_t state)
2751{
2752	struct regulator_dev *rdev;
2753	int ret = 0;
 
 
2754
2755	/* ON is handled by regulator active state */
2756	if (state == PM_SUSPEND_ON)
2757		return -EINVAL;
2758
2759	mutex_lock(&regulator_list_mutex);
2760	list_for_each_entry(rdev, &regulator_list, list) {
2761
2762		mutex_lock(&rdev->mutex);
2763		ret = suspend_prepare(rdev, state);
2764		mutex_unlock(&rdev->mutex);
2765
2766		if (ret < 0) {
2767			rdev_err(rdev, "failed to prepare\n");
2768			goto out;
2769		}
2770	}
2771out:
2772	mutex_unlock(&regulator_list_mutex);
2773	return ret;
2774}
2775EXPORT_SYMBOL_GPL(regulator_suspend_prepare);
2776
2777/**
2778 * regulator_suspend_finish - resume regulators from system wide suspend
2779 *
2780 * Turn on regulators that might be turned off by regulator_suspend_prepare
2781 * and that should be turned on according to the regulators properties.
2782 */
2783int regulator_suspend_finish(void)
2784{
2785	struct regulator_dev *rdev;
2786	int ret = 0, error;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2787
2788	mutex_lock(&regulator_list_mutex);
2789	list_for_each_entry(rdev, &regulator_list, list) {
2790		struct regulator_ops *ops = rdev->desc->ops;
2791
2792		mutex_lock(&rdev->mutex);
2793		if ((rdev->use_count > 0  || rdev->constraints->always_on) &&
2794				ops->enable) {
2795			error = ops->enable(rdev);
2796			if (error)
2797				ret = error;
2798		} else {
2799			if (!has_full_constraints)
2800				goto unlock;
2801			if (!ops->disable)
2802				goto unlock;
2803			if (ops->is_enabled && !ops->is_enabled(rdev))
2804				goto unlock;
2805
2806			error = ops->disable(rdev);
2807			if (error)
2808				ret = error;
2809		}
2810unlock:
2811		mutex_unlock(&rdev->mutex);
2812	}
2813	mutex_unlock(&regulator_list_mutex);
2814	return ret;
2815}
2816EXPORT_SYMBOL_GPL(regulator_suspend_finish);
 
 
 
2817
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2818/**
2819 * regulator_has_full_constraints - the system has fully specified constraints
2820 *
2821 * Calling this function will cause the regulator API to disable all
2822 * regulators which have a zero use count and don't have an always_on
2823 * constraint in a late_initcall.
2824 *
2825 * The intention is that this will become the default behaviour in a
2826 * future kernel release so users are encouraged to use this facility
2827 * now.
2828 */
2829void regulator_has_full_constraints(void)
2830{
2831	has_full_constraints = 1;
2832}
2833EXPORT_SYMBOL_GPL(regulator_has_full_constraints);
2834
2835/**
2836 * regulator_use_dummy_regulator - Provide a dummy regulator when none is found
2837 *
2838 * Calling this function will cause the regulator API to provide a
2839 * dummy regulator to consumers if no physical regulator is found,
2840 * allowing most consumers to proceed as though a regulator were
2841 * configured.  This allows systems such as those with software
2842 * controllable regulators for the CPU core only to be brought up more
2843 * readily.
2844 */
2845void regulator_use_dummy_regulator(void)
2846{
2847	board_wants_dummy_regulator = true;
2848}
2849EXPORT_SYMBOL_GPL(regulator_use_dummy_regulator);
2850
2851/**
2852 * rdev_get_drvdata - get rdev regulator driver data
2853 * @rdev: regulator
2854 *
2855 * Get rdev regulator driver private data. This call can be used in the
2856 * regulator driver context.
2857 */
2858void *rdev_get_drvdata(struct regulator_dev *rdev)
2859{
2860	return rdev->reg_data;
2861}
2862EXPORT_SYMBOL_GPL(rdev_get_drvdata);
2863
2864/**
2865 * regulator_get_drvdata - get regulator driver data
2866 * @regulator: regulator
2867 *
2868 * Get regulator driver private data. This call can be used in the consumer
2869 * driver context when non API regulator specific functions need to be called.
2870 */
2871void *regulator_get_drvdata(struct regulator *regulator)
2872{
2873	return regulator->rdev->reg_data;
2874}
2875EXPORT_SYMBOL_GPL(regulator_get_drvdata);
2876
2877/**
2878 * regulator_set_drvdata - set regulator driver data
2879 * @regulator: regulator
2880 * @data: data
2881 */
2882void regulator_set_drvdata(struct regulator *regulator, void *data)
2883{
2884	regulator->rdev->reg_data = data;
2885}
2886EXPORT_SYMBOL_GPL(regulator_set_drvdata);
2887
2888/**
2889 * regulator_get_id - get regulator ID
2890 * @rdev: regulator
2891 */
2892int rdev_get_id(struct regulator_dev *rdev)
2893{
2894	return rdev->desc->id;
2895}
2896EXPORT_SYMBOL_GPL(rdev_get_id);
2897
2898struct device *rdev_get_dev(struct regulator_dev *rdev)
2899{
2900	return &rdev->dev;
2901}
2902EXPORT_SYMBOL_GPL(rdev_get_dev);
2903
 
 
 
 
 
 
2904void *regulator_get_init_drvdata(struct regulator_init_data *reg_init_data)
2905{
2906	return reg_init_data->driver_data;
2907}
2908EXPORT_SYMBOL_GPL(regulator_get_init_drvdata);
2909
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2910static int __init regulator_init(void)
2911{
2912	int ret;
2913
2914	ret = class_register(&regulator_class);
2915
 
 
 
 
2916#ifdef CONFIG_DEBUG_FS
2917	debugfs_root = debugfs_create_dir("regulator", NULL);
2918	if (IS_ERR(debugfs_root) || !debugfs_root) {
2919		pr_warn("regulator: Failed to create debugfs directory\n");
2920		debugfs_root = NULL;
2921	}
2922#endif
 
2923
2924	regulator_dummy_init();
2925
2926	return ret;
2927}
2928
2929/* init early to allow our consumers to complete system booting */
2930core_initcall(regulator_init);
2931
2932static int __init regulator_init_complete(void)
2933{
2934	struct regulator_dev *rdev;
2935	struct regulator_ops *ops;
2936	struct regulation_constraints *c;
2937	int enabled, ret;
 
 
2938
2939	mutex_lock(&regulator_list_mutex);
 
2940
2941	/* If we have a full configuration then disable any regulators
2942	 * which are not in use or always_on.  This will become the
2943	 * default behaviour in the future.
2944	 */
2945	list_for_each_entry(rdev, &regulator_list, list) {
2946		ops = rdev->desc->ops;
2947		c = rdev->constraints;
2948
2949		if (!ops->disable || (c && c->always_on))
2950			continue;
2951
2952		mutex_lock(&rdev->mutex);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2953
2954		if (rdev->use_count)
2955			goto unlock;
2956
2957		/* If we can't read the status assume it's on. */
2958		if (ops->is_enabled)
2959			enabled = ops->is_enabled(rdev);
2960		else
2961			enabled = 1;
2962
2963		if (!enabled)
2964			goto unlock;
 
 
 
 
 
2965
2966		if (has_full_constraints) {
2967			/* We log since this may kill the system if it
2968			 * goes wrong. */
2969			rdev_info(rdev, "disabling\n");
2970			ret = ops->disable(rdev);
2971			if (ret != 0) {
2972				rdev_err(rdev, "couldn't disable: %d\n", ret);
2973			}
2974		} else {
2975			/* The intention is that in future we will
2976			 * assume that full constraints are provided
2977			 * so warn even if we aren't going to do
2978			 * anything here.
2979			 */
2980			rdev_warn(rdev, "incomplete constraints, leaving on\n");
2981		}
2982
2983unlock:
2984		mutex_unlock(&rdev->mutex);
 
 
 
 
 
2985	}
2986
2987	mutex_unlock(&regulator_list_mutex);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2988
2989	return 0;
2990}
2991late_initcall(regulator_init_complete);