blob: b899947d839d87b03608d1f9bf4b4208cf57aa01 [file] [log] [blame]
Liam Girdwood414c70c2008-04-30 15:59:04 +01001/*
2 * core.c -- Voltage/Current Regulator framework.
3 *
4 * Copyright 2007, 2008 Wolfson Microelectronics PLC.
Liam Girdwooda5766f12008-10-10 13:22:20 +01005 * Copyright 2008 SlimLogic Ltd.
Liam Girdwood414c70c2008-04-30 15:59:04 +01006 *
Liam Girdwooda5766f12008-10-10 13:22:20 +01007 * Author: Liam Girdwood <lrg@slimlogic.co.uk>
Liam Girdwood414c70c2008-04-30 15:59:04 +01008 *
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License as published by the
11 * Free Software Foundation; either version 2 of the License, or (at your
12 * option) any later version.
13 *
14 */
15
16#include <linux/kernel.h>
17#include <linux/init.h>
Mark Brown1130e5b2010-12-21 23:49:31 +000018#include <linux/debugfs.h>
Liam Girdwood414c70c2008-04-30 15:59:04 +010019#include <linux/device.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090020#include <linux/slab.h>
Mark Brownf21e0e82011-05-24 08:12:40 +080021#include <linux/async.h>
Liam Girdwood414c70c2008-04-30 15:59:04 +010022#include <linux/err.h>
23#include <linux/mutex.h>
24#include <linux/suspend.h>
Mark Brown31aae2b2009-12-21 12:21:52 +000025#include <linux/delay.h>
Mark Brown65f73502012-06-27 14:14:38 +010026#include <linux/gpio.h>
Russell King778b28b2014-06-29 17:55:54 +010027#include <linux/gpio/consumer.h>
Rajendra Nayak69511a42011-11-18 16:47:20 +053028#include <linux/of.h>
Mark Brown65b19ce2012-04-15 11:16:05 +010029#include <linux/regmap.h>
Rajendra Nayak69511a42011-11-18 16:47:20 +053030#include <linux/regulator/of_regulator.h>
Liam Girdwood414c70c2008-04-30 15:59:04 +010031#include <linux/regulator/consumer.h>
32#include <linux/regulator/driver.h>
33#include <linux/regulator/machine.h>
Paul Gortmaker65602c32011-07-17 16:28:23 -040034#include <linux/module.h>
Liam Girdwood414c70c2008-04-30 15:59:04 +010035
Mark Brown02fa3ec2010-11-10 14:38:30 +000036#define CREATE_TRACE_POINTS
37#include <trace/events/regulator.h>
38
Mark Brown34abbd62010-02-12 10:18:08 +000039#include "dummy.h"
Mark Brown0cdfcc02013-09-11 13:15:40 +010040#include "internal.h"
Mark Brown34abbd62010-02-12 10:18:08 +000041
Mark Brown7d51a0d2011-06-09 16:06:37 +010042#define rdev_crit(rdev, fmt, ...) \
43 pr_crit("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
Joe Perches5da84fd2010-11-30 05:53:48 -080044#define rdev_err(rdev, fmt, ...) \
45 pr_err("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
46#define rdev_warn(rdev, fmt, ...) \
47 pr_warn("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
48#define rdev_info(rdev, fmt, ...) \
49 pr_info("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
50#define rdev_dbg(rdev, fmt, ...) \
51 pr_debug("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
52
Liam Girdwood414c70c2008-04-30 15:59:04 +010053static DEFINE_MUTEX(regulator_list_mutex);
54static LIST_HEAD(regulator_list);
55static LIST_HEAD(regulator_map_list);
Kim, Milof19b00d2013-02-18 06:50:39 +000056static LIST_HEAD(regulator_ena_gpio_list);
Charles Keepaxa06ccd92013-10-15 20:14:20 +010057static LIST_HEAD(regulator_supply_alias_list);
Mark Brown21cf8912010-12-21 23:30:07 +000058static bool has_full_constraints;
Liam Girdwood414c70c2008-04-30 15:59:04 +010059
Mark Brown1130e5b2010-12-21 23:49:31 +000060static struct dentry *debugfs_root;
Mark Brown1130e5b2010-12-21 23:49:31 +000061
Mark Brown8dc53902008-12-31 12:52:40 +000062/*
Liam Girdwood414c70c2008-04-30 15:59:04 +010063 * struct regulator_map
64 *
65 * Used to provide symbolic supply names to devices.
66 */
67struct regulator_map {
68 struct list_head list;
Mark Brown40f92442009-06-17 17:56:39 +010069 const char *dev_name; /* The dev_name() for the consumer */
Liam Girdwood414c70c2008-04-30 15:59:04 +010070 const char *supply;
Liam Girdwooda5766f12008-10-10 13:22:20 +010071 struct regulator_dev *regulator;
Liam Girdwood414c70c2008-04-30 15:59:04 +010072};
73
Liam Girdwood414c70c2008-04-30 15:59:04 +010074/*
Kim, Milof19b00d2013-02-18 06:50:39 +000075 * struct regulator_enable_gpio
76 *
77 * Management for shared enable GPIO pin
78 */
79struct regulator_enable_gpio {
80 struct list_head list;
Russell King778b28b2014-06-29 17:55:54 +010081 struct gpio_desc *gpiod;
Kim, Milof19b00d2013-02-18 06:50:39 +000082 u32 enable_count; /* a number of enabled shared GPIO */
83 u32 request_count; /* a number of requested shared GPIO */
84 unsigned int ena_gpio_invert:1;
85};
86
Charles Keepaxa06ccd92013-10-15 20:14:20 +010087/*
88 * struct regulator_supply_alias
89 *
90 * Used to map lookups for a supply onto an alternative device.
91 */
92struct regulator_supply_alias {
93 struct list_head list;
94 struct device *src_dev;
95 const char *src_supply;
96 struct device *alias_dev;
97 const char *alias_supply;
98};
99
Liam Girdwood414c70c2008-04-30 15:59:04 +0100100static int _regulator_is_enabled(struct regulator_dev *rdev);
Mark Brown3801b862011-06-09 16:22:22 +0100101static int _regulator_disable(struct regulator_dev *rdev);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100102static int _regulator_get_voltage(struct regulator_dev *rdev);
103static int _regulator_get_current_limit(struct regulator_dev *rdev);
104static unsigned int _regulator_get_mode(struct regulator_dev *rdev);
Heiko Stübner71795692014-08-28 12:36:04 -0700105static int _notifier_call_chain(struct regulator_dev *rdev,
Liam Girdwood414c70c2008-04-30 15:59:04 +0100106 unsigned long event, void *data);
Mark Brown75790252010-12-12 14:25:50 +0000107static int _regulator_do_set_voltage(struct regulator_dev *rdev,
108 int min_uV, int max_uV);
Mark Brown3801b862011-06-09 16:22:22 +0100109static struct regulator *create_regulator(struct regulator_dev *rdev,
110 struct device *dev,
111 const char *supply_name);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100112
Mark Brown1083c392009-10-22 16:31:32 +0100113static const char *rdev_get_name(struct regulator_dev *rdev)
114{
115 if (rdev->constraints && rdev->constraints->name)
116 return rdev->constraints->name;
117 else if (rdev->desc->name)
118 return rdev->desc->name;
119 else
120 return "";
121}
122
Mark Brown87b28412013-11-27 16:13:10 +0000123static bool have_full_constraints(void)
124{
Mark Brown75bc9642013-11-27 16:22:53 +0000125 return has_full_constraints || of_have_populated_dt();
Mark Brown87b28412013-11-27 16:13:10 +0000126}
127
Rajendra Nayak69511a42011-11-18 16:47:20 +0530128/**
129 * of_get_regulator - get a regulator device node based on supply name
130 * @dev: Device pointer for the consumer (of regulator) device
131 * @supply: regulator supply name
132 *
133 * Extract the regulator device node corresponding to the supply name.
Maxime Ripard167d41d2013-03-23 11:00:41 +0100134 * returns the device node corresponding to the regulator if found, else
Rajendra Nayak69511a42011-11-18 16:47:20 +0530135 * returns NULL.
136 */
137static struct device_node *of_get_regulator(struct device *dev, const char *supply)
138{
139 struct device_node *regnode = NULL;
140 char prop_name[32]; /* 32 is max size of property name */
141
142 dev_dbg(dev, "Looking up %s-supply from device tree\n", supply);
143
144 snprintf(prop_name, 32, "%s-supply", supply);
145 regnode = of_parse_phandle(dev->of_node, prop_name, 0);
146
147 if (!regnode) {
Rajendra Nayak16fbcc32012-03-16 15:50:21 +0530148 dev_dbg(dev, "Looking up %s property in node %s failed",
Rajendra Nayak69511a42011-11-18 16:47:20 +0530149 prop_name, dev->of_node->full_name);
150 return NULL;
151 }
152 return regnode;
153}
154
Mark Brown6492bc12012-04-19 13:19:07 +0100155static int _regulator_can_change_status(struct regulator_dev *rdev)
156{
157 if (!rdev->constraints)
158 return 0;
159
160 if (rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_STATUS)
161 return 1;
162 else
163 return 0;
164}
165
Liam Girdwood414c70c2008-04-30 15:59:04 +0100166/* Platform voltage constraint check */
167static int regulator_check_voltage(struct regulator_dev *rdev,
168 int *min_uV, int *max_uV)
169{
170 BUG_ON(*min_uV > *max_uV);
171
172 if (!rdev->constraints) {
Joe Perches5da84fd2010-11-30 05:53:48 -0800173 rdev_err(rdev, "no constraints\n");
Liam Girdwood414c70c2008-04-30 15:59:04 +0100174 return -ENODEV;
175 }
176 if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) {
Joe Perches5da84fd2010-11-30 05:53:48 -0800177 rdev_err(rdev, "operation not allowed\n");
Liam Girdwood414c70c2008-04-30 15:59:04 +0100178 return -EPERM;
179 }
180
181 if (*max_uV > rdev->constraints->max_uV)
182 *max_uV = rdev->constraints->max_uV;
183 if (*min_uV < rdev->constraints->min_uV)
184 *min_uV = rdev->constraints->min_uV;
185
Mark Brown89f425e2011-07-12 11:20:37 +0900186 if (*min_uV > *max_uV) {
187 rdev_err(rdev, "unsupportable voltage range: %d-%duV\n",
Mark Brown54abd332011-07-21 15:07:37 +0100188 *min_uV, *max_uV);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100189 return -EINVAL;
Mark Brown89f425e2011-07-12 11:20:37 +0900190 }
Liam Girdwood414c70c2008-04-30 15:59:04 +0100191
192 return 0;
193}
194
Thomas Petazzoni05fda3b1a2010-12-03 11:31:07 +0100195/* Make sure we select a voltage that suits the needs of all
196 * regulator consumers
197 */
198static int regulator_check_consumers(struct regulator_dev *rdev,
199 int *min_uV, int *max_uV)
200{
201 struct regulator *regulator;
202
203 list_for_each_entry(regulator, &rdev->consumer_list, list) {
Mark Brown4aa922c2011-05-14 13:42:34 -0700204 /*
205 * Assume consumers that didn't say anything are OK
206 * with anything in the constraint range.
207 */
208 if (!regulator->min_uV && !regulator->max_uV)
209 continue;
210
Thomas Petazzoni05fda3b1a2010-12-03 11:31:07 +0100211 if (*max_uV > regulator->max_uV)
212 *max_uV = regulator->max_uV;
213 if (*min_uV < regulator->min_uV)
214 *min_uV = regulator->min_uV;
215 }
216
Mark Browndd8004a2012-11-28 17:09:27 +0000217 if (*min_uV > *max_uV) {
Russ Dill9c7b4e82013-02-14 04:46:33 -0800218 rdev_err(rdev, "Restricting voltage, %u-%uuV\n",
219 *min_uV, *max_uV);
Thomas Petazzoni05fda3b1a2010-12-03 11:31:07 +0100220 return -EINVAL;
Mark Browndd8004a2012-11-28 17:09:27 +0000221 }
Thomas Petazzoni05fda3b1a2010-12-03 11:31:07 +0100222
223 return 0;
224}
225
Liam Girdwood414c70c2008-04-30 15:59:04 +0100226/* current constraint check */
227static int regulator_check_current_limit(struct regulator_dev *rdev,
228 int *min_uA, int *max_uA)
229{
230 BUG_ON(*min_uA > *max_uA);
231
232 if (!rdev->constraints) {
Joe Perches5da84fd2010-11-30 05:53:48 -0800233 rdev_err(rdev, "no constraints\n");
Liam Girdwood414c70c2008-04-30 15:59:04 +0100234 return -ENODEV;
235 }
236 if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_CURRENT)) {
Joe Perches5da84fd2010-11-30 05:53:48 -0800237 rdev_err(rdev, "operation not allowed\n");
Liam Girdwood414c70c2008-04-30 15:59:04 +0100238 return -EPERM;
239 }
240
241 if (*max_uA > rdev->constraints->max_uA)
242 *max_uA = rdev->constraints->max_uA;
243 if (*min_uA < rdev->constraints->min_uA)
244 *min_uA = rdev->constraints->min_uA;
245
Mark Brown89f425e2011-07-12 11:20:37 +0900246 if (*min_uA > *max_uA) {
247 rdev_err(rdev, "unsupportable current range: %d-%duA\n",
Mark Brown54abd332011-07-21 15:07:37 +0100248 *min_uA, *max_uA);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100249 return -EINVAL;
Mark Brown89f425e2011-07-12 11:20:37 +0900250 }
Liam Girdwood414c70c2008-04-30 15:59:04 +0100251
252 return 0;
253}
254
255/* operating mode constraint check */
Mark Brown2c608232011-03-30 06:29:12 +0900256static int regulator_mode_constrain(struct regulator_dev *rdev, int *mode)
Liam Girdwood414c70c2008-04-30 15:59:04 +0100257{
Mark Brown2c608232011-03-30 06:29:12 +0900258 switch (*mode) {
David Brownelle5735202008-11-16 11:46:56 -0800259 case REGULATOR_MODE_FAST:
260 case REGULATOR_MODE_NORMAL:
261 case REGULATOR_MODE_IDLE:
262 case REGULATOR_MODE_STANDBY:
263 break;
264 default:
Mark Brown89f425e2011-07-12 11:20:37 +0900265 rdev_err(rdev, "invalid mode %x specified\n", *mode);
David Brownelle5735202008-11-16 11:46:56 -0800266 return -EINVAL;
267 }
268
Liam Girdwood414c70c2008-04-30 15:59:04 +0100269 if (!rdev->constraints) {
Joe Perches5da84fd2010-11-30 05:53:48 -0800270 rdev_err(rdev, "no constraints\n");
Liam Girdwood414c70c2008-04-30 15:59:04 +0100271 return -ENODEV;
272 }
273 if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_MODE)) {
Joe Perches5da84fd2010-11-30 05:53:48 -0800274 rdev_err(rdev, "operation not allowed\n");
Liam Girdwood414c70c2008-04-30 15:59:04 +0100275 return -EPERM;
276 }
Mark Brown2c608232011-03-30 06:29:12 +0900277
278 /* The modes are bitmasks, the most power hungry modes having
279 * the lowest values. If the requested mode isn't supported
280 * try higher modes. */
281 while (*mode) {
282 if (rdev->constraints->valid_modes_mask & *mode)
283 return 0;
284 *mode /= 2;
Liam Girdwood414c70c2008-04-30 15:59:04 +0100285 }
Mark Brown2c608232011-03-30 06:29:12 +0900286
287 return -EINVAL;
Liam Girdwood414c70c2008-04-30 15:59:04 +0100288}
289
290/* dynamic regulator mode switching constraint check */
291static int regulator_check_drms(struct regulator_dev *rdev)
292{
293 if (!rdev->constraints) {
Joe Perches5da84fd2010-11-30 05:53:48 -0800294 rdev_err(rdev, "no constraints\n");
Liam Girdwood414c70c2008-04-30 15:59:04 +0100295 return -ENODEV;
296 }
297 if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_DRMS)) {
Joe Perches5da84fd2010-11-30 05:53:48 -0800298 rdev_err(rdev, "operation not allowed\n");
Liam Girdwood414c70c2008-04-30 15:59:04 +0100299 return -EPERM;
300 }
301 return 0;
302}
303
Liam Girdwood414c70c2008-04-30 15:59:04 +0100304static ssize_t regulator_uV_show(struct device *dev,
305 struct device_attribute *attr, char *buf)
306{
Liam Girdwooda5766f12008-10-10 13:22:20 +0100307 struct regulator_dev *rdev = dev_get_drvdata(dev);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100308 ssize_t ret;
309
310 mutex_lock(&rdev->mutex);
311 ret = sprintf(buf, "%d\n", _regulator_get_voltage(rdev));
312 mutex_unlock(&rdev->mutex);
313
314 return ret;
315}
David Brownell7ad68e22008-11-11 17:39:02 -0800316static DEVICE_ATTR(microvolts, 0444, regulator_uV_show, NULL);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100317
318static ssize_t regulator_uA_show(struct device *dev,
319 struct device_attribute *attr, char *buf)
320{
Liam Girdwooda5766f12008-10-10 13:22:20 +0100321 struct regulator_dev *rdev = dev_get_drvdata(dev);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100322
323 return sprintf(buf, "%d\n", _regulator_get_current_limit(rdev));
324}
David Brownell7ad68e22008-11-11 17:39:02 -0800325static DEVICE_ATTR(microamps, 0444, regulator_uA_show, NULL);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100326
Greg Kroah-Hartman587cea22013-07-24 15:05:21 -0700327static ssize_t name_show(struct device *dev, struct device_attribute *attr,
328 char *buf)
Mark Brownbc558a62008-10-10 15:33:20 +0100329{
330 struct regulator_dev *rdev = dev_get_drvdata(dev);
Mark Brownbc558a62008-10-10 15:33:20 +0100331
Mark Brown1083c392009-10-22 16:31:32 +0100332 return sprintf(buf, "%s\n", rdev_get_name(rdev));
Mark Brownbc558a62008-10-10 15:33:20 +0100333}
Greg Kroah-Hartman587cea22013-07-24 15:05:21 -0700334static DEVICE_ATTR_RO(name);
Mark Brownbc558a62008-10-10 15:33:20 +0100335
David Brownell4fca9542008-11-11 17:38:53 -0800336static ssize_t regulator_print_opmode(char *buf, int mode)
Liam Girdwood414c70c2008-04-30 15:59:04 +0100337{
Liam Girdwood414c70c2008-04-30 15:59:04 +0100338 switch (mode) {
339 case REGULATOR_MODE_FAST:
340 return sprintf(buf, "fast\n");
341 case REGULATOR_MODE_NORMAL:
342 return sprintf(buf, "normal\n");
343 case REGULATOR_MODE_IDLE:
344 return sprintf(buf, "idle\n");
345 case REGULATOR_MODE_STANDBY:
346 return sprintf(buf, "standby\n");
347 }
348 return sprintf(buf, "unknown\n");
349}
350
David Brownell4fca9542008-11-11 17:38:53 -0800351static ssize_t regulator_opmode_show(struct device *dev,
352 struct device_attribute *attr, char *buf)
Liam Girdwood414c70c2008-04-30 15:59:04 +0100353{
Liam Girdwooda5766f12008-10-10 13:22:20 +0100354 struct regulator_dev *rdev = dev_get_drvdata(dev);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100355
David Brownell4fca9542008-11-11 17:38:53 -0800356 return regulator_print_opmode(buf, _regulator_get_mode(rdev));
357}
David Brownell7ad68e22008-11-11 17:39:02 -0800358static DEVICE_ATTR(opmode, 0444, regulator_opmode_show, NULL);
David Brownell4fca9542008-11-11 17:38:53 -0800359
360static ssize_t regulator_print_state(char *buf, int state)
361{
Liam Girdwood414c70c2008-04-30 15:59:04 +0100362 if (state > 0)
363 return sprintf(buf, "enabled\n");
364 else if (state == 0)
365 return sprintf(buf, "disabled\n");
366 else
367 return sprintf(buf, "unknown\n");
368}
369
David Brownell4fca9542008-11-11 17:38:53 -0800370static ssize_t regulator_state_show(struct device *dev,
371 struct device_attribute *attr, char *buf)
372{
373 struct regulator_dev *rdev = dev_get_drvdata(dev);
Mark Brown93325462009-08-03 18:49:56 +0100374 ssize_t ret;
David Brownell4fca9542008-11-11 17:38:53 -0800375
Mark Brown93325462009-08-03 18:49:56 +0100376 mutex_lock(&rdev->mutex);
377 ret = regulator_print_state(buf, _regulator_is_enabled(rdev));
378 mutex_unlock(&rdev->mutex);
379
380 return ret;
David Brownell4fca9542008-11-11 17:38:53 -0800381}
David Brownell7ad68e22008-11-11 17:39:02 -0800382static DEVICE_ATTR(state, 0444, regulator_state_show, NULL);
David Brownell4fca9542008-11-11 17:38:53 -0800383
David Brownell853116a2009-01-14 23:03:17 -0800384static ssize_t regulator_status_show(struct device *dev,
385 struct device_attribute *attr, char *buf)
386{
387 struct regulator_dev *rdev = dev_get_drvdata(dev);
388 int status;
389 char *label;
390
391 status = rdev->desc->ops->get_status(rdev);
392 if (status < 0)
393 return status;
394
395 switch (status) {
396 case REGULATOR_STATUS_OFF:
397 label = "off";
398 break;
399 case REGULATOR_STATUS_ON:
400 label = "on";
401 break;
402 case REGULATOR_STATUS_ERROR:
403 label = "error";
404 break;
405 case REGULATOR_STATUS_FAST:
406 label = "fast";
407 break;
408 case REGULATOR_STATUS_NORMAL:
409 label = "normal";
410 break;
411 case REGULATOR_STATUS_IDLE:
412 label = "idle";
413 break;
414 case REGULATOR_STATUS_STANDBY:
415 label = "standby";
416 break;
Mark Brownf59c8f92012-08-31 10:36:37 -0700417 case REGULATOR_STATUS_BYPASS:
418 label = "bypass";
419 break;
Krystian Garbaciak1beaf762012-07-12 13:53:35 +0100420 case REGULATOR_STATUS_UNDEFINED:
421 label = "undefined";
422 break;
David Brownell853116a2009-01-14 23:03:17 -0800423 default:
424 return -ERANGE;
425 }
426
427 return sprintf(buf, "%s\n", label);
428}
429static DEVICE_ATTR(status, 0444, regulator_status_show, NULL);
430
Liam Girdwood414c70c2008-04-30 15:59:04 +0100431static ssize_t regulator_min_uA_show(struct device *dev,
432 struct device_attribute *attr, char *buf)
433{
Liam Girdwooda5766f12008-10-10 13:22:20 +0100434 struct regulator_dev *rdev = dev_get_drvdata(dev);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100435
436 if (!rdev->constraints)
437 return sprintf(buf, "constraint not defined\n");
438
439 return sprintf(buf, "%d\n", rdev->constraints->min_uA);
440}
David Brownell7ad68e22008-11-11 17:39:02 -0800441static DEVICE_ATTR(min_microamps, 0444, regulator_min_uA_show, NULL);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100442
443static ssize_t regulator_max_uA_show(struct device *dev,
444 struct device_attribute *attr, char *buf)
445{
Liam Girdwooda5766f12008-10-10 13:22:20 +0100446 struct regulator_dev *rdev = dev_get_drvdata(dev);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100447
448 if (!rdev->constraints)
449 return sprintf(buf, "constraint not defined\n");
450
451 return sprintf(buf, "%d\n", rdev->constraints->max_uA);
452}
David Brownell7ad68e22008-11-11 17:39:02 -0800453static DEVICE_ATTR(max_microamps, 0444, regulator_max_uA_show, NULL);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100454
455static ssize_t regulator_min_uV_show(struct device *dev,
456 struct device_attribute *attr, char *buf)
457{
Liam Girdwooda5766f12008-10-10 13:22:20 +0100458 struct regulator_dev *rdev = dev_get_drvdata(dev);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100459
460 if (!rdev->constraints)
461 return sprintf(buf, "constraint not defined\n");
462
463 return sprintf(buf, "%d\n", rdev->constraints->min_uV);
464}
David Brownell7ad68e22008-11-11 17:39:02 -0800465static DEVICE_ATTR(min_microvolts, 0444, regulator_min_uV_show, NULL);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100466
467static ssize_t regulator_max_uV_show(struct device *dev,
468 struct device_attribute *attr, char *buf)
469{
Liam Girdwooda5766f12008-10-10 13:22:20 +0100470 struct regulator_dev *rdev = dev_get_drvdata(dev);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100471
472 if (!rdev->constraints)
473 return sprintf(buf, "constraint not defined\n");
474
475 return sprintf(buf, "%d\n", rdev->constraints->max_uV);
476}
David Brownell7ad68e22008-11-11 17:39:02 -0800477static DEVICE_ATTR(max_microvolts, 0444, regulator_max_uV_show, NULL);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100478
479static ssize_t regulator_total_uA_show(struct device *dev,
480 struct device_attribute *attr, char *buf)
481{
Liam Girdwooda5766f12008-10-10 13:22:20 +0100482 struct regulator_dev *rdev = dev_get_drvdata(dev);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100483 struct regulator *regulator;
484 int uA = 0;
485
486 mutex_lock(&rdev->mutex);
487 list_for_each_entry(regulator, &rdev->consumer_list, list)
Stefan Roesefa2984d2009-11-27 15:56:34 +0100488 uA += regulator->uA_load;
Liam Girdwood414c70c2008-04-30 15:59:04 +0100489 mutex_unlock(&rdev->mutex);
490 return sprintf(buf, "%d\n", uA);
491}
David Brownell7ad68e22008-11-11 17:39:02 -0800492static DEVICE_ATTR(requested_microamps, 0444, regulator_total_uA_show, NULL);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100493
Greg Kroah-Hartman587cea22013-07-24 15:05:21 -0700494static ssize_t num_users_show(struct device *dev, struct device_attribute *attr,
495 char *buf)
Liam Girdwood414c70c2008-04-30 15:59:04 +0100496{
Liam Girdwooda5766f12008-10-10 13:22:20 +0100497 struct regulator_dev *rdev = dev_get_drvdata(dev);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100498 return sprintf(buf, "%d\n", rdev->use_count);
499}
Greg Kroah-Hartman587cea22013-07-24 15:05:21 -0700500static DEVICE_ATTR_RO(num_users);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100501
Greg Kroah-Hartman587cea22013-07-24 15:05:21 -0700502static ssize_t type_show(struct device *dev, struct device_attribute *attr,
503 char *buf)
Liam Girdwood414c70c2008-04-30 15:59:04 +0100504{
Liam Girdwooda5766f12008-10-10 13:22:20 +0100505 struct regulator_dev *rdev = dev_get_drvdata(dev);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100506
507 switch (rdev->desc->type) {
508 case REGULATOR_VOLTAGE:
509 return sprintf(buf, "voltage\n");
510 case REGULATOR_CURRENT:
511 return sprintf(buf, "current\n");
512 }
513 return sprintf(buf, "unknown\n");
514}
Greg Kroah-Hartman587cea22013-07-24 15:05:21 -0700515static DEVICE_ATTR_RO(type);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100516
517static ssize_t regulator_suspend_mem_uV_show(struct device *dev,
518 struct device_attribute *attr, char *buf)
519{
Liam Girdwooda5766f12008-10-10 13:22:20 +0100520 struct regulator_dev *rdev = dev_get_drvdata(dev);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100521
Liam Girdwood414c70c2008-04-30 15:59:04 +0100522 return sprintf(buf, "%d\n", rdev->constraints->state_mem.uV);
523}
David Brownell7ad68e22008-11-11 17:39:02 -0800524static DEVICE_ATTR(suspend_mem_microvolts, 0444,
525 regulator_suspend_mem_uV_show, NULL);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100526
527static ssize_t regulator_suspend_disk_uV_show(struct device *dev,
528 struct device_attribute *attr, char *buf)
529{
Liam Girdwooda5766f12008-10-10 13:22:20 +0100530 struct regulator_dev *rdev = dev_get_drvdata(dev);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100531
Liam Girdwood414c70c2008-04-30 15:59:04 +0100532 return sprintf(buf, "%d\n", rdev->constraints->state_disk.uV);
533}
David Brownell7ad68e22008-11-11 17:39:02 -0800534static DEVICE_ATTR(suspend_disk_microvolts, 0444,
535 regulator_suspend_disk_uV_show, NULL);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100536
537static ssize_t regulator_suspend_standby_uV_show(struct device *dev,
538 struct device_attribute *attr, char *buf)
539{
Liam Girdwooda5766f12008-10-10 13:22:20 +0100540 struct regulator_dev *rdev = dev_get_drvdata(dev);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100541
Liam Girdwood414c70c2008-04-30 15:59:04 +0100542 return sprintf(buf, "%d\n", rdev->constraints->state_standby.uV);
543}
David Brownell7ad68e22008-11-11 17:39:02 -0800544static DEVICE_ATTR(suspend_standby_microvolts, 0444,
545 regulator_suspend_standby_uV_show, NULL);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100546
Liam Girdwood414c70c2008-04-30 15:59:04 +0100547static ssize_t regulator_suspend_mem_mode_show(struct device *dev,
548 struct device_attribute *attr, char *buf)
549{
Liam Girdwooda5766f12008-10-10 13:22:20 +0100550 struct regulator_dev *rdev = dev_get_drvdata(dev);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100551
David Brownell4fca9542008-11-11 17:38:53 -0800552 return regulator_print_opmode(buf,
553 rdev->constraints->state_mem.mode);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100554}
David Brownell7ad68e22008-11-11 17:39:02 -0800555static DEVICE_ATTR(suspend_mem_mode, 0444,
556 regulator_suspend_mem_mode_show, NULL);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100557
558static ssize_t regulator_suspend_disk_mode_show(struct device *dev,
559 struct device_attribute *attr, char *buf)
560{
Liam Girdwooda5766f12008-10-10 13:22:20 +0100561 struct regulator_dev *rdev = dev_get_drvdata(dev);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100562
David Brownell4fca9542008-11-11 17:38:53 -0800563 return regulator_print_opmode(buf,
564 rdev->constraints->state_disk.mode);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100565}
David Brownell7ad68e22008-11-11 17:39:02 -0800566static DEVICE_ATTR(suspend_disk_mode, 0444,
567 regulator_suspend_disk_mode_show, NULL);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100568
569static ssize_t regulator_suspend_standby_mode_show(struct device *dev,
570 struct device_attribute *attr, char *buf)
571{
Liam Girdwooda5766f12008-10-10 13:22:20 +0100572 struct regulator_dev *rdev = dev_get_drvdata(dev);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100573
David Brownell4fca9542008-11-11 17:38:53 -0800574 return regulator_print_opmode(buf,
575 rdev->constraints->state_standby.mode);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100576}
David Brownell7ad68e22008-11-11 17:39:02 -0800577static DEVICE_ATTR(suspend_standby_mode, 0444,
578 regulator_suspend_standby_mode_show, NULL);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100579
580static ssize_t regulator_suspend_mem_state_show(struct device *dev,
581 struct device_attribute *attr, char *buf)
582{
Liam Girdwooda5766f12008-10-10 13:22:20 +0100583 struct regulator_dev *rdev = dev_get_drvdata(dev);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100584
David Brownell4fca9542008-11-11 17:38:53 -0800585 return regulator_print_state(buf,
586 rdev->constraints->state_mem.enabled);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100587}
David Brownell7ad68e22008-11-11 17:39:02 -0800588static DEVICE_ATTR(suspend_mem_state, 0444,
589 regulator_suspend_mem_state_show, NULL);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100590
591static ssize_t regulator_suspend_disk_state_show(struct device *dev,
592 struct device_attribute *attr, char *buf)
593{
Liam Girdwooda5766f12008-10-10 13:22:20 +0100594 struct regulator_dev *rdev = dev_get_drvdata(dev);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100595
David Brownell4fca9542008-11-11 17:38:53 -0800596 return regulator_print_state(buf,
597 rdev->constraints->state_disk.enabled);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100598}
David Brownell7ad68e22008-11-11 17:39:02 -0800599static DEVICE_ATTR(suspend_disk_state, 0444,
600 regulator_suspend_disk_state_show, NULL);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100601
602static ssize_t regulator_suspend_standby_state_show(struct device *dev,
603 struct device_attribute *attr, char *buf)
604{
Liam Girdwooda5766f12008-10-10 13:22:20 +0100605 struct regulator_dev *rdev = dev_get_drvdata(dev);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100606
David Brownell4fca9542008-11-11 17:38:53 -0800607 return regulator_print_state(buf,
608 rdev->constraints->state_standby.enabled);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100609}
David Brownell7ad68e22008-11-11 17:39:02 -0800610static DEVICE_ATTR(suspend_standby_state, 0444,
611 regulator_suspend_standby_state_show, NULL);
Mark Brownbc558a62008-10-10 15:33:20 +0100612
Mark Brownf59c8f92012-08-31 10:36:37 -0700613static ssize_t regulator_bypass_show(struct device *dev,
614 struct device_attribute *attr, char *buf)
615{
616 struct regulator_dev *rdev = dev_get_drvdata(dev);
617 const char *report;
618 bool bypass;
619 int ret;
620
621 ret = rdev->desc->ops->get_bypass(rdev, &bypass);
622
623 if (ret != 0)
624 report = "unknown";
625 else if (bypass)
626 report = "enabled";
627 else
628 report = "disabled";
629
630 return sprintf(buf, "%s\n", report);
631}
632static DEVICE_ATTR(bypass, 0444,
633 regulator_bypass_show, NULL);
David Brownell7ad68e22008-11-11 17:39:02 -0800634
Liam Girdwood414c70c2008-04-30 15:59:04 +0100635/* Calculate the new optimum regulator operating mode based on the new total
636 * consumer load. All locks held by caller */
Bjorn Andersson8460ef32015-01-27 18:46:31 -0800637static int drms_uA_update(struct regulator_dev *rdev)
Liam Girdwood414c70c2008-04-30 15:59:04 +0100638{
639 struct regulator *sibling;
640 int current_uA = 0, output_uV, input_uV, err;
641 unsigned int mode;
642
Bjorn Andersson8460ef32015-01-27 18:46:31 -0800643 /*
644 * first check to see if we can set modes at all, otherwise just
645 * tell the consumer everything is OK.
646 */
Liam Girdwood414c70c2008-04-30 15:59:04 +0100647 err = regulator_check_drms(rdev);
Bjorn Andersson8460ef32015-01-27 18:46:31 -0800648 if (err < 0)
649 return 0;
650
651 if (!rdev->desc->ops->get_optimum_mode)
652 return 0;
653
654 if (!rdev->desc->ops->set_mode)
655 return -EINVAL;
Liam Girdwood414c70c2008-04-30 15:59:04 +0100656
657 /* get output voltage */
Mark Brown1bf5a1f2010-12-10 17:28:06 +0000658 output_uV = _regulator_get_voltage(rdev);
Bjorn Andersson8460ef32015-01-27 18:46:31 -0800659 if (output_uV <= 0) {
660 rdev_err(rdev, "invalid output voltage found\n");
661 return -EINVAL;
662 }
Liam Girdwood414c70c2008-04-30 15:59:04 +0100663
664 /* get input voltage */
Mark Brown1bf5a1f2010-12-10 17:28:06 +0000665 input_uV = 0;
666 if (rdev->supply)
Axel Lin3f24f5a2012-04-13 21:35:05 +0800667 input_uV = regulator_get_voltage(rdev->supply);
Mark Brown1bf5a1f2010-12-10 17:28:06 +0000668 if (input_uV <= 0)
Liam Girdwood414c70c2008-04-30 15:59:04 +0100669 input_uV = rdev->constraints->input_uV;
Bjorn Andersson8460ef32015-01-27 18:46:31 -0800670 if (input_uV <= 0) {
671 rdev_err(rdev, "invalid input voltage found\n");
672 return -EINVAL;
673 }
Liam Girdwood414c70c2008-04-30 15:59:04 +0100674
675 /* calc total requested load */
676 list_for_each_entry(sibling, &rdev->consumer_list, list)
Stefan Roesefa2984d2009-11-27 15:56:34 +0100677 current_uA += sibling->uA_load;
Liam Girdwood414c70c2008-04-30 15:59:04 +0100678
679 /* now get the optimum mode for our new total regulator load */
680 mode = rdev->desc->ops->get_optimum_mode(rdev, input_uV,
681 output_uV, current_uA);
682
683 /* check the new mode is allowed */
Mark Brown2c608232011-03-30 06:29:12 +0900684 err = regulator_mode_constrain(rdev, &mode);
Bjorn Andersson8460ef32015-01-27 18:46:31 -0800685 if (err < 0) {
686 rdev_err(rdev, "failed to get optimum mode @ %d uA %d -> %d uV\n",
687 current_uA, input_uV, output_uV);
688 return err;
689 }
690
691 err = rdev->desc->ops->set_mode(rdev, mode);
692 if (err < 0)
693 rdev_err(rdev, "failed to set optimum mode %x\n", mode);
694
695 return err;
Liam Girdwood414c70c2008-04-30 15:59:04 +0100696}
697
698static int suspend_set_state(struct regulator_dev *rdev,
699 struct regulator_state *rstate)
700{
701 int ret = 0;
Mark Brown638f85c2009-10-22 16:31:33 +0100702
703 /* If we have no suspend mode configration don't set anything;
Axel Lin8ac0e952012-04-14 09:14:34 +0800704 * only warn if the driver implements set_suspend_voltage or
705 * set_suspend_mode callback.
Mark Brown638f85c2009-10-22 16:31:33 +0100706 */
707 if (!rstate->enabled && !rstate->disabled) {
Axel Lin8ac0e952012-04-14 09:14:34 +0800708 if (rdev->desc->ops->set_suspend_voltage ||
709 rdev->desc->ops->set_suspend_mode)
Joe Perches5da84fd2010-11-30 05:53:48 -0800710 rdev_warn(rdev, "No configuration\n");
Mark Brown638f85c2009-10-22 16:31:33 +0100711 return 0;
712 }
713
714 if (rstate->enabled && rstate->disabled) {
Joe Perches5da84fd2010-11-30 05:53:48 -0800715 rdev_err(rdev, "invalid configuration\n");
Mark Brown638f85c2009-10-22 16:31:33 +0100716 return -EINVAL;
717 }
718
Axel Lin8ac0e952012-04-14 09:14:34 +0800719 if (rstate->enabled && rdev->desc->ops->set_suspend_enable)
Liam Girdwood414c70c2008-04-30 15:59:04 +0100720 ret = rdev->desc->ops->set_suspend_enable(rdev);
Axel Lin8ac0e952012-04-14 09:14:34 +0800721 else if (rstate->disabled && rdev->desc->ops->set_suspend_disable)
Liam Girdwood414c70c2008-04-30 15:59:04 +0100722 ret = rdev->desc->ops->set_suspend_disable(rdev);
Axel Lin8ac0e952012-04-14 09:14:34 +0800723 else /* OK if set_suspend_enable or set_suspend_disable is NULL */
724 ret = 0;
725
Liam Girdwood414c70c2008-04-30 15:59:04 +0100726 if (ret < 0) {
Joe Perches5da84fd2010-11-30 05:53:48 -0800727 rdev_err(rdev, "failed to enabled/disable\n");
Liam Girdwood414c70c2008-04-30 15:59:04 +0100728 return ret;
729 }
730
731 if (rdev->desc->ops->set_suspend_voltage && rstate->uV > 0) {
732 ret = rdev->desc->ops->set_suspend_voltage(rdev, rstate->uV);
733 if (ret < 0) {
Joe Perches5da84fd2010-11-30 05:53:48 -0800734 rdev_err(rdev, "failed to set voltage\n");
Liam Girdwood414c70c2008-04-30 15:59:04 +0100735 return ret;
736 }
737 }
738
739 if (rdev->desc->ops->set_suspend_mode && rstate->mode > 0) {
740 ret = rdev->desc->ops->set_suspend_mode(rdev, rstate->mode);
741 if (ret < 0) {
Joe Perches5da84fd2010-11-30 05:53:48 -0800742 rdev_err(rdev, "failed to set mode\n");
Liam Girdwood414c70c2008-04-30 15:59:04 +0100743 return ret;
744 }
745 }
746 return ret;
747}
748
749/* locks held by caller */
750static int suspend_prepare(struct regulator_dev *rdev, suspend_state_t state)
751{
752 if (!rdev->constraints)
753 return -EINVAL;
754
755 switch (state) {
756 case PM_SUSPEND_STANDBY:
757 return suspend_set_state(rdev,
758 &rdev->constraints->state_standby);
759 case PM_SUSPEND_MEM:
760 return suspend_set_state(rdev,
761 &rdev->constraints->state_mem);
762 case PM_SUSPEND_MAX:
763 return suspend_set_state(rdev,
764 &rdev->constraints->state_disk);
765 default:
766 return -EINVAL;
767 }
768}
769
770static void print_constraints(struct regulator_dev *rdev)
771{
772 struct regulation_constraints *constraints = rdev->constraints;
Mark Brown973e9a22010-02-11 19:20:48 +0000773 char buf[80] = "";
Mark Brown8f031b42009-10-22 16:31:31 +0100774 int count = 0;
775 int ret;
Liam Girdwood414c70c2008-04-30 15:59:04 +0100776
Mark Brown8f031b42009-10-22 16:31:31 +0100777 if (constraints->min_uV && constraints->max_uV) {
Liam Girdwood414c70c2008-04-30 15:59:04 +0100778 if (constraints->min_uV == constraints->max_uV)
Mark Brown8f031b42009-10-22 16:31:31 +0100779 count += sprintf(buf + count, "%d mV ",
780 constraints->min_uV / 1000);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100781 else
Mark Brown8f031b42009-10-22 16:31:31 +0100782 count += sprintf(buf + count, "%d <--> %d mV ",
783 constraints->min_uV / 1000,
784 constraints->max_uV / 1000);
Liam Girdwood414c70c2008-04-30 15:59:04 +0100785 }
Mark Brown8f031b42009-10-22 16:31:31 +0100786
787 if (!constraints->min_uV ||
788 constraints->min_uV != constraints->max_uV) {
789 ret = _regulator_get_voltage(rdev);
790 if (ret > 0)
791 count += sprintf(buf + count, "at %d mV ", ret / 1000);
792 }
793
Mark Brownbf5892a2011-05-08 22:13:37 +0100794 if (constraints->uV_offset)
795 count += sprintf(buf, "%dmV offset ",
796 constraints->uV_offset / 1000);
797
Mark Brown8f031b42009-10-22 16:31:31 +0100798 if (constraints->min_uA && constraints->max_uA) {
799 if (constraints->min_uA == constraints->max_uA)
800 count += sprintf(buf + count, "%d mA ",
801 constraints->min_uA / 1000);
802 else
803 count += sprintf(buf + count, "%d <--> %d mA ",
804 constraints->min_uA / 1000,
805 constraints->max_uA / 1000);
806 }
807
808 if (!constraints->min_uA ||
809 constraints->min_uA != constraints->max_uA) {
810 ret = _regulator_get_current_limit(rdev);
811 if (ret > 0)
Cyril Chemparathye4a63762010-09-22 12:30:15 -0400812 count += sprintf(buf + count, "at %d mA ", ret / 1000);
Mark Brown8f031b42009-10-22 16:31:31 +0100813 }
814
Liam Girdwood414c70c2008-04-30 15:59:04 +0100815 if (constraints->valid_modes_mask & REGULATOR_MODE_FAST)
816 count += sprintf(buf + count, "fast ");
817 if (constraints->valid_modes_mask & REGULATOR_MODE_NORMAL)
818 count += sprintf(buf + count, "normal ");
819 if (constraints->valid_modes_mask & REGULATOR_MODE_IDLE)
820 count += sprintf(buf + count, "idle ");
821 if (constraints->valid_modes_mask & REGULATOR_MODE_STANDBY)
822 count += sprintf(buf + count, "standby");
823
Uwe Kleine-König215b8b02012-08-07 21:01:37 +0200824 if (!count)
825 sprintf(buf, "no parameters");
826
Mark Brown194dbae2014-10-31 19:11:59 +0000827 rdev_dbg(rdev, "%s\n", buf);
Mark Brown4a682922012-02-09 13:26:13 +0000828
829 if ((constraints->min_uV != constraints->max_uV) &&
830 !(constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE))
831 rdev_warn(rdev,
832 "Voltage range but no REGULATOR_CHANGE_VOLTAGE\n");
Liam Girdwood414c70c2008-04-30 15:59:04 +0100833}
834
Mark Browne79055d2009-10-19 15:53:50 +0100835static int machine_constraints_voltage(struct regulator_dev *rdev,
Mark Brown1083c392009-10-22 16:31:32 +0100836 struct regulation_constraints *constraints)
Mark Browne79055d2009-10-19 15:53:50 +0100837{
Guodong Xu272e2312014-08-13 19:33:38 +0800838 const struct regulator_ops *ops = rdev->desc->ops;
Mark Brownaf5866c2009-10-22 16:31:30 +0100839 int ret;
840
841 /* do we need to apply the constraint voltage */
842 if (rdev->constraints->apply_uV &&
Mark Brown75790252010-12-12 14:25:50 +0000843 rdev->constraints->min_uV == rdev->constraints->max_uV) {
Alban Bedel064d5cd2014-05-20 12:12:16 +0200844 int current_uV = _regulator_get_voltage(rdev);
845 if (current_uV < 0) {
Nishanth Menon69d58832014-06-04 14:53:25 -0500846 rdev_err(rdev,
847 "failed to get the current voltage(%d)\n",
848 current_uV);
Alban Bedel064d5cd2014-05-20 12:12:16 +0200849 return current_uV;
850 }
851 if (current_uV < rdev->constraints->min_uV ||
852 current_uV > rdev->constraints->max_uV) {
853 ret = _regulator_do_set_voltage(
854 rdev, rdev->constraints->min_uV,
855 rdev->constraints->max_uV);
856 if (ret < 0) {
857 rdev_err(rdev,
Nishanth Menon69d58832014-06-04 14:53:25 -0500858 "failed to apply %duV constraint(%d)\n",
859 rdev->constraints->min_uV, ret);
Alban Bedel064d5cd2014-05-20 12:12:16 +0200860 return ret;
861 }
Mark Brown75790252010-12-12 14:25:50 +0000862 }
Mark Brownaf5866c2009-10-22 16:31:30 +0100863 }
Mark Browne79055d2009-10-19 15:53:50 +0100864
865 /* constrain machine-level voltage specs to fit
866 * the actual range supported by this regulator.
867 */
868 if (ops->list_voltage && rdev->desc->n_voltages) {
869 int count = rdev->desc->n_voltages;
870 int i;
871 int min_uV = INT_MAX;
872 int max_uV = INT_MIN;
873 int cmin = constraints->min_uV;
874 int cmax = constraints->max_uV;
875
876 /* it's safe to autoconfigure fixed-voltage supplies
877 and the constraints are used by list_voltage. */
878 if (count == 1 && !cmin) {
879 cmin = 1;
880 cmax = INT_MAX;
881 constraints->min_uV = cmin;
882 constraints->max_uV = cmax;
883 }
884
885 /* voltage constraints are optional */
886 if ((cmin == 0) && (cmax == 0))
887 return 0;
888
889 /* else require explicit machine-level constraints */
890 if (cmin <= 0 || cmax <= 0 || cmax < cmin) {
Joe Perches5da84fd2010-11-30 05:53:48 -0800891 rdev_err(rdev, "invalid voltage constraints\n");
Mark Browne79055d2009-10-19 15:53:50 +0100892 return -EINVAL;
893 }
894
895 /* initial: [cmin..cmax] valid, [min_uV..max_uV] not */
896 for (i = 0; i < count; i++) {
897 int value;
898
899 value = ops->list_voltage(rdev, i);
900 if (value <= 0)
901 continue;
902
903 /* maybe adjust [min_uV..max_uV] */
904 if (value >= cmin && value < min_uV)
905 min_uV = value;
906 if (value <= cmax && value > max_uV)
907 max_uV = value;
908 }
909
910 /* final: [min_uV..max_uV] valid iff constraints valid */
911 if (max_uV < min_uV) {
Mark Brownfff15be2012-11-27 18:48:56 +0000912 rdev_err(rdev,
913 "unsupportable voltage constraints %u-%uuV\n",
914 min_uV, max_uV);
Mark Browne79055d2009-10-19 15:53:50 +0100915 return -EINVAL;
916 }
917
918 /* use regulator's subset of machine constraints */
919 if (constraints->min_uV < min_uV) {
Joe Perches5da84fd2010-11-30 05:53:48 -0800920 rdev_dbg(rdev, "override min_uV, %d -> %d\n",
921 constraints->min_uV, min_uV);
Mark Browne79055d2009-10-19 15:53:50 +0100922 constraints->min_uV = min_uV;
923 }
924 if (constraints->max_uV > max_uV) {
Joe Perches5da84fd2010-11-30 05:53:48 -0800925 rdev_dbg(rdev, "override max_uV, %d -> %d\n",
926 constraints->max_uV, max_uV);
Mark Browne79055d2009-10-19 15:53:50 +0100927 constraints->max_uV = max_uV;
928 }
929 }
930
931 return 0;
932}
933
Laxman Dewanganf8c17002013-09-20 13:13:02 +0530934static int machine_constraints_current(struct regulator_dev *rdev,
935 struct regulation_constraints *constraints)
936{
Guodong Xu272e2312014-08-13 19:33:38 +0800937 const struct regulator_ops *ops = rdev->desc->ops;
Laxman Dewanganf8c17002013-09-20 13:13:02 +0530938 int ret;
939
940 if (!constraints->min_uA && !constraints->max_uA)
941 return 0;
942
943 if (constraints->min_uA > constraints->max_uA) {
944 rdev_err(rdev, "Invalid current constraints\n");
945 return -EINVAL;
946 }
947
948 if (!ops->set_current_limit || !ops->get_current_limit) {
949 rdev_warn(rdev, "Operation of current configuration missing\n");
950 return 0;
951 }
952
953 /* Set regulator current in constraints range */
954 ret = ops->set_current_limit(rdev, constraints->min_uA,
955 constraints->max_uA);
956 if (ret < 0) {
957 rdev_err(rdev, "Failed to set current constraint, %d\n", ret);
958 return ret;
959 }
960
961 return 0;
962}
963
Markus Pargmann30c21972014-02-20 17:36:03 +0100964static int _regulator_do_enable(struct regulator_dev *rdev);
965
Liam Girdwooda5766f12008-10-10 13:22:20 +0100966/**
967 * set_machine_constraints - sets regulator constraints
Mark Brown69279fb2008-12-31 12:52:41 +0000968 * @rdev: regulator source
Mark Brownc8e7e462008-12-31 12:52:42 +0000969 * @constraints: constraints to apply
Liam Girdwooda5766f12008-10-10 13:22:20 +0100970 *
971 * Allows platform initialisation code to define and constrain
972 * regulator circuits e.g. valid voltage/current ranges, etc. NOTE:
973 * Constraints *must* be set by platform code in order for some
974 * regulator operations to proceed i.e. set_voltage, set_current_limit,
975 * set_mode.
976 */
977static int set_machine_constraints(struct regulator_dev *rdev,
Mark Brownf8c12fe2010-11-29 15:55:17 +0000978 const struct regulation_constraints *constraints)
Liam Girdwooda5766f12008-10-10 13:22:20 +0100979{
980 int ret = 0;
Guodong Xu272e2312014-08-13 19:33:38 +0800981 const struct regulator_ops *ops = rdev->desc->ops;
Mark Browne06f5b42008-09-09 16:21:19 +0100982
Mark Brown9a8f5e02011-11-29 18:11:19 +0000983 if (constraints)
984 rdev->constraints = kmemdup(constraints, sizeof(*constraints),
985 GFP_KERNEL);
986 else
987 rdev->constraints = kzalloc(sizeof(*constraints),
988 GFP_KERNEL);
Mark Brownf8c12fe2010-11-29 15:55:17 +0000989 if (!rdev->constraints)
990 return -ENOMEM;
Mark Brownaf5866c2009-10-22 16:31:30 +0100991
Mark Brownf8c12fe2010-11-29 15:55:17 +0000992 ret = machine_constraints_voltage(rdev, rdev->constraints);
Mark Browne79055d2009-10-19 15:53:50 +0100993 if (ret != 0)
994 goto out;
David Brownell4367cfd2009-02-26 11:48:36 -0800995
Laxman Dewanganf8c17002013-09-20 13:13:02 +0530996 ret = machine_constraints_current(rdev, rdev->constraints);
997 if (ret != 0)
998 goto out;
999
Liam Girdwooda5766f12008-10-10 13:22:20 +01001000 /* do we need to setup our suspend state */
Mark Brown9a8f5e02011-11-29 18:11:19 +00001001 if (rdev->constraints->initial_state) {
Mark Brownf8c12fe2010-11-29 15:55:17 +00001002 ret = suspend_prepare(rdev, rdev->constraints->initial_state);
Mark Browne06f5b42008-09-09 16:21:19 +01001003 if (ret < 0) {
Joe Perches5da84fd2010-11-30 05:53:48 -08001004 rdev_err(rdev, "failed to set suspend state\n");
Mark Browne06f5b42008-09-09 16:21:19 +01001005 goto out;
1006 }
1007 }
Liam Girdwooda5766f12008-10-10 13:22:20 +01001008
Mark Brown9a8f5e02011-11-29 18:11:19 +00001009 if (rdev->constraints->initial_mode) {
Mark Browna3084662009-02-26 19:24:19 +00001010 if (!ops->set_mode) {
Joe Perches5da84fd2010-11-30 05:53:48 -08001011 rdev_err(rdev, "no set_mode operation\n");
Mark Browna3084662009-02-26 19:24:19 +00001012 ret = -EINVAL;
1013 goto out;
1014 }
1015
Mark Brownf8c12fe2010-11-29 15:55:17 +00001016 ret = ops->set_mode(rdev, rdev->constraints->initial_mode);
Mark Browna3084662009-02-26 19:24:19 +00001017 if (ret < 0) {
Joe Perches5da84fd2010-11-30 05:53:48 -08001018 rdev_err(rdev, "failed to set initial mode: %d\n", ret);
Mark Browna3084662009-02-26 19:24:19 +00001019 goto out;
1020 }
1021 }
1022
Mark Browncacf90f2009-03-02 16:32:46 +00001023 /* If the constraints say the regulator should be on at this point
1024 * and we have control then make sure it is enabled.
1025 */
Markus Pargmann30c21972014-02-20 17:36:03 +01001026 if (rdev->constraints->always_on || rdev->constraints->boot_on) {
1027 ret = _regulator_do_enable(rdev);
1028 if (ret < 0 && ret != -EINVAL) {
Joe Perches5da84fd2010-11-30 05:53:48 -08001029 rdev_err(rdev, "failed to enable\n");
Mark Browne5fda262008-09-09 16:21:20 +01001030 goto out;
1031 }
1032 }
1033
Yadwinder Singh Brar1653ccf2013-06-29 18:21:15 +05301034 if ((rdev->constraints->ramp_delay || rdev->constraints->ramp_disable)
1035 && ops->set_ramp_delay) {
Yadwinder Singh Brar6f0b2c62012-06-11 17:41:08 +05301036 ret = ops->set_ramp_delay(rdev, rdev->constraints->ramp_delay);
1037 if (ret < 0) {
1038 rdev_err(rdev, "failed to set ramp_delay\n");
1039 goto out;
1040 }
1041 }
1042
Liam Girdwooda5766f12008-10-10 13:22:20 +01001043 print_constraints(rdev);
Axel Lin1a6958e72011-07-15 10:50:43 +08001044 return 0;
Liam Girdwooda5766f12008-10-10 13:22:20 +01001045out:
Axel Lin1a6958e72011-07-15 10:50:43 +08001046 kfree(rdev->constraints);
1047 rdev->constraints = NULL;
Liam Girdwooda5766f12008-10-10 13:22:20 +01001048 return ret;
1049}
1050
1051/**
1052 * set_supply - set regulator supply regulator
Mark Brown69279fb2008-12-31 12:52:41 +00001053 * @rdev: regulator name
1054 * @supply_rdev: supply regulator name
Liam Girdwooda5766f12008-10-10 13:22:20 +01001055 *
1056 * Called by platform initialisation code to set the supply regulator for this
1057 * regulator. This ensures that a regulators supply will also be enabled by the
1058 * core if it's child is enabled.
1059 */
1060static int set_supply(struct regulator_dev *rdev,
Mark Brown3801b862011-06-09 16:22:22 +01001061 struct regulator_dev *supply_rdev)
Liam Girdwooda5766f12008-10-10 13:22:20 +01001062{
1063 int err;
1064
Mark Brown3801b862011-06-09 16:22:22 +01001065 rdev_info(rdev, "supplied by %s\n", rdev_get_name(supply_rdev));
1066
1067 rdev->supply = create_regulator(supply_rdev, &rdev->dev, "SUPPLY");
Axel Lin32c78de2011-12-29 17:03:20 +08001068 if (rdev->supply == NULL) {
1069 err = -ENOMEM;
Mark Brown3801b862011-06-09 16:22:22 +01001070 return err;
Liam Girdwooda5766f12008-10-10 13:22:20 +01001071 }
Laxman Dewangan57ad526a2012-07-23 20:35:46 +05301072 supply_rdev->open_count++;
Mark Brown3801b862011-06-09 16:22:22 +01001073
1074 return 0;
Liam Girdwooda5766f12008-10-10 13:22:20 +01001075}
1076
1077/**
Randy Dunlap06c63f92010-11-18 15:02:26 -08001078 * set_consumer_device_supply - Bind a regulator to a symbolic supply
Mark Brown69279fb2008-12-31 12:52:41 +00001079 * @rdev: regulator source
Mark Brown40f92442009-06-17 17:56:39 +01001080 * @consumer_dev_name: dev_name() string for device supply applies to
Mark Brown69279fb2008-12-31 12:52:41 +00001081 * @supply: symbolic name for supply
Liam Girdwooda5766f12008-10-10 13:22:20 +01001082 *
1083 * Allows platform initialisation code to map physical regulator
1084 * sources to symbolic names for supplies for use by devices. Devices
1085 * should use these symbolic names to request regulators, avoiding the
1086 * need to provide board-specific regulator names as platform data.
1087 */
1088static int set_consumer_device_supply(struct regulator_dev *rdev,
Mark Brown737f3602012-02-02 00:10:51 +00001089 const char *consumer_dev_name,
1090 const char *supply)
Liam Girdwooda5766f12008-10-10 13:22:20 +01001091{
1092 struct regulator_map *node;
Mark Brown9ed20992009-07-21 16:00:26 +01001093 int has_dev;
Liam Girdwooda5766f12008-10-10 13:22:20 +01001094
1095 if (supply == NULL)
1096 return -EINVAL;
1097
Mark Brown9ed20992009-07-21 16:00:26 +01001098 if (consumer_dev_name != NULL)
1099 has_dev = 1;
1100 else
1101 has_dev = 0;
1102
David Brownell6001e132008-12-31 12:54:19 +00001103 list_for_each_entry(node, &regulator_map_list, list) {
Jani Nikula23b5cc22010-04-29 10:55:09 +03001104 if (node->dev_name && consumer_dev_name) {
1105 if (strcmp(node->dev_name, consumer_dev_name) != 0)
1106 continue;
1107 } else if (node->dev_name || consumer_dev_name) {
David Brownell6001e132008-12-31 12:54:19 +00001108 continue;
Jani Nikula23b5cc22010-04-29 10:55:09 +03001109 }
1110
David Brownell6001e132008-12-31 12:54:19 +00001111 if (strcmp(node->supply, supply) != 0)
1112 continue;
1113
Mark Brown737f3602012-02-02 00:10:51 +00001114 pr_debug("%s: %s/%s is '%s' supply; fail %s/%s\n",
1115 consumer_dev_name,
1116 dev_name(&node->regulator->dev),
1117 node->regulator->desc->name,
1118 supply,
1119 dev_name(&rdev->dev), rdev_get_name(rdev));
David Brownell6001e132008-12-31 12:54:19 +00001120 return -EBUSY;
1121 }
1122
Mark Brown9ed20992009-07-21 16:00:26 +01001123 node = kzalloc(sizeof(struct regulator_map), GFP_KERNEL);
Liam Girdwooda5766f12008-10-10 13:22:20 +01001124 if (node == NULL)
1125 return -ENOMEM;
1126
1127 node->regulator = rdev;
Liam Girdwooda5766f12008-10-10 13:22:20 +01001128 node->supply = supply;
1129
Mark Brown9ed20992009-07-21 16:00:26 +01001130 if (has_dev) {
1131 node->dev_name = kstrdup(consumer_dev_name, GFP_KERNEL);
1132 if (node->dev_name == NULL) {
1133 kfree(node);
1134 return -ENOMEM;
1135 }
Mark Brown40f92442009-06-17 17:56:39 +01001136 }
1137
Liam Girdwooda5766f12008-10-10 13:22:20 +01001138 list_add(&node->list, &regulator_map_list);
1139 return 0;
1140}
1141
Mike Rapoport0f1d7472009-01-22 16:00:29 +02001142static void unset_regulator_supplies(struct regulator_dev *rdev)
1143{
1144 struct regulator_map *node, *n;
1145
1146 list_for_each_entry_safe(node, n, &regulator_map_list, list) {
1147 if (rdev == node->regulator) {
1148 list_del(&node->list);
Mark Brown40f92442009-06-17 17:56:39 +01001149 kfree(node->dev_name);
Mike Rapoport0f1d7472009-01-22 16:00:29 +02001150 kfree(node);
Mike Rapoport0f1d7472009-01-22 16:00:29 +02001151 }
1152 }
1153}
1154
Mark Brownf5726ae2011-06-09 16:22:20 +01001155#define REG_STR_SIZE 64
Liam Girdwood414c70c2008-04-30 15:59:04 +01001156
1157static struct regulator *create_regulator(struct regulator_dev *rdev,
1158 struct device *dev,
1159 const char *supply_name)
1160{
1161 struct regulator *regulator;
1162 char buf[REG_STR_SIZE];
1163 int err, size;
1164
1165 regulator = kzalloc(sizeof(*regulator), GFP_KERNEL);
1166 if (regulator == NULL)
1167 return NULL;
1168
1169 mutex_lock(&rdev->mutex);
1170 regulator->rdev = rdev;
1171 list_add(&regulator->list, &rdev->consumer_list);
1172
1173 if (dev) {
Shawn Guoe2c98ea2012-07-05 14:19:42 +08001174 regulator->dev = dev;
1175
Mark Brown222cc7b2012-06-22 11:39:16 +01001176 /* Add a link to the device sysfs entry */
Liam Girdwood414c70c2008-04-30 15:59:04 +01001177 size = scnprintf(buf, REG_STR_SIZE, "%s-%s",
1178 dev->kobj.name, supply_name);
1179 if (size >= REG_STR_SIZE)
Mark Brown222cc7b2012-06-22 11:39:16 +01001180 goto overflow_err;
Liam Girdwood414c70c2008-04-30 15:59:04 +01001181
1182 regulator->supply_name = kstrdup(buf, GFP_KERNEL);
1183 if (regulator->supply_name == NULL)
Mark Brown222cc7b2012-06-22 11:39:16 +01001184 goto overflow_err;
Liam Girdwood414c70c2008-04-30 15:59:04 +01001185
1186 err = sysfs_create_link(&rdev->dev.kobj, &dev->kobj,
1187 buf);
1188 if (err) {
Joe Perches5da84fd2010-11-30 05:53:48 -08001189 rdev_warn(rdev, "could not add device link %s err %d\n",
1190 dev->kobj.name, err);
Mark Brown222cc7b2012-06-22 11:39:16 +01001191 /* non-fatal */
Liam Girdwood414c70c2008-04-30 15:59:04 +01001192 }
Mark Brown5de70512011-06-19 13:33:16 +01001193 } else {
1194 regulator->supply_name = kstrdup(supply_name, GFP_KERNEL);
1195 if (regulator->supply_name == NULL)
Mark Brown222cc7b2012-06-22 11:39:16 +01001196 goto overflow_err;
Liam Girdwood414c70c2008-04-30 15:59:04 +01001197 }
Mark Brown5de70512011-06-19 13:33:16 +01001198
Mark Brown5de70512011-06-19 13:33:16 +01001199 regulator->debugfs = debugfs_create_dir(regulator->supply_name,
1200 rdev->debugfs);
Stephen Boyd24751432012-02-20 22:50:42 -08001201 if (!regulator->debugfs) {
Mark Brown5de70512011-06-19 13:33:16 +01001202 rdev_warn(rdev, "Failed to create debugfs directory\n");
Mark Brown5de70512011-06-19 13:33:16 +01001203 } else {
1204 debugfs_create_u32("uA_load", 0444, regulator->debugfs,
1205 &regulator->uA_load);
1206 debugfs_create_u32("min_uV", 0444, regulator->debugfs,
1207 &regulator->min_uV);
1208 debugfs_create_u32("max_uV", 0444, regulator->debugfs,
1209 &regulator->max_uV);
1210 }
Mark Brown5de70512011-06-19 13:33:16 +01001211
Mark Brown6492bc12012-04-19 13:19:07 +01001212 /*
1213 * Check now if the regulator is an always on regulator - if
1214 * it is then we don't need to do nearly so much work for
1215 * enable/disable calls.
1216 */
1217 if (!_regulator_can_change_status(rdev) &&
1218 _regulator_is_enabled(rdev))
1219 regulator->always_on = true;
1220
Liam Girdwood414c70c2008-04-30 15:59:04 +01001221 mutex_unlock(&rdev->mutex);
1222 return regulator;
Liam Girdwood414c70c2008-04-30 15:59:04 +01001223overflow_err:
1224 list_del(&regulator->list);
1225 kfree(regulator);
1226 mutex_unlock(&rdev->mutex);
1227 return NULL;
1228}
1229
Mark Brown31aae2b2009-12-21 12:21:52 +00001230static int _regulator_get_enable_time(struct regulator_dev *rdev)
1231{
Laxman Dewangan00c877c2013-09-18 18:18:02 +05301232 if (rdev->constraints && rdev->constraints->enable_time)
1233 return rdev->constraints->enable_time;
Mark Brown31aae2b2009-12-21 12:21:52 +00001234 if (!rdev->desc->ops->enable_time)
Mark Brown79511ed2012-06-27 14:23:10 +01001235 return rdev->desc->enable_time;
Mark Brown31aae2b2009-12-21 12:21:52 +00001236 return rdev->desc->ops->enable_time(rdev);
1237}
1238
Charles Keepaxa06ccd92013-10-15 20:14:20 +01001239static struct regulator_supply_alias *regulator_find_supply_alias(
1240 struct device *dev, const char *supply)
1241{
1242 struct regulator_supply_alias *map;
1243
1244 list_for_each_entry(map, &regulator_supply_alias_list, list)
1245 if (map->src_dev == dev && strcmp(map->src_supply, supply) == 0)
1246 return map;
1247
1248 return NULL;
1249}
1250
1251static void regulator_supply_alias(struct device **dev, const char **supply)
1252{
1253 struct regulator_supply_alias *map;
1254
1255 map = regulator_find_supply_alias(*dev, *supply);
1256 if (map) {
1257 dev_dbg(*dev, "Mapping supply %s to %s,%s\n",
1258 *supply, map->alias_supply,
1259 dev_name(map->alias_dev));
1260 *dev = map->alias_dev;
1261 *supply = map->alias_supply;
1262 }
1263}
1264
Rajendra Nayak69511a42011-11-18 16:47:20 +05301265static struct regulator_dev *regulator_dev_lookup(struct device *dev,
Mark Brown6d191a52012-03-29 14:19:02 +01001266 const char *supply,
1267 int *ret)
Rajendra Nayak69511a42011-11-18 16:47:20 +05301268{
1269 struct regulator_dev *r;
1270 struct device_node *node;
Mark Brown576ca4362012-03-30 12:24:37 +01001271 struct regulator_map *map;
1272 const char *devname = NULL;
Rajendra Nayak69511a42011-11-18 16:47:20 +05301273
Charles Keepaxa06ccd92013-10-15 20:14:20 +01001274 regulator_supply_alias(&dev, &supply);
1275
Rajendra Nayak69511a42011-11-18 16:47:20 +05301276 /* first do a dt based lookup */
1277 if (dev && dev->of_node) {
1278 node = of_get_regulator(dev, supply);
Mark Brown6d191a52012-03-29 14:19:02 +01001279 if (node) {
Rajendra Nayak69511a42011-11-18 16:47:20 +05301280 list_for_each_entry(r, &regulator_list, list)
1281 if (r->dev.parent &&
1282 node == r->dev.of_node)
1283 return r;
Mark Brown317b5682014-01-27 17:34:07 +00001284 *ret = -EPROBE_DEFER;
1285 return NULL;
Mark Brown6d191a52012-03-29 14:19:02 +01001286 } else {
1287 /*
1288 * If we couldn't even get the node then it's
1289 * not just that the device didn't register
1290 * yet, there's no node and we'll never
1291 * succeed.
1292 */
1293 *ret = -ENODEV;
1294 }
Rajendra Nayak69511a42011-11-18 16:47:20 +05301295 }
1296
1297 /* if not found, try doing it non-dt way */
Mark Brown576ca4362012-03-30 12:24:37 +01001298 if (dev)
1299 devname = dev_name(dev);
1300
Rajendra Nayak69511a42011-11-18 16:47:20 +05301301 list_for_each_entry(r, &regulator_list, list)
1302 if (strcmp(rdev_get_name(r), supply) == 0)
1303 return r;
1304
Mark Brown576ca4362012-03-30 12:24:37 +01001305 list_for_each_entry(map, &regulator_map_list, list) {
1306 /* If the mapping has a device set up it must match */
1307 if (map->dev_name &&
1308 (!devname || strcmp(map->dev_name, devname)))
1309 continue;
1310
1311 if (strcmp(map->supply, supply) == 0)
1312 return map->regulator;
1313 }
1314
1315
Rajendra Nayak69511a42011-11-18 16:47:20 +05301316 return NULL;
1317}
1318
Mark Brown5ffbd132009-07-21 16:00:23 +01001319/* Internal regulator request function */
1320static struct regulator *_regulator_get(struct device *dev, const char *id,
Mark Brown4ddfebd2013-09-13 19:50:37 +01001321 bool exclusive, bool allow_dummy)
Liam Girdwood414c70c2008-04-30 15:59:04 +01001322{
1323 struct regulator_dev *rdev;
Mark Brown04bf3012012-03-11 13:07:56 +00001324 struct regulator *regulator = ERR_PTR(-EPROBE_DEFER);
Mark Brown40f92442009-06-17 17:56:39 +01001325 const char *devname = NULL;
Mark Brown317b5682014-01-27 17:34:07 +00001326 int ret;
Liam Girdwood414c70c2008-04-30 15:59:04 +01001327
1328 if (id == NULL) {
Joe Perches5da84fd2010-11-30 05:53:48 -08001329 pr_err("get() with no identifier\n");
Mark Brown043c9982013-09-20 12:32:18 +01001330 return ERR_PTR(-EINVAL);
Liam Girdwood414c70c2008-04-30 15:59:04 +01001331 }
1332
Mark Brown40f92442009-06-17 17:56:39 +01001333 if (dev)
1334 devname = dev_name(dev);
1335
Mark Brown317b5682014-01-27 17:34:07 +00001336 if (have_full_constraints())
1337 ret = -ENODEV;
1338 else
1339 ret = -EPROBE_DEFER;
1340
Liam Girdwood414c70c2008-04-30 15:59:04 +01001341 mutex_lock(&regulator_list_mutex);
1342
Mark Brown6d191a52012-03-29 14:19:02 +01001343 rdev = regulator_dev_lookup(dev, id, &ret);
Rajendra Nayak69511a42011-11-18 16:47:20 +05301344 if (rdev)
1345 goto found;
1346
Mark Brownef60abb2013-09-23 16:12:52 +01001347 regulator = ERR_PTR(ret);
1348
Nishanth Menon1e4b5452013-04-16 16:45:16 -05001349 /*
1350 * If we have return value from dev_lookup fail, we do not expect to
1351 * succeed, so, quit with appropriate error value
1352 */
Jingoo Han0d25d092014-01-08 10:02:16 +09001353 if (ret && ret != -ENODEV)
Nishanth Menon1e4b5452013-04-16 16:45:16 -05001354 goto out;
Nishanth Menon1e4b5452013-04-16 16:45:16 -05001355
Mark Brown34abbd62010-02-12 10:18:08 +00001356 if (!devname)
1357 devname = "deviceless";
1358
Mark Brown4ddfebd2013-09-13 19:50:37 +01001359 /*
1360 * Assume that a regulator is physically present and enabled
1361 * even if it isn't hooked up and just provide a dummy.
Mark Brown34abbd62010-02-12 10:18:08 +00001362 */
Mark Brown87b28412013-11-27 16:13:10 +00001363 if (have_full_constraints() && allow_dummy) {
Joe Perches5da84fd2010-11-30 05:53:48 -08001364 pr_warn("%s supply %s not found, using dummy regulator\n",
1365 devname, id);
Mark Brown4ddfebd2013-09-13 19:50:37 +01001366
Mark Brown34abbd62010-02-12 10:18:08 +00001367 rdev = dummy_regulator_rdev;
1368 goto found;
Hans de Goede07817192013-12-17 16:24:57 +01001369 /* Don't log an error when called from regulator_get_optional() */
1370 } else if (!have_full_constraints() || exclusive) {
Shuah Khanacc3d5c2014-02-20 12:58:15 -07001371 dev_warn(dev, "dummy supplies not allowed\n");
Mark Brown34abbd62010-02-12 10:18:08 +00001372 }
Mark Brown34abbd62010-02-12 10:18:08 +00001373
Liam Girdwood414c70c2008-04-30 15:59:04 +01001374 mutex_unlock(&regulator_list_mutex);
1375 return regulator;
1376
1377found:
Mark Brown5ffbd132009-07-21 16:00:23 +01001378 if (rdev->exclusive) {
1379 regulator = ERR_PTR(-EPERM);
1380 goto out;
1381 }
1382
1383 if (exclusive && rdev->open_count) {
1384 regulator = ERR_PTR(-EBUSY);
1385 goto out;
1386 }
1387
Liam Girdwooda5766f12008-10-10 13:22:20 +01001388 if (!try_module_get(rdev->owner))
1389 goto out;
1390
Liam Girdwood414c70c2008-04-30 15:59:04 +01001391 regulator = create_regulator(rdev, dev, id);
1392 if (regulator == NULL) {
1393 regulator = ERR_PTR(-ENOMEM);
1394 module_put(rdev->owner);
Axel Linbcda4322011-12-29 17:02:08 +08001395 goto out;
Liam Girdwood414c70c2008-04-30 15:59:04 +01001396 }
1397
Mark Brown5ffbd132009-07-21 16:00:23 +01001398 rdev->open_count++;
1399 if (exclusive) {
1400 rdev->exclusive = 1;
1401
1402 ret = _regulator_is_enabled(rdev);
1403 if (ret > 0)
1404 rdev->use_count = 1;
1405 else
1406 rdev->use_count = 0;
1407 }
1408
Liam Girdwooda5766f12008-10-10 13:22:20 +01001409out:
Liam Girdwood414c70c2008-04-30 15:59:04 +01001410 mutex_unlock(&regulator_list_mutex);
Mark Brown5ffbd132009-07-21 16:00:23 +01001411
Liam Girdwood414c70c2008-04-30 15:59:04 +01001412 return regulator;
1413}
Mark Brown5ffbd132009-07-21 16:00:23 +01001414
1415/**
1416 * regulator_get - lookup and obtain a reference to a regulator.
1417 * @dev: device for regulator "consumer"
1418 * @id: Supply name or regulator ID.
1419 *
1420 * Returns a struct regulator corresponding to the regulator producer,
1421 * or IS_ERR() condition containing errno.
1422 *
1423 * Use of supply names configured via regulator_set_device_supply() is
1424 * strongly encouraged. It is recommended that the supply name used
1425 * should match the name used for the supply and/or the relevant
1426 * device pins in the datasheet.
1427 */
1428struct regulator *regulator_get(struct device *dev, const char *id)
1429{
Mark Brown4ddfebd2013-09-13 19:50:37 +01001430 return _regulator_get(dev, id, false, true);
Mark Brown5ffbd132009-07-21 16:00:23 +01001431}
Liam Girdwood414c70c2008-04-30 15:59:04 +01001432EXPORT_SYMBOL_GPL(regulator_get);
1433
Stephen Boyd070b9072012-01-16 19:39:58 -08001434/**
Mark Brown5ffbd132009-07-21 16:00:23 +01001435 * regulator_get_exclusive - obtain exclusive access to a regulator.
1436 * @dev: device for regulator "consumer"
1437 * @id: Supply name or regulator ID.
1438 *
1439 * Returns a struct regulator corresponding to the regulator producer,
1440 * or IS_ERR() condition containing errno. Other consumers will be
Stephen Boyd69c3f722014-05-28 12:41:28 -07001441 * unable to obtain this regulator while this reference is held and the
1442 * use count for the regulator will be initialised to reflect the current
1443 * state of the regulator.
Mark Brown5ffbd132009-07-21 16:00:23 +01001444 *
1445 * This is intended for use by consumers which cannot tolerate shared
1446 * use of the regulator such as those which need to force the
1447 * regulator off for correct operation of the hardware they are
1448 * controlling.
1449 *
1450 * Use of supply names configured via regulator_set_device_supply() is
1451 * strongly encouraged. It is recommended that the supply name used
1452 * should match the name used for the supply and/or the relevant
1453 * device pins in the datasheet.
1454 */
1455struct regulator *regulator_get_exclusive(struct device *dev, const char *id)
1456{
Mark Brown4ddfebd2013-09-13 19:50:37 +01001457 return _regulator_get(dev, id, true, false);
Mark Brown5ffbd132009-07-21 16:00:23 +01001458}
1459EXPORT_SYMBOL_GPL(regulator_get_exclusive);
1460
Mark Brownde1dd9f2013-07-29 21:42:42 +01001461/**
1462 * regulator_get_optional - obtain optional access to a regulator.
1463 * @dev: device for regulator "consumer"
1464 * @id: Supply name or regulator ID.
1465 *
1466 * Returns a struct regulator corresponding to the regulator producer,
Stephen Boyd69c3f722014-05-28 12:41:28 -07001467 * or IS_ERR() condition containing errno.
Mark Brownde1dd9f2013-07-29 21:42:42 +01001468 *
1469 * This is intended for use by consumers for devices which can have
1470 * some supplies unconnected in normal use, such as some MMC devices.
1471 * It can allow the regulator core to provide stub supplies for other
1472 * supplies requested using normal regulator_get() calls without
1473 * disrupting the operation of drivers that can handle absent
1474 * supplies.
1475 *
1476 * Use of supply names configured via regulator_set_device_supply() is
1477 * strongly encouraged. It is recommended that the supply name used
1478 * should match the name used for the supply and/or the relevant
1479 * device pins in the datasheet.
1480 */
1481struct regulator *regulator_get_optional(struct device *dev, const char *id)
1482{
Mark Brown4ddfebd2013-09-13 19:50:37 +01001483 return _regulator_get(dev, id, false, false);
Mark Brownde1dd9f2013-07-29 21:42:42 +01001484}
1485EXPORT_SYMBOL_GPL(regulator_get_optional);
1486
Ashay Jaiswal83b03022015-01-08 18:54:25 +05301487/* regulator_list_mutex lock held by regulator_put() */
Charles Keepax23ff2f02012-11-14 09:39:31 +00001488static void _regulator_put(struct regulator *regulator)
Liam Girdwood414c70c2008-04-30 15:59:04 +01001489{
1490 struct regulator_dev *rdev;
1491
1492 if (regulator == NULL || IS_ERR(regulator))
1493 return;
1494
Liam Girdwood414c70c2008-04-30 15:59:04 +01001495 rdev = regulator->rdev;
1496
Mark Brown5de70512011-06-19 13:33:16 +01001497 debugfs_remove_recursive(regulator->debugfs);
Mark Brown5de70512011-06-19 13:33:16 +01001498
Liam Girdwood414c70c2008-04-30 15:59:04 +01001499 /* remove any sysfs entries */
Shawn Guoe2c98ea2012-07-05 14:19:42 +08001500 if (regulator->dev)
Liam Girdwood414c70c2008-04-30 15:59:04 +01001501 sysfs_remove_link(&rdev->dev.kobj, regulator->supply_name);
Ashay Jaiswal83b03022015-01-08 18:54:25 +05301502 mutex_lock(&rdev->mutex);
Mark Brown5de70512011-06-19 13:33:16 +01001503 kfree(regulator->supply_name);
Liam Girdwood414c70c2008-04-30 15:59:04 +01001504 list_del(&regulator->list);
1505 kfree(regulator);
1506
Mark Brown5ffbd132009-07-21 16:00:23 +01001507 rdev->open_count--;
1508 rdev->exclusive = 0;
Ashay Jaiswal83b03022015-01-08 18:54:25 +05301509 mutex_unlock(&rdev->mutex);
Mark Brown5ffbd132009-07-21 16:00:23 +01001510
Liam Girdwood414c70c2008-04-30 15:59:04 +01001511 module_put(rdev->owner);
Charles Keepax23ff2f02012-11-14 09:39:31 +00001512}
1513
1514/**
1515 * regulator_put - "free" the regulator source
1516 * @regulator: regulator source
1517 *
1518 * Note: drivers must ensure that all regulator_enable calls made on this
1519 * regulator source are balanced by regulator_disable calls prior to calling
1520 * this function.
1521 */
1522void regulator_put(struct regulator *regulator)
1523{
1524 mutex_lock(&regulator_list_mutex);
1525 _regulator_put(regulator);
Liam Girdwood414c70c2008-04-30 15:59:04 +01001526 mutex_unlock(&regulator_list_mutex);
1527}
1528EXPORT_SYMBOL_GPL(regulator_put);
1529
Charles Keepaxa06ccd92013-10-15 20:14:20 +01001530/**
1531 * regulator_register_supply_alias - Provide device alias for supply lookup
1532 *
1533 * @dev: device that will be given as the regulator "consumer"
1534 * @id: Supply name or regulator ID
1535 * @alias_dev: device that should be used to lookup the supply
1536 * @alias_id: Supply name or regulator ID that should be used to lookup the
1537 * supply
1538 *
1539 * All lookups for id on dev will instead be conducted for alias_id on
1540 * alias_dev.
1541 */
1542int regulator_register_supply_alias(struct device *dev, const char *id,
1543 struct device *alias_dev,
1544 const char *alias_id)
1545{
1546 struct regulator_supply_alias *map;
1547
1548 map = regulator_find_supply_alias(dev, id);
1549 if (map)
1550 return -EEXIST;
1551
1552 map = kzalloc(sizeof(struct regulator_supply_alias), GFP_KERNEL);
1553 if (!map)
1554 return -ENOMEM;
1555
1556 map->src_dev = dev;
1557 map->src_supply = id;
1558 map->alias_dev = alias_dev;
1559 map->alias_supply = alias_id;
1560
1561 list_add(&map->list, &regulator_supply_alias_list);
1562
1563 pr_info("Adding alias for supply %s,%s -> %s,%s\n",
1564 id, dev_name(dev), alias_id, dev_name(alias_dev));
1565
1566 return 0;
1567}
1568EXPORT_SYMBOL_GPL(regulator_register_supply_alias);
1569
1570/**
1571 * regulator_unregister_supply_alias - Remove device alias
1572 *
1573 * @dev: device that will be given as the regulator "consumer"
1574 * @id: Supply name or regulator ID
1575 *
1576 * Remove a lookup alias if one exists for id on dev.
1577 */
1578void regulator_unregister_supply_alias(struct device *dev, const char *id)
1579{
1580 struct regulator_supply_alias *map;
1581
1582 map = regulator_find_supply_alias(dev, id);
1583 if (map) {
1584 list_del(&map->list);
1585 kfree(map);
1586 }
1587}
1588EXPORT_SYMBOL_GPL(regulator_unregister_supply_alias);
1589
1590/**
1591 * regulator_bulk_register_supply_alias - register multiple aliases
1592 *
1593 * @dev: device that will be given as the regulator "consumer"
1594 * @id: List of supply names or regulator IDs
1595 * @alias_dev: device that should be used to lookup the supply
1596 * @alias_id: List of supply names or regulator IDs that should be used to
1597 * lookup the supply
1598 * @num_id: Number of aliases to register
1599 *
1600 * @return 0 on success, an errno on failure.
1601 *
1602 * This helper function allows drivers to register several supply
1603 * aliases in one operation. If any of the aliases cannot be
1604 * registered any aliases that were registered will be removed
1605 * before returning to the caller.
1606 */
Lee Jones9f8c0fe2014-05-23 16:44:10 +01001607int regulator_bulk_register_supply_alias(struct device *dev,
1608 const char *const *id,
Charles Keepaxa06ccd92013-10-15 20:14:20 +01001609 struct device *alias_dev,
Lee Jones9f8c0fe2014-05-23 16:44:10 +01001610 const char *const *alias_id,
Charles Keepaxa06ccd92013-10-15 20:14:20 +01001611 int num_id)
1612{
1613 int i;
1614 int ret;
1615
1616 for (i = 0; i < num_id; ++i) {
1617 ret = regulator_register_supply_alias(dev, id[i], alias_dev,
1618 alias_id[i]);
1619 if (ret < 0)
1620 goto err;
1621 }
1622
1623 return 0;
1624
1625err:
1626 dev_err(dev,
1627 "Failed to create supply alias %s,%s -> %s,%s\n",
1628 id[i], dev_name(dev), alias_id[i], dev_name(alias_dev));
1629
1630 while (--i >= 0)
1631 regulator_unregister_supply_alias(dev, id[i]);
1632
1633 return ret;
1634}
1635EXPORT_SYMBOL_GPL(regulator_bulk_register_supply_alias);
1636
1637/**
1638 * regulator_bulk_unregister_supply_alias - unregister multiple aliases
1639 *
1640 * @dev: device that will be given as the regulator "consumer"
1641 * @id: List of supply names or regulator IDs
1642 * @num_id: Number of aliases to unregister
1643 *
1644 * This helper function allows drivers to unregister several supply
1645 * aliases in one operation.
1646 */
1647void regulator_bulk_unregister_supply_alias(struct device *dev,
Lee Jones9f8c0fe2014-05-23 16:44:10 +01001648 const char *const *id,
Charles Keepaxa06ccd92013-10-15 20:14:20 +01001649 int num_id)
1650{
1651 int i;
1652
1653 for (i = 0; i < num_id; ++i)
1654 regulator_unregister_supply_alias(dev, id[i]);
1655}
1656EXPORT_SYMBOL_GPL(regulator_bulk_unregister_supply_alias);
1657
1658
Kim, Milof19b00d2013-02-18 06:50:39 +00001659/* Manage enable GPIO list. Same GPIO pin can be shared among regulators */
1660static int regulator_ena_gpio_request(struct regulator_dev *rdev,
1661 const struct regulator_config *config)
1662{
1663 struct regulator_enable_gpio *pin;
Russell King778b28b2014-06-29 17:55:54 +01001664 struct gpio_desc *gpiod;
Kim, Milof19b00d2013-02-18 06:50:39 +00001665 int ret;
1666
Russell King778b28b2014-06-29 17:55:54 +01001667 gpiod = gpio_to_desc(config->ena_gpio);
1668
Kim, Milof19b00d2013-02-18 06:50:39 +00001669 list_for_each_entry(pin, &regulator_ena_gpio_list, list) {
Russell King778b28b2014-06-29 17:55:54 +01001670 if (pin->gpiod == gpiod) {
Kim, Milof19b00d2013-02-18 06:50:39 +00001671 rdev_dbg(rdev, "GPIO %d is already used\n",
1672 config->ena_gpio);
1673 goto update_ena_gpio_to_rdev;
1674 }
1675 }
1676
1677 ret = gpio_request_one(config->ena_gpio,
1678 GPIOF_DIR_OUT | config->ena_gpio_flags,
1679 rdev_get_name(rdev));
1680 if (ret)
1681 return ret;
1682
1683 pin = kzalloc(sizeof(struct regulator_enable_gpio), GFP_KERNEL);
1684 if (pin == NULL) {
1685 gpio_free(config->ena_gpio);
1686 return -ENOMEM;
1687 }
1688
Russell King778b28b2014-06-29 17:55:54 +01001689 pin->gpiod = gpiod;
Kim, Milof19b00d2013-02-18 06:50:39 +00001690 pin->ena_gpio_invert = config->ena_gpio_invert;
1691 list_add(&pin->list, &regulator_ena_gpio_list);
1692
1693update_ena_gpio_to_rdev:
1694 pin->request_count++;
1695 rdev->ena_pin = pin;
1696 return 0;
1697}
1698
1699static void regulator_ena_gpio_free(struct regulator_dev *rdev)
1700{
1701 struct regulator_enable_gpio *pin, *n;
1702
1703 if (!rdev->ena_pin)
1704 return;
1705
1706 /* Free the GPIO only in case of no use */
1707 list_for_each_entry_safe(pin, n, &regulator_ena_gpio_list, list) {
Russell King778b28b2014-06-29 17:55:54 +01001708 if (pin->gpiod == rdev->ena_pin->gpiod) {
Kim, Milof19b00d2013-02-18 06:50:39 +00001709 if (pin->request_count <= 1) {
1710 pin->request_count = 0;
Russell King778b28b2014-06-29 17:55:54 +01001711 gpiod_put(pin->gpiod);
Kim, Milof19b00d2013-02-18 06:50:39 +00001712 list_del(&pin->list);
1713 kfree(pin);
Seung-Woo Kim60a23622014-12-04 19:17:17 +09001714 rdev->ena_pin = NULL;
1715 return;
Kim, Milof19b00d2013-02-18 06:50:39 +00001716 } else {
1717 pin->request_count--;
1718 }
1719 }
1720 }
1721}
1722
Kim, Milo967cfb12013-02-18 06:50:48 +00001723/**
Robert P. J. Day31d6eeb2013-05-02 10:19:11 -04001724 * regulator_ena_gpio_ctrl - balance enable_count of each GPIO and actual GPIO pin control
1725 * @rdev: regulator_dev structure
1726 * @enable: enable GPIO at initial use?
1727 *
Kim, Milo967cfb12013-02-18 06:50:48 +00001728 * GPIO is enabled in case of initial use. (enable_count is 0)
1729 * GPIO is disabled when it is not shared any more. (enable_count <= 1)
1730 */
1731static int regulator_ena_gpio_ctrl(struct regulator_dev *rdev, bool enable)
1732{
1733 struct regulator_enable_gpio *pin = rdev->ena_pin;
1734
1735 if (!pin)
1736 return -EINVAL;
1737
1738 if (enable) {
1739 /* Enable GPIO at initial use */
1740 if (pin->enable_count == 0)
Russell King778b28b2014-06-29 17:55:54 +01001741 gpiod_set_value_cansleep(pin->gpiod,
1742 !pin->ena_gpio_invert);
Kim, Milo967cfb12013-02-18 06:50:48 +00001743
1744 pin->enable_count++;
1745 } else {
1746 if (pin->enable_count > 1) {
1747 pin->enable_count--;
1748 return 0;
1749 }
1750
1751 /* Disable GPIO if not used */
1752 if (pin->enable_count <= 1) {
Russell King778b28b2014-06-29 17:55:54 +01001753 gpiod_set_value_cansleep(pin->gpiod,
1754 pin->ena_gpio_invert);
Kim, Milo967cfb12013-02-18 06:50:48 +00001755 pin->enable_count = 0;
1756 }
1757 }
1758
1759 return 0;
1760}
1761
Guodong Xu79fd1142014-08-13 19:33:39 +08001762/**
1763 * _regulator_enable_delay - a delay helper function
1764 * @delay: time to delay in microseconds
1765 *
1766 * Delay for the requested amount of time as per the guidelines in:
1767 *
1768 * Documentation/timers/timers-howto.txt
1769 *
1770 * The assumption here is that regulators will never be enabled in
1771 * atomic context and therefore sleeping functions can be used.
1772 */
1773static void _regulator_enable_delay(unsigned int delay)
1774{
1775 unsigned int ms = delay / 1000;
1776 unsigned int us = delay % 1000;
1777
1778 if (ms > 0) {
1779 /*
1780 * For small enough values, handle super-millisecond
1781 * delays in the usleep_range() call below.
1782 */
1783 if (ms < 20)
1784 us += ms * 1000;
1785 else
1786 msleep(ms);
1787 }
1788
1789 /*
1790 * Give the scheduler some room to coalesce with any other
1791 * wakeup sources. For delays shorter than 10 us, don't even
1792 * bother setting up high-resolution timers and just busy-
1793 * loop.
1794 */
1795 if (us >= 10)
1796 usleep_range(us, us + 100);
1797 else
1798 udelay(us);
1799}
1800
Mark Brown5c5659d2012-06-27 13:21:26 +01001801static int _regulator_do_enable(struct regulator_dev *rdev)
1802{
1803 int ret, delay;
1804
1805 /* Query before enabling in case configuration dependent. */
1806 ret = _regulator_get_enable_time(rdev);
1807 if (ret >= 0) {
1808 delay = ret;
1809 } else {
1810 rdev_warn(rdev, "enable_time() failed: %d\n", ret);
1811 delay = 0;
1812 }
1813
1814 trace_regulator_enable(rdev_get_name(rdev));
1815
Guodong Xu871f5652014-08-13 19:33:40 +08001816 if (rdev->desc->off_on_delay) {
1817 /* if needed, keep a distance of off_on_delay from last time
1818 * this regulator was disabled.
1819 */
1820 unsigned long start_jiffy = jiffies;
1821 unsigned long intended, max_delay, remaining;
1822
1823 max_delay = usecs_to_jiffies(rdev->desc->off_on_delay);
1824 intended = rdev->last_off_jiffy + max_delay;
1825
1826 if (time_before(start_jiffy, intended)) {
1827 /* calc remaining jiffies to deal with one-time
1828 * timer wrapping.
1829 * in case of multiple timer wrapping, either it can be
1830 * detected by out-of-range remaining, or it cannot be
1831 * detected and we gets a panelty of
1832 * _regulator_enable_delay().
1833 */
1834 remaining = intended - start_jiffy;
1835 if (remaining <= max_delay)
1836 _regulator_enable_delay(
1837 jiffies_to_usecs(remaining));
1838 }
1839 }
1840
Kim, Milo967cfb12013-02-18 06:50:48 +00001841 if (rdev->ena_pin) {
1842 ret = regulator_ena_gpio_ctrl(rdev, true);
1843 if (ret < 0)
1844 return ret;
Mark Brown65f73502012-06-27 14:14:38 +01001845 rdev->ena_gpio_state = 1;
1846 } else if (rdev->desc->ops->enable) {
Mark Brown5c5659d2012-06-27 13:21:26 +01001847 ret = rdev->desc->ops->enable(rdev);
1848 if (ret < 0)
1849 return ret;
1850 } else {
1851 return -EINVAL;
1852 }
1853
1854 /* Allow the regulator to ramp; it would be useful to extend
1855 * this for bulk operations so that the regulators can ramp
1856 * together. */
1857 trace_regulator_enable_delay(rdev_get_name(rdev));
1858
Guodong Xu79fd1142014-08-13 19:33:39 +08001859 _regulator_enable_delay(delay);
Mark Brown5c5659d2012-06-27 13:21:26 +01001860
1861 trace_regulator_enable_complete(rdev_get_name(rdev));
1862
1863 return 0;
1864}
1865
Liam Girdwood414c70c2008-04-30 15:59:04 +01001866/* locks held by regulator_enable() */
1867static int _regulator_enable(struct regulator_dev *rdev)
1868{
Mark Brown5c5659d2012-06-27 13:21:26 +01001869 int ret;
Liam Girdwood414c70c2008-04-30 15:59:04 +01001870
Liam Girdwood414c70c2008-04-30 15:59:04 +01001871 /* check voltage and requested load before enabling */
Mark Brown9a2372f2009-08-03 18:49:57 +01001872 if (rdev->constraints &&
1873 (rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_DRMS))
1874 drms_uA_update(rdev);
Liam Girdwood414c70c2008-04-30 15:59:04 +01001875
Mark Brown9a2372f2009-08-03 18:49:57 +01001876 if (rdev->use_count == 0) {
1877 /* The regulator may on if it's not switchable or left on */
1878 ret = _regulator_is_enabled(rdev);
1879 if (ret == -EINVAL || ret == 0) {
1880 if (!_regulator_can_change_status(rdev))
1881 return -EPERM;
Liam Girdwood414c70c2008-04-30 15:59:04 +01001882
Mark Brown5c5659d2012-06-27 13:21:26 +01001883 ret = _regulator_do_enable(rdev);
Mark Brown31aae2b2009-12-21 12:21:52 +00001884 if (ret < 0)
1885 return ret;
1886
Linus Walleija7433cf2009-08-26 12:54:04 +02001887 } else if (ret < 0) {
Joe Perches5da84fd2010-11-30 05:53:48 -08001888 rdev_err(rdev, "is_enabled() failed: %d\n", ret);
Liam Girdwood414c70c2008-04-30 15:59:04 +01001889 return ret;
1890 }
Linus Walleija7433cf2009-08-26 12:54:04 +02001891 /* Fallthrough on positive return values - already enabled */
Liam Girdwood414c70c2008-04-30 15:59:04 +01001892 }
1893
Mark Brown9a2372f2009-08-03 18:49:57 +01001894 rdev->use_count++;
1895
1896 return 0;
Liam Girdwood414c70c2008-04-30 15:59:04 +01001897}
1898
1899/**
1900 * regulator_enable - enable regulator output
1901 * @regulator: regulator source
1902 *
Mark Browncf7bbcd2008-12-31 12:52:43 +00001903 * Request that the regulator be enabled with the regulator output at
1904 * the predefined voltage or current value. Calls to regulator_enable()
1905 * must be balanced with calls to regulator_disable().
1906 *
Liam Girdwood414c70c2008-04-30 15:59:04 +01001907 * NOTE: the output value can be set by other drivers, boot loader or may be
Mark Browncf7bbcd2008-12-31 12:52:43 +00001908 * hardwired in the regulator.
Liam Girdwood414c70c2008-04-30 15:59:04 +01001909 */
1910int regulator_enable(struct regulator *regulator)
1911{
David Brownell412aec62008-11-16 11:44:46 -08001912 struct regulator_dev *rdev = regulator->rdev;
1913 int ret = 0;
Liam Girdwood414c70c2008-04-30 15:59:04 +01001914
Mark Brown6492bc12012-04-19 13:19:07 +01001915 if (regulator->always_on)
1916 return 0;
1917
Mark Brown3801b862011-06-09 16:22:22 +01001918 if (rdev->supply) {
1919 ret = regulator_enable(rdev->supply);
1920 if (ret != 0)
1921 return ret;
1922 }
1923
David Brownell412aec62008-11-16 11:44:46 -08001924 mutex_lock(&rdev->mutex);
David Brownellcd94b502009-03-11 16:43:34 -08001925 ret = _regulator_enable(rdev);
David Brownell412aec62008-11-16 11:44:46 -08001926 mutex_unlock(&rdev->mutex);
Mark Brown3801b862011-06-09 16:22:22 +01001927
Heiko Stübnerd1685e42011-10-14 18:00:29 +02001928 if (ret != 0 && rdev->supply)
Mark Brown3801b862011-06-09 16:22:22 +01001929 regulator_disable(rdev->supply);
1930
Liam Girdwood414c70c2008-04-30 15:59:04 +01001931 return ret;
1932}
1933EXPORT_SYMBOL_GPL(regulator_enable);
1934
Mark Brown5c5659d2012-06-27 13:21:26 +01001935static int _regulator_do_disable(struct regulator_dev *rdev)
1936{
1937 int ret;
1938
1939 trace_regulator_disable(rdev_get_name(rdev));
1940
Kim, Milo967cfb12013-02-18 06:50:48 +00001941 if (rdev->ena_pin) {
1942 ret = regulator_ena_gpio_ctrl(rdev, false);
1943 if (ret < 0)
1944 return ret;
Mark Brown5c5659d2012-06-27 13:21:26 +01001945 rdev->ena_gpio_state = 0;
1946
1947 } else if (rdev->desc->ops->disable) {
1948 ret = rdev->desc->ops->disable(rdev);
1949 if (ret != 0)
1950 return ret;
1951 }
1952
Guodong Xu871f5652014-08-13 19:33:40 +08001953 /* cares about last_off_jiffy only if off_on_delay is required by
1954 * device.
1955 */
1956 if (rdev->desc->off_on_delay)
1957 rdev->last_off_jiffy = jiffies;
1958
Mark Brown5c5659d2012-06-27 13:21:26 +01001959 trace_regulator_disable_complete(rdev_get_name(rdev));
1960
Mark Brown5c5659d2012-06-27 13:21:26 +01001961 return 0;
1962}
1963
Liam Girdwood414c70c2008-04-30 15:59:04 +01001964/* locks held by regulator_disable() */
Mark Brown3801b862011-06-09 16:22:22 +01001965static int _regulator_disable(struct regulator_dev *rdev)
Liam Girdwood414c70c2008-04-30 15:59:04 +01001966{
1967 int ret = 0;
1968
David Brownellcd94b502009-03-11 16:43:34 -08001969 if (WARN(rdev->use_count <= 0,
Joe Perches43e7ee32010-12-06 14:05:19 -08001970 "unbalanced disables for %s\n", rdev_get_name(rdev)))
David Brownellcd94b502009-03-11 16:43:34 -08001971 return -EIO;
1972
Liam Girdwood414c70c2008-04-30 15:59:04 +01001973 /* are we the last user and permitted to disable ? */
Mark Brown60ef66f2009-10-13 13:06:50 +01001974 if (rdev->use_count == 1 &&
1975 (rdev->constraints && !rdev->constraints->always_on)) {
Liam Girdwood414c70c2008-04-30 15:59:04 +01001976
1977 /* we are last user */
Mark Brown5c5659d2012-06-27 13:21:26 +01001978 if (_regulator_can_change_status(rdev)) {
Richard Fitzgeralda1c8a552014-11-24 14:10:52 +00001979 ret = _notifier_call_chain(rdev,
1980 REGULATOR_EVENT_PRE_DISABLE,
1981 NULL);
1982 if (ret & NOTIFY_STOP_MASK)
1983 return -EINVAL;
1984
Mark Brown5c5659d2012-06-27 13:21:26 +01001985 ret = _regulator_do_disable(rdev);
Liam Girdwood414c70c2008-04-30 15:59:04 +01001986 if (ret < 0) {
Joe Perches5da84fd2010-11-30 05:53:48 -08001987 rdev_err(rdev, "failed to disable\n");
Richard Fitzgeralda1c8a552014-11-24 14:10:52 +00001988 _notifier_call_chain(rdev,
1989 REGULATOR_EVENT_ABORT_DISABLE,
1990 NULL);
Liam Girdwood414c70c2008-04-30 15:59:04 +01001991 return ret;
1992 }
Markus Pargmann66fda752014-02-20 17:36:04 +01001993 _notifier_call_chain(rdev, REGULATOR_EVENT_DISABLE,
1994 NULL);
Liam Girdwood414c70c2008-04-30 15:59:04 +01001995 }
1996
Liam Girdwood414c70c2008-04-30 15:59:04 +01001997 rdev->use_count = 0;
1998 } else if (rdev->use_count > 1) {
1999
2000 if (rdev->constraints &&
2001 (rdev->constraints->valid_ops_mask &
2002 REGULATOR_CHANGE_DRMS))
2003 drms_uA_update(rdev);
2004
2005 rdev->use_count--;
2006 }
Mark Brown3801b862011-06-09 16:22:22 +01002007
Liam Girdwood414c70c2008-04-30 15:59:04 +01002008 return ret;
2009}
2010
2011/**
2012 * regulator_disable - disable regulator output
2013 * @regulator: regulator source
2014 *
Mark Browncf7bbcd2008-12-31 12:52:43 +00002015 * Disable the regulator output voltage or current. Calls to
2016 * regulator_enable() must be balanced with calls to
2017 * regulator_disable().
Mark Brown69279fb2008-12-31 12:52:41 +00002018 *
Liam Girdwood414c70c2008-04-30 15:59:04 +01002019 * NOTE: this will only disable the regulator output if no other consumer
Mark Browncf7bbcd2008-12-31 12:52:43 +00002020 * devices have it enabled, the regulator device supports disabling and
2021 * machine constraints permit this operation.
Liam Girdwood414c70c2008-04-30 15:59:04 +01002022 */
2023int regulator_disable(struct regulator *regulator)
2024{
David Brownell412aec62008-11-16 11:44:46 -08002025 struct regulator_dev *rdev = regulator->rdev;
2026 int ret = 0;
Liam Girdwood414c70c2008-04-30 15:59:04 +01002027
Mark Brown6492bc12012-04-19 13:19:07 +01002028 if (regulator->always_on)
2029 return 0;
2030
David Brownell412aec62008-11-16 11:44:46 -08002031 mutex_lock(&rdev->mutex);
Mark Brown3801b862011-06-09 16:22:22 +01002032 ret = _regulator_disable(rdev);
David Brownell412aec62008-11-16 11:44:46 -08002033 mutex_unlock(&rdev->mutex);
Jeffrey Carlyle8cbf8112010-10-08 14:49:19 -05002034
Mark Brown3801b862011-06-09 16:22:22 +01002035 if (ret == 0 && rdev->supply)
2036 regulator_disable(rdev->supply);
Jeffrey Carlyle8cbf8112010-10-08 14:49:19 -05002037
Liam Girdwood414c70c2008-04-30 15:59:04 +01002038 return ret;
2039}
2040EXPORT_SYMBOL_GPL(regulator_disable);
2041
2042/* locks held by regulator_force_disable() */
Mark Brown3801b862011-06-09 16:22:22 +01002043static int _regulator_force_disable(struct regulator_dev *rdev)
Liam Girdwood414c70c2008-04-30 15:59:04 +01002044{
2045 int ret = 0;
2046
Richard Fitzgeralda1c8a552014-11-24 14:10:52 +00002047 ret = _notifier_call_chain(rdev, REGULATOR_EVENT_FORCE_DISABLE |
2048 REGULATOR_EVENT_PRE_DISABLE, NULL);
2049 if (ret & NOTIFY_STOP_MASK)
2050 return -EINVAL;
2051
Markus Pargmann66fda752014-02-20 17:36:04 +01002052 ret = _regulator_do_disable(rdev);
2053 if (ret < 0) {
2054 rdev_err(rdev, "failed to force disable\n");
Richard Fitzgeralda1c8a552014-11-24 14:10:52 +00002055 _notifier_call_chain(rdev, REGULATOR_EVENT_FORCE_DISABLE |
2056 REGULATOR_EVENT_ABORT_DISABLE, NULL);
Markus Pargmann66fda752014-02-20 17:36:04 +01002057 return ret;
Liam Girdwood414c70c2008-04-30 15:59:04 +01002058 }
2059
Markus Pargmann66fda752014-02-20 17:36:04 +01002060 _notifier_call_chain(rdev, REGULATOR_EVENT_FORCE_DISABLE |
2061 REGULATOR_EVENT_DISABLE, NULL);
2062
2063 return 0;
Liam Girdwood414c70c2008-04-30 15:59:04 +01002064}
2065
2066/**
2067 * regulator_force_disable - force disable regulator output
2068 * @regulator: regulator source
2069 *
2070 * Forcibly disable the regulator output voltage or current.
2071 * NOTE: this *will* disable the regulator output even if other consumer
2072 * devices have it enabled. This should be used for situations when device
2073 * damage will likely occur if the regulator is not disabled (e.g. over temp).
2074 */
2075int regulator_force_disable(struct regulator *regulator)
2076{
Mark Brown82d15832011-05-09 11:41:02 +02002077 struct regulator_dev *rdev = regulator->rdev;
Liam Girdwood414c70c2008-04-30 15:59:04 +01002078 int ret;
2079
Mark Brown82d15832011-05-09 11:41:02 +02002080 mutex_lock(&rdev->mutex);
Liam Girdwood414c70c2008-04-30 15:59:04 +01002081 regulator->uA_load = 0;
Mark Brown3801b862011-06-09 16:22:22 +01002082 ret = _regulator_force_disable(regulator->rdev);
Mark Brown82d15832011-05-09 11:41:02 +02002083 mutex_unlock(&rdev->mutex);
Jeffrey Carlyle8cbf8112010-10-08 14:49:19 -05002084
Mark Brown3801b862011-06-09 16:22:22 +01002085 if (rdev->supply)
2086 while (rdev->open_count--)
2087 regulator_disable(rdev->supply);
Jeffrey Carlyle8cbf8112010-10-08 14:49:19 -05002088
Liam Girdwood414c70c2008-04-30 15:59:04 +01002089 return ret;
2090}
2091EXPORT_SYMBOL_GPL(regulator_force_disable);
2092
Mark Brownda07ecd2011-09-11 09:53:50 +01002093static void regulator_disable_work(struct work_struct *work)
2094{
2095 struct regulator_dev *rdev = container_of(work, struct regulator_dev,
2096 disable_work.work);
2097 int count, i, ret;
2098
2099 mutex_lock(&rdev->mutex);
2100
2101 BUG_ON(!rdev->deferred_disables);
2102
2103 count = rdev->deferred_disables;
2104 rdev->deferred_disables = 0;
2105
2106 for (i = 0; i < count; i++) {
2107 ret = _regulator_disable(rdev);
2108 if (ret != 0)
2109 rdev_err(rdev, "Deferred disable failed: %d\n", ret);
2110 }
2111
2112 mutex_unlock(&rdev->mutex);
2113
2114 if (rdev->supply) {
2115 for (i = 0; i < count; i++) {
2116 ret = regulator_disable(rdev->supply);
2117 if (ret != 0) {
2118 rdev_err(rdev,
2119 "Supply disable failed: %d\n", ret);
2120 }
2121 }
2122 }
2123}
2124
2125/**
2126 * regulator_disable_deferred - disable regulator output with delay
2127 * @regulator: regulator source
2128 * @ms: miliseconds until the regulator is disabled
2129 *
2130 * Execute regulator_disable() on the regulator after a delay. This
2131 * is intended for use with devices that require some time to quiesce.
2132 *
2133 * NOTE: this will only disable the regulator output if no other consumer
2134 * devices have it enabled, the regulator device supports disabling and
2135 * machine constraints permit this operation.
2136 */
2137int regulator_disable_deferred(struct regulator *regulator, int ms)
2138{
2139 struct regulator_dev *rdev = regulator->rdev;
Mark Brownaa598022011-10-03 22:42:43 +01002140 int ret;
Mark Brownda07ecd2011-09-11 09:53:50 +01002141
Mark Brown6492bc12012-04-19 13:19:07 +01002142 if (regulator->always_on)
2143 return 0;
2144
Mark Brown2b5a24a2012-09-07 11:00:53 +08002145 if (!ms)
2146 return regulator_disable(regulator);
2147
Mark Brownda07ecd2011-09-11 09:53:50 +01002148 mutex_lock(&rdev->mutex);
2149 rdev->deferred_disables++;
2150 mutex_unlock(&rdev->mutex);
2151
Mark Brown070260f2013-07-18 11:52:04 +01002152 ret = queue_delayed_work(system_power_efficient_wq,
2153 &rdev->disable_work,
2154 msecs_to_jiffies(ms));
Mark Brownaa598022011-10-03 22:42:43 +01002155 if (ret < 0)
2156 return ret;
2157 else
2158 return 0;
Mark Brownda07ecd2011-09-11 09:53:50 +01002159}
2160EXPORT_SYMBOL_GPL(regulator_disable_deferred);
2161
Liam Girdwood414c70c2008-04-30 15:59:04 +01002162static int _regulator_is_enabled(struct regulator_dev *rdev)
2163{
Mark Brown65f73502012-06-27 14:14:38 +01002164 /* A GPIO control always takes precedence */
Kim, Milo7b74d142013-02-18 06:50:55 +00002165 if (rdev->ena_pin)
Mark Brown65f73502012-06-27 14:14:38 +01002166 return rdev->ena_gpio_state;
2167
Mark Brown9a7f6a42010-02-11 17:22:45 +00002168 /* If we don't know then assume that the regulator is always on */
Mark Brown93325462009-08-03 18:49:56 +01002169 if (!rdev->desc->ops->is_enabled)
Mark Brown9a7f6a42010-02-11 17:22:45 +00002170 return 1;
Liam Girdwood414c70c2008-04-30 15:59:04 +01002171
Mark Brown93325462009-08-03 18:49:56 +01002172 return rdev->desc->ops->is_enabled(rdev);
Liam Girdwood414c70c2008-04-30 15:59:04 +01002173}
2174
2175/**
2176 * regulator_is_enabled - is the regulator output enabled
2177 * @regulator: regulator source
2178 *
David Brownell412aec62008-11-16 11:44:46 -08002179 * Returns positive if the regulator driver backing the source/client
2180 * has requested that the device be enabled, zero if it hasn't, else a
2181 * negative errno code.
2182 *
2183 * Note that the device backing this regulator handle can have multiple
2184 * users, so it might be enabled even if regulator_enable() was never
2185 * called for this particular source.
Liam Girdwood414c70c2008-04-30 15:59:04 +01002186 */
2187int regulator_is_enabled(struct regulator *regulator)
2188{
Mark Brown93325462009-08-03 18:49:56 +01002189 int ret;
2190
Mark Brown6492bc12012-04-19 13:19:07 +01002191 if (regulator->always_on)
2192 return 1;
2193
Mark Brown93325462009-08-03 18:49:56 +01002194 mutex_lock(&regulator->rdev->mutex);
2195 ret = _regulator_is_enabled(regulator->rdev);
2196 mutex_unlock(&regulator->rdev->mutex);
2197
2198 return ret;
Liam Girdwood414c70c2008-04-30 15:59:04 +01002199}
2200EXPORT_SYMBOL_GPL(regulator_is_enabled);
2201
2202/**
Marek Szyprowskid1e7de32012-12-04 15:01:01 +01002203 * regulator_can_change_voltage - check if regulator can change voltage
2204 * @regulator: regulator source
2205 *
2206 * Returns positive if the regulator driver backing the source/client
Masanari Iidae2278672014-02-18 22:54:36 +09002207 * can change its voltage, false otherwise. Useful for detecting fixed
Marek Szyprowskid1e7de32012-12-04 15:01:01 +01002208 * or dummy regulators and disabling voltage change logic in the client
2209 * driver.
2210 */
2211int regulator_can_change_voltage(struct regulator *regulator)
2212{
2213 struct regulator_dev *rdev = regulator->rdev;
2214
2215 if (rdev->constraints &&
Axel Lin19280e42012-12-12 09:22:46 +08002216 (rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) {
2217 if (rdev->desc->n_voltages - rdev->desc->linear_min_sel > 1)
2218 return 1;
2219
2220 if (rdev->desc->continuous_voltage_range &&
2221 rdev->constraints->min_uV && rdev->constraints->max_uV &&
2222 rdev->constraints->min_uV != rdev->constraints->max_uV)
2223 return 1;
2224 }
Marek Szyprowskid1e7de32012-12-04 15:01:01 +01002225
2226 return 0;
2227}
2228EXPORT_SYMBOL_GPL(regulator_can_change_voltage);
2229
2230/**
David Brownell4367cfd2009-02-26 11:48:36 -08002231 * regulator_count_voltages - count regulator_list_voltage() selectors
2232 * @regulator: regulator source
2233 *
2234 * Returns number of selectors, or negative errno. Selectors are
2235 * numbered starting at zero, and typically correspond to bitfields
2236 * in hardware registers.
2237 */
2238int regulator_count_voltages(struct regulator *regulator)
2239{
2240 struct regulator_dev *rdev = regulator->rdev;
2241
Javier Martinez Canillas26988ef2014-07-29 18:28:56 +02002242 if (rdev->desc->n_voltages)
2243 return rdev->desc->n_voltages;
2244
2245 if (!rdev->supply)
2246 return -EINVAL;
2247
2248 return regulator_count_voltages(rdev->supply);
David Brownell4367cfd2009-02-26 11:48:36 -08002249}
2250EXPORT_SYMBOL_GPL(regulator_count_voltages);
2251
2252/**
2253 * regulator_list_voltage - enumerate supported voltages
2254 * @regulator: regulator source
2255 * @selector: identify voltage to list
2256 * Context: can sleep
2257 *
2258 * Returns a voltage that can be passed to @regulator_set_voltage(),
Thomas Weber88393162010-03-16 11:47:56 +01002259 * zero if this selector code can't be used on this system, or a
David Brownell4367cfd2009-02-26 11:48:36 -08002260 * negative errno.
2261 */
2262int regulator_list_voltage(struct regulator *regulator, unsigned selector)
2263{
Guodong Xu272e2312014-08-13 19:33:38 +08002264 struct regulator_dev *rdev = regulator->rdev;
2265 const struct regulator_ops *ops = rdev->desc->ops;
2266 int ret;
David Brownell4367cfd2009-02-26 11:48:36 -08002267
Guennadi Liakhovetskif4460432013-11-13 12:33:00 +01002268 if (rdev->desc->fixed_uV && rdev->desc->n_voltages == 1 && !selector)
2269 return rdev->desc->fixed_uV;
2270
Javier Martinez Canillas26988ef2014-07-29 18:28:56 +02002271 if (ops->list_voltage) {
2272 if (selector >= rdev->desc->n_voltages)
2273 return -EINVAL;
2274 mutex_lock(&rdev->mutex);
2275 ret = ops->list_voltage(rdev, selector);
2276 mutex_unlock(&rdev->mutex);
2277 } else if (rdev->supply) {
2278 ret = regulator_list_voltage(rdev->supply, selector);
2279 } else {
David Brownell4367cfd2009-02-26 11:48:36 -08002280 return -EINVAL;
Javier Martinez Canillas26988ef2014-07-29 18:28:56 +02002281 }
David Brownell4367cfd2009-02-26 11:48:36 -08002282
2283 if (ret > 0) {
2284 if (ret < rdev->constraints->min_uV)
2285 ret = 0;
2286 else if (ret > rdev->constraints->max_uV)
2287 ret = 0;
2288 }
2289
2290 return ret;
2291}
2292EXPORT_SYMBOL_GPL(regulator_list_voltage);
2293
2294/**
Tuomas Tynkkynen04eca282014-07-21 18:38:48 +03002295 * regulator_get_regmap - get the regulator's register map
2296 * @regulator: regulator source
2297 *
2298 * Returns the register map for the given regulator, or an ERR_PTR value
2299 * if the regulator doesn't use regmap.
2300 */
2301struct regmap *regulator_get_regmap(struct regulator *regulator)
2302{
2303 struct regmap *map = regulator->rdev->regmap;
2304
2305 return map ? map : ERR_PTR(-EOPNOTSUPP);
2306}
2307
2308/**
2309 * regulator_get_hardware_vsel_register - get the HW voltage selector register
2310 * @regulator: regulator source
2311 * @vsel_reg: voltage selector register, output parameter
2312 * @vsel_mask: mask for voltage selector bitfield, output parameter
2313 *
2314 * Returns the hardware register offset and bitmask used for setting the
2315 * regulator voltage. This might be useful when configuring voltage-scaling
2316 * hardware or firmware that can make I2C requests behind the kernel's back,
2317 * for example.
2318 *
2319 * On success, the output parameters @vsel_reg and @vsel_mask are filled in
2320 * and 0 is returned, otherwise a negative errno is returned.
2321 */
2322int regulator_get_hardware_vsel_register(struct regulator *regulator,
2323 unsigned *vsel_reg,
2324 unsigned *vsel_mask)
2325{
Guodong Xu39f54602014-08-19 18:07:41 +08002326 struct regulator_dev *rdev = regulator->rdev;
2327 const struct regulator_ops *ops = rdev->desc->ops;
Tuomas Tynkkynen04eca282014-07-21 18:38:48 +03002328
2329 if (ops->set_voltage_sel != regulator_set_voltage_sel_regmap)
2330 return -EOPNOTSUPP;
2331
2332 *vsel_reg = rdev->desc->vsel_reg;
2333 *vsel_mask = rdev->desc->vsel_mask;
2334
2335 return 0;
2336}
2337EXPORT_SYMBOL_GPL(regulator_get_hardware_vsel_register);
2338
2339/**
2340 * regulator_list_hardware_vsel - get the HW-specific register value for a selector
2341 * @regulator: regulator source
2342 * @selector: identify voltage to list
2343 *
2344 * Converts the selector to a hardware-specific voltage selector that can be
2345 * directly written to the regulator registers. The address of the voltage
2346 * register can be determined by calling @regulator_get_hardware_vsel_register.
2347 *
2348 * On error a negative errno is returned.
2349 */
2350int regulator_list_hardware_vsel(struct regulator *regulator,
2351 unsigned selector)
2352{
Guodong Xu39f54602014-08-19 18:07:41 +08002353 struct regulator_dev *rdev = regulator->rdev;
2354 const struct regulator_ops *ops = rdev->desc->ops;
Tuomas Tynkkynen04eca282014-07-21 18:38:48 +03002355
2356 if (selector >= rdev->desc->n_voltages)
2357 return -EINVAL;
2358 if (ops->set_voltage_sel != regulator_set_voltage_sel_regmap)
2359 return -EOPNOTSUPP;
2360
2361 return selector;
2362}
2363EXPORT_SYMBOL_GPL(regulator_list_hardware_vsel);
2364
2365/**
Paul Walmsley2a668a82013-06-07 08:06:56 +00002366 * regulator_get_linear_step - return the voltage step size between VSEL values
2367 * @regulator: regulator source
2368 *
2369 * Returns the voltage step size between VSEL values for linear
2370 * regulators, or return 0 if the regulator isn't a linear regulator.
2371 */
2372unsigned int regulator_get_linear_step(struct regulator *regulator)
2373{
2374 struct regulator_dev *rdev = regulator->rdev;
2375
2376 return rdev->desc->uV_step;
2377}
2378EXPORT_SYMBOL_GPL(regulator_get_linear_step);
2379
2380/**
Mark Browna7a1ad92009-07-21 16:00:24 +01002381 * regulator_is_supported_voltage - check if a voltage range can be supported
2382 *
2383 * @regulator: Regulator to check.
2384 * @min_uV: Minimum required voltage in uV.
2385 * @max_uV: Maximum required voltage in uV.
2386 *
2387 * Returns a boolean or a negative error code.
2388 */
2389int regulator_is_supported_voltage(struct regulator *regulator,
2390 int min_uV, int max_uV)
2391{
Mark Brownc5f39392012-07-02 15:00:18 +01002392 struct regulator_dev *rdev = regulator->rdev;
Mark Browna7a1ad92009-07-21 16:00:24 +01002393 int i, voltages, ret;
2394
Mark Brownc5f39392012-07-02 15:00:18 +01002395 /* If we can't change voltage check the current voltage */
2396 if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) {
2397 ret = regulator_get_voltage(regulator);
2398 if (ret >= 0)
Jingoo Han0d25d092014-01-08 10:02:16 +09002399 return min_uV <= ret && ret <= max_uV;
Mark Brownc5f39392012-07-02 15:00:18 +01002400 else
2401 return ret;
2402 }
2403
Pawel Mollbd7a2b62012-09-24 18:56:53 +01002404 /* Any voltage within constrains range is fine? */
2405 if (rdev->desc->continuous_voltage_range)
2406 return min_uV >= rdev->constraints->min_uV &&
2407 max_uV <= rdev->constraints->max_uV;
2408
Mark Browna7a1ad92009-07-21 16:00:24 +01002409 ret = regulator_count_voltages(regulator);
2410 if (ret < 0)
2411 return ret;
2412 voltages = ret;
2413
2414 for (i = 0; i < voltages; i++) {
2415 ret = regulator_list_voltage(regulator, i);
2416
2417 if (ret >= min_uV && ret <= max_uV)
2418 return 1;
2419 }
2420
2421 return 0;
2422}
Mark Browna398eaa2011-12-28 12:48:45 +00002423EXPORT_SYMBOL_GPL(regulator_is_supported_voltage);
Mark Browna7a1ad92009-07-21 16:00:24 +01002424
Heiko Stübner71795692014-08-28 12:36:04 -07002425static int _regulator_call_set_voltage(struct regulator_dev *rdev,
2426 int min_uV, int max_uV,
2427 unsigned *selector)
2428{
2429 struct pre_voltage_change_data data;
2430 int ret;
2431
2432 data.old_uV = _regulator_get_voltage(rdev);
2433 data.min_uV = min_uV;
2434 data.max_uV = max_uV;
2435 ret = _notifier_call_chain(rdev, REGULATOR_EVENT_PRE_VOLTAGE_CHANGE,
2436 &data);
2437 if (ret & NOTIFY_STOP_MASK)
2438 return -EINVAL;
2439
2440 ret = rdev->desc->ops->set_voltage(rdev, min_uV, max_uV, selector);
2441 if (ret >= 0)
2442 return ret;
2443
2444 _notifier_call_chain(rdev, REGULATOR_EVENT_ABORT_VOLTAGE_CHANGE,
2445 (void *)data.old_uV);
2446
2447 return ret;
2448}
2449
2450static int _regulator_call_set_voltage_sel(struct regulator_dev *rdev,
2451 int uV, unsigned selector)
2452{
2453 struct pre_voltage_change_data data;
2454 int ret;
2455
2456 data.old_uV = _regulator_get_voltage(rdev);
2457 data.min_uV = uV;
2458 data.max_uV = uV;
2459 ret = _notifier_call_chain(rdev, REGULATOR_EVENT_PRE_VOLTAGE_CHANGE,
2460 &data);
2461 if (ret & NOTIFY_STOP_MASK)
2462 return -EINVAL;
2463
2464 ret = rdev->desc->ops->set_voltage_sel(rdev, selector);
2465 if (ret >= 0)
2466 return ret;
2467
2468 _notifier_call_chain(rdev, REGULATOR_EVENT_ABORT_VOLTAGE_CHANGE,
2469 (void *)data.old_uV);
2470
2471 return ret;
2472}
2473
Mark Brown75790252010-12-12 14:25:50 +00002474static int _regulator_do_set_voltage(struct regulator_dev *rdev,
2475 int min_uV, int max_uV)
2476{
2477 int ret;
Linus Walleij77af1b2642011-03-17 13:24:36 +01002478 int delay = 0;
Mark Browne113d792012-06-26 10:57:51 +01002479 int best_val = 0;
Mark Brown75790252010-12-12 14:25:50 +00002480 unsigned int selector;
Axel Lineba41a52012-04-04 10:32:10 +08002481 int old_selector = -1;
Mark Brown75790252010-12-12 14:25:50 +00002482
2483 trace_regulator_set_voltage(rdev_get_name(rdev), min_uV, max_uV);
2484
Mark Brownbf5892a2011-05-08 22:13:37 +01002485 min_uV += rdev->constraints->uV_offset;
2486 max_uV += rdev->constraints->uV_offset;
2487
Axel Lineba41a52012-04-04 10:32:10 +08002488 /*
2489 * If we can't obtain the old selector there is not enough
2490 * info to call set_voltage_time_sel().
2491 */
Axel Lin8b7485e2012-05-21 09:37:52 +08002492 if (_regulator_is_enabled(rdev) &&
2493 rdev->desc->ops->set_voltage_time_sel &&
Axel Lineba41a52012-04-04 10:32:10 +08002494 rdev->desc->ops->get_voltage_sel) {
2495 old_selector = rdev->desc->ops->get_voltage_sel(rdev);
2496 if (old_selector < 0)
2497 return old_selector;
2498 }
2499
Mark Brown75790252010-12-12 14:25:50 +00002500 if (rdev->desc->ops->set_voltage) {
Heiko Stübner71795692014-08-28 12:36:04 -07002501 ret = _regulator_call_set_voltage(rdev, min_uV, max_uV,
2502 &selector);
Mark Browne113d792012-06-26 10:57:51 +01002503
2504 if (ret >= 0) {
2505 if (rdev->desc->ops->list_voltage)
2506 best_val = rdev->desc->ops->list_voltage(rdev,
2507 selector);
2508 else
2509 best_val = _regulator_get_voltage(rdev);
2510 }
2511
Mark Browne8eef822010-12-12 14:36:17 +00002512 } else if (rdev->desc->ops->set_voltage_sel) {
Axel Lin9152c362012-06-04 09:41:38 +08002513 if (rdev->desc->ops->map_voltage) {
Mark Browne843fc42012-05-09 21:16:06 +01002514 ret = rdev->desc->ops->map_voltage(rdev, min_uV,
2515 max_uV);
Axel Lin9152c362012-06-04 09:41:38 +08002516 } else {
2517 if (rdev->desc->ops->list_voltage ==
2518 regulator_list_voltage_linear)
2519 ret = regulator_map_voltage_linear(rdev,
2520 min_uV, max_uV);
Axel Lin36698622014-05-24 11:10:43 +08002521 else if (rdev->desc->ops->list_voltage ==
2522 regulator_list_voltage_linear_range)
2523 ret = regulator_map_voltage_linear_range(rdev,
2524 min_uV, max_uV);
Axel Lin9152c362012-06-04 09:41:38 +08002525 else
2526 ret = regulator_map_voltage_iterate(rdev,
2527 min_uV, max_uV);
2528 }
Mark Browne8eef822010-12-12 14:36:17 +00002529
Mark Browne843fc42012-05-09 21:16:06 +01002530 if (ret >= 0) {
Mark Browne113d792012-06-26 10:57:51 +01002531 best_val = rdev->desc->ops->list_voltage(rdev, ret);
2532 if (min_uV <= best_val && max_uV >= best_val) {
2533 selector = ret;
Axel Linc66a5662013-02-06 11:09:48 +08002534 if (old_selector == selector)
2535 ret = 0;
2536 else
Heiko Stübner71795692014-08-28 12:36:04 -07002537 ret = _regulator_call_set_voltage_sel(
2538 rdev, best_val, selector);
Mark Browne113d792012-06-26 10:57:51 +01002539 } else {
2540 ret = -EINVAL;
2541 }
Mark Browne8eef822010-12-12 14:36:17 +00002542 }
Mark Brown75790252010-12-12 14:25:50 +00002543 } else {
2544 ret = -EINVAL;
2545 }
2546
Axel Lineba41a52012-04-04 10:32:10 +08002547 /* Call set_voltage_time_sel if successfully obtained old_selector */
Yadwinder Singh Brar5b175952013-06-29 18:21:19 +05302548 if (ret == 0 && !rdev->constraints->ramp_disable && old_selector >= 0
2549 && old_selector != selector) {
Axel Lineba41a52012-04-04 10:32:10 +08002550
2551 delay = rdev->desc->ops->set_voltage_time_sel(rdev,
2552 old_selector, selector);
2553 if (delay < 0) {
2554 rdev_warn(rdev, "set_voltage_time_sel() failed: %d\n",
2555 delay);
2556 delay = 0;
2557 }
Axel Lineba41a52012-04-04 10:32:10 +08002558
Philip Rakity8b96de32012-06-14 15:07:56 -07002559 /* Insert any necessary delays */
2560 if (delay >= 1000) {
2561 mdelay(delay / 1000);
2562 udelay(delay % 1000);
2563 } else if (delay) {
2564 udelay(delay);
2565 }
Linus Walleij77af1b2642011-03-17 13:24:36 +01002566 }
2567
Axel Lin2f6c7972012-08-06 23:44:19 +08002568 if (ret == 0 && best_val >= 0) {
2569 unsigned long data = best_val;
2570
Mark Brownded06a52010-12-16 13:59:10 +00002571 _notifier_call_chain(rdev, REGULATOR_EVENT_VOLTAGE_CHANGE,
Axel Lin2f6c7972012-08-06 23:44:19 +08002572 (void *)data);
2573 }
Mark Brownded06a52010-12-16 13:59:10 +00002574
Axel Lineba41a52012-04-04 10:32:10 +08002575 trace_regulator_set_voltage_complete(rdev_get_name(rdev), best_val);
Mark Brown75790252010-12-12 14:25:50 +00002576
2577 return ret;
2578}
2579
Mark Browna7a1ad92009-07-21 16:00:24 +01002580/**
Liam Girdwood414c70c2008-04-30 15:59:04 +01002581 * regulator_set_voltage - set regulator output voltage
2582 * @regulator: regulator source
2583 * @min_uV: Minimum required voltage in uV
2584 * @max_uV: Maximum acceptable voltage in uV
2585 *
2586 * Sets a voltage regulator to the desired output voltage. This can be set
2587 * during any regulator state. IOW, regulator can be disabled or enabled.
2588 *
2589 * If the regulator is enabled then the voltage will change to the new value
2590 * immediately otherwise if the regulator is disabled the regulator will
2591 * output at the new voltage when enabled.
2592 *
2593 * NOTE: If the regulator is shared between several devices then the lowest
2594 * request voltage that meets the system constraints will be used.
Mark Brown69279fb2008-12-31 12:52:41 +00002595 * Regulator system constraints must be set for this regulator before
Liam Girdwood414c70c2008-04-30 15:59:04 +01002596 * calling this function otherwise this call will fail.
2597 */
2598int regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV)
2599{
2600 struct regulator_dev *rdev = regulator->rdev;
Mark Brown95a3c232010-12-16 15:49:37 +00002601 int ret = 0;
Paolo Pisati92d7a552012-12-13 10:13:00 +01002602 int old_min_uV, old_max_uV;
Bjorn Anderssonc00dc352014-02-05 12:30:26 -08002603 int current_uV;
Liam Girdwood414c70c2008-04-30 15:59:04 +01002604
2605 mutex_lock(&rdev->mutex);
2606
Mark Brown95a3c232010-12-16 15:49:37 +00002607 /* If we're setting the same range as last time the change
2608 * should be a noop (some cpufreq implementations use the same
2609 * voltage for multiple frequencies, for example).
2610 */
2611 if (regulator->min_uV == min_uV && regulator->max_uV == max_uV)
2612 goto out;
2613
Bjorn Anderssonc00dc352014-02-05 12:30:26 -08002614 /* If we're trying to set a range that overlaps the current voltage,
2615 * return succesfully even though the regulator does not support
2616 * changing the voltage.
2617 */
2618 if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) {
2619 current_uV = _regulator_get_voltage(rdev);
2620 if (min_uV <= current_uV && current_uV <= max_uV) {
2621 regulator->min_uV = min_uV;
2622 regulator->max_uV = max_uV;
2623 goto out;
2624 }
2625 }
2626
Liam Girdwood414c70c2008-04-30 15:59:04 +01002627 /* sanity check */
Mark Browne8eef822010-12-12 14:36:17 +00002628 if (!rdev->desc->ops->set_voltage &&
2629 !rdev->desc->ops->set_voltage_sel) {
Liam Girdwood414c70c2008-04-30 15:59:04 +01002630 ret = -EINVAL;
2631 goto out;
2632 }
2633
2634 /* constraints check */
2635 ret = regulator_check_voltage(rdev, &min_uV, &max_uV);
2636 if (ret < 0)
2637 goto out;
Jingoo Han0d25d092014-01-08 10:02:16 +09002638
Paolo Pisati92d7a552012-12-13 10:13:00 +01002639 /* restore original values in case of error */
2640 old_min_uV = regulator->min_uV;
2641 old_max_uV = regulator->max_uV;
Liam Girdwood414c70c2008-04-30 15:59:04 +01002642 regulator->min_uV = min_uV;
2643 regulator->max_uV = max_uV;
Mark Brown3a93f2a2010-11-10 14:38:29 +00002644
Thomas Petazzoni05fda3b1a2010-12-03 11:31:07 +01002645 ret = regulator_check_consumers(rdev, &min_uV, &max_uV);
2646 if (ret < 0)
Paolo Pisati92d7a552012-12-13 10:13:00 +01002647 goto out2;
Thomas Petazzoni05fda3b1a2010-12-03 11:31:07 +01002648
Mark Brown75790252010-12-12 14:25:50 +00002649 ret = _regulator_do_set_voltage(rdev, min_uV, max_uV);
Paolo Pisati92d7a552012-12-13 10:13:00 +01002650 if (ret < 0)
2651 goto out2;
Jingoo Han0d25d092014-01-08 10:02:16 +09002652
Liam Girdwood414c70c2008-04-30 15:59:04 +01002653out:
2654 mutex_unlock(&rdev->mutex);
2655 return ret;
Paolo Pisati92d7a552012-12-13 10:13:00 +01002656out2:
2657 regulator->min_uV = old_min_uV;
2658 regulator->max_uV = old_max_uV;
2659 mutex_unlock(&rdev->mutex);
2660 return ret;
Liam Girdwood414c70c2008-04-30 15:59:04 +01002661}
2662EXPORT_SYMBOL_GPL(regulator_set_voltage);
2663
Mark Brown606a2562010-12-16 15:49:36 +00002664/**
Linus Walleij88cd222b2011-03-17 13:24:52 +01002665 * regulator_set_voltage_time - get raise/fall time
2666 * @regulator: regulator source
2667 * @old_uV: starting voltage in microvolts
2668 * @new_uV: target voltage in microvolts
2669 *
2670 * Provided with the starting and ending voltage, this function attempts to
2671 * calculate the time in microseconds required to rise or fall to this new
2672 * voltage.
2673 */
2674int regulator_set_voltage_time(struct regulator *regulator,
2675 int old_uV, int new_uV)
2676{
Guodong Xu272e2312014-08-13 19:33:38 +08002677 struct regulator_dev *rdev = regulator->rdev;
2678 const struct regulator_ops *ops = rdev->desc->ops;
Linus Walleij88cd222b2011-03-17 13:24:52 +01002679 int old_sel = -1;
2680 int new_sel = -1;
2681 int voltage;
2682 int i;
2683
2684 /* Currently requires operations to do this */
2685 if (!ops->list_voltage || !ops->set_voltage_time_sel
2686 || !rdev->desc->n_voltages)
2687 return -EINVAL;
2688
2689 for (i = 0; i < rdev->desc->n_voltages; i++) {
2690 /* We only look for exact voltage matches here */
2691 voltage = regulator_list_voltage(regulator, i);
2692 if (voltage < 0)
2693 return -EINVAL;
2694 if (voltage == 0)
2695 continue;
2696 if (voltage == old_uV)
2697 old_sel = i;
2698 if (voltage == new_uV)
2699 new_sel = i;
2700 }
2701
2702 if (old_sel < 0 || new_sel < 0)
2703 return -EINVAL;
2704
2705 return ops->set_voltage_time_sel(rdev, old_sel, new_sel);
2706}
2707EXPORT_SYMBOL_GPL(regulator_set_voltage_time);
2708
2709/**
Randy Dunlap296c6562012-08-18 17:44:14 -07002710 * regulator_set_voltage_time_sel - get raise/fall time
2711 * @rdev: regulator source device
Yadwinder Singh Brar98a175b2012-06-09 16:40:38 +05302712 * @old_selector: selector for starting voltage
2713 * @new_selector: selector for target voltage
2714 *
2715 * Provided with the starting and target voltage selectors, this function
2716 * returns time in microseconds required to rise or fall to this new voltage
2717 *
Axel Linf11d08c2012-06-19 09:38:45 +08002718 * Drivers providing ramp_delay in regulation_constraints can use this as their
Axel Lin398715a2012-06-18 10:11:28 +08002719 * set_voltage_time_sel() operation.
Yadwinder Singh Brar98a175b2012-06-09 16:40:38 +05302720 */
2721int regulator_set_voltage_time_sel(struct regulator_dev *rdev,
2722 unsigned int old_selector,
2723 unsigned int new_selector)
2724{
Axel Lin398715a2012-06-18 10:11:28 +08002725 unsigned int ramp_delay = 0;
Axel Linf11d08c2012-06-19 09:38:45 +08002726 int old_volt, new_volt;
Axel Lin398715a2012-06-18 10:11:28 +08002727
2728 if (rdev->constraints->ramp_delay)
2729 ramp_delay = rdev->constraints->ramp_delay;
2730 else if (rdev->desc->ramp_delay)
2731 ramp_delay = rdev->desc->ramp_delay;
2732
2733 if (ramp_delay == 0) {
Yadwinder Singh Brar6f0b2c62012-06-11 17:41:08 +05302734 rdev_warn(rdev, "ramp_delay not set\n");
Axel Lin398715a2012-06-18 10:11:28 +08002735 return 0;
Yadwinder Singh Brar6f0b2c62012-06-11 17:41:08 +05302736 }
Axel Lin398715a2012-06-18 10:11:28 +08002737
Axel Linf11d08c2012-06-19 09:38:45 +08002738 /* sanity check */
2739 if (!rdev->desc->ops->list_voltage)
2740 return -EINVAL;
Axel Lin398715a2012-06-18 10:11:28 +08002741
Axel Linf11d08c2012-06-19 09:38:45 +08002742 old_volt = rdev->desc->ops->list_voltage(rdev, old_selector);
2743 new_volt = rdev->desc->ops->list_voltage(rdev, new_selector);
2744
2745 return DIV_ROUND_UP(abs(new_volt - old_volt), ramp_delay);
Yadwinder Singh Brar98a175b2012-06-09 16:40:38 +05302746}
Mark Brownb19dbf72012-06-23 11:34:20 +01002747EXPORT_SYMBOL_GPL(regulator_set_voltage_time_sel);
Yadwinder Singh Brar98a175b2012-06-09 16:40:38 +05302748
2749/**
Mark Brown606a2562010-12-16 15:49:36 +00002750 * regulator_sync_voltage - re-apply last regulator output voltage
2751 * @regulator: regulator source
2752 *
2753 * Re-apply the last configured voltage. This is intended to be used
2754 * where some external control source the consumer is cooperating with
2755 * has caused the configured voltage to change.
2756 */
2757int regulator_sync_voltage(struct regulator *regulator)
2758{
2759 struct regulator_dev *rdev = regulator->rdev;
2760 int ret, min_uV, max_uV;
2761
2762 mutex_lock(&rdev->mutex);
2763
2764 if (!rdev->desc->ops->set_voltage &&
2765 !rdev->desc->ops->set_voltage_sel) {
2766 ret = -EINVAL;
2767 goto out;
2768 }
2769
2770 /* This is only going to work if we've had a voltage configured. */
2771 if (!regulator->min_uV && !regulator->max_uV) {
2772 ret = -EINVAL;
2773 goto out;
2774 }
2775
2776 min_uV = regulator->min_uV;
2777 max_uV = regulator->max_uV;
2778
2779 /* This should be a paranoia check... */
2780 ret = regulator_check_voltage(rdev, &min_uV, &max_uV);
2781 if (ret < 0)
2782 goto out;
2783
2784 ret = regulator_check_consumers(rdev, &min_uV, &max_uV);
2785 if (ret < 0)
2786 goto out;
2787
2788 ret = _regulator_do_set_voltage(rdev, min_uV, max_uV);
2789
2790out:
2791 mutex_unlock(&rdev->mutex);
2792 return ret;
2793}
2794EXPORT_SYMBOL_GPL(regulator_sync_voltage);
2795
Liam Girdwood414c70c2008-04-30 15:59:04 +01002796static int _regulator_get_voltage(struct regulator_dev *rdev)
2797{
Mark Brownbf5892a2011-05-08 22:13:37 +01002798 int sel, ret;
Mark Brown476c2d82010-12-10 17:28:07 +00002799
2800 if (rdev->desc->ops->get_voltage_sel) {
2801 sel = rdev->desc->ops->get_voltage_sel(rdev);
2802 if (sel < 0)
2803 return sel;
Mark Brownbf5892a2011-05-08 22:13:37 +01002804 ret = rdev->desc->ops->list_voltage(rdev, sel);
Axel Lincb220d12011-05-23 20:08:10 +08002805 } else if (rdev->desc->ops->get_voltage) {
Mark Brownbf5892a2011-05-08 22:13:37 +01002806 ret = rdev->desc->ops->get_voltage(rdev);
Mark Brownf7df20e2012-08-09 16:42:19 +01002807 } else if (rdev->desc->ops->list_voltage) {
2808 ret = rdev->desc->ops->list_voltage(rdev, 0);
Laxman Dewangan5a523602013-09-10 15:45:05 +05302809 } else if (rdev->desc->fixed_uV && (rdev->desc->n_voltages == 1)) {
2810 ret = rdev->desc->fixed_uV;
Javier Martinez Canillase3039962014-07-29 18:28:55 +02002811 } else if (rdev->supply) {
2812 ret = regulator_get_voltage(rdev->supply);
Axel Lincb220d12011-05-23 20:08:10 +08002813 } else {
Liam Girdwood414c70c2008-04-30 15:59:04 +01002814 return -EINVAL;
Axel Lincb220d12011-05-23 20:08:10 +08002815 }
Mark Brownbf5892a2011-05-08 22:13:37 +01002816
Axel Lincb220d12011-05-23 20:08:10 +08002817 if (ret < 0)
2818 return ret;
Mark Brownbf5892a2011-05-08 22:13:37 +01002819 return ret - rdev->constraints->uV_offset;
Liam Girdwood414c70c2008-04-30 15:59:04 +01002820}
2821
2822/**
2823 * regulator_get_voltage - get regulator output voltage
2824 * @regulator: regulator source
2825 *
2826 * This returns the current regulator voltage in uV.
2827 *
2828 * NOTE: If the regulator is disabled it will return the voltage value. This
2829 * function should not be used to determine regulator state.
2830 */
2831int regulator_get_voltage(struct regulator *regulator)
2832{
2833 int ret;
2834
2835 mutex_lock(&regulator->rdev->mutex);
2836
2837 ret = _regulator_get_voltage(regulator->rdev);
2838
2839 mutex_unlock(&regulator->rdev->mutex);
2840
2841 return ret;
2842}
2843EXPORT_SYMBOL_GPL(regulator_get_voltage);
2844
2845/**
2846 * regulator_set_current_limit - set regulator output current limit
2847 * @regulator: regulator source
Charles Keepaxce0d10f2013-05-21 15:04:07 +01002848 * @min_uA: Minimum supported current in uA
Liam Girdwood414c70c2008-04-30 15:59:04 +01002849 * @max_uA: Maximum supported current in uA
2850 *
2851 * Sets current sink to the desired output current. This can be set during
2852 * any regulator state. IOW, regulator can be disabled or enabled.
2853 *
2854 * If the regulator is enabled then the current will change to the new value
2855 * immediately otherwise if the regulator is disabled the regulator will
2856 * output at the new current when enabled.
2857 *
2858 * NOTE: Regulator system constraints must be set for this regulator before
2859 * calling this function otherwise this call will fail.
2860 */
2861int regulator_set_current_limit(struct regulator *regulator,
2862 int min_uA, int max_uA)
2863{
2864 struct regulator_dev *rdev = regulator->rdev;
2865 int ret;
2866
2867 mutex_lock(&rdev->mutex);
2868
2869 /* sanity check */
2870 if (!rdev->desc->ops->set_current_limit) {
2871 ret = -EINVAL;
2872 goto out;
2873 }
2874
2875 /* constraints check */
2876 ret = regulator_check_current_limit(rdev, &min_uA, &max_uA);
2877 if (ret < 0)
2878 goto out;
2879
2880 ret = rdev->desc->ops->set_current_limit(rdev, min_uA, max_uA);
2881out:
2882 mutex_unlock(&rdev->mutex);
2883 return ret;
2884}
2885EXPORT_SYMBOL_GPL(regulator_set_current_limit);
2886
2887static int _regulator_get_current_limit(struct regulator_dev *rdev)
2888{
2889 int ret;
2890
2891 mutex_lock(&rdev->mutex);
2892
2893 /* sanity check */
2894 if (!rdev->desc->ops->get_current_limit) {
2895 ret = -EINVAL;
2896 goto out;
2897 }
2898
2899 ret = rdev->desc->ops->get_current_limit(rdev);
2900out:
2901 mutex_unlock(&rdev->mutex);
2902 return ret;
2903}
2904
2905/**
2906 * regulator_get_current_limit - get regulator output current
2907 * @regulator: regulator source
2908 *
2909 * This returns the current supplied by the specified current sink in uA.
2910 *
2911 * NOTE: If the regulator is disabled it will return the current value. This
2912 * function should not be used to determine regulator state.
2913 */
2914int regulator_get_current_limit(struct regulator *regulator)
2915{
2916 return _regulator_get_current_limit(regulator->rdev);
2917}
2918EXPORT_SYMBOL_GPL(regulator_get_current_limit);
2919
2920/**
2921 * regulator_set_mode - set regulator operating mode
2922 * @regulator: regulator source
2923 * @mode: operating mode - one of the REGULATOR_MODE constants
2924 *
2925 * Set regulator operating mode to increase regulator efficiency or improve
2926 * regulation performance.
2927 *
2928 * NOTE: Regulator system constraints must be set for this regulator before
2929 * calling this function otherwise this call will fail.
2930 */
2931int regulator_set_mode(struct regulator *regulator, unsigned int mode)
2932{
2933 struct regulator_dev *rdev = regulator->rdev;
2934 int ret;
Sundar R Iyer500b4ac2010-05-17 21:24:48 +05302935 int regulator_curr_mode;
Liam Girdwood414c70c2008-04-30 15:59:04 +01002936
2937 mutex_lock(&rdev->mutex);
2938
2939 /* sanity check */
2940 if (!rdev->desc->ops->set_mode) {
2941 ret = -EINVAL;
2942 goto out;
2943 }
2944
Sundar R Iyer500b4ac2010-05-17 21:24:48 +05302945 /* return if the same mode is requested */
2946 if (rdev->desc->ops->get_mode) {
2947 regulator_curr_mode = rdev->desc->ops->get_mode(rdev);
2948 if (regulator_curr_mode == mode) {
2949 ret = 0;
2950 goto out;
2951 }
2952 }
2953
Liam Girdwood414c70c2008-04-30 15:59:04 +01002954 /* constraints check */
Axel Lin22c51b42011-04-01 18:25:25 +08002955 ret = regulator_mode_constrain(rdev, &mode);
Liam Girdwood414c70c2008-04-30 15:59:04 +01002956 if (ret < 0)
2957 goto out;
2958
2959 ret = rdev->desc->ops->set_mode(rdev, mode);
2960out:
2961 mutex_unlock(&rdev->mutex);
2962 return ret;
2963}
2964EXPORT_SYMBOL_GPL(regulator_set_mode);
2965
2966static unsigned int _regulator_get_mode(struct regulator_dev *rdev)
2967{
2968 int ret;
2969
2970 mutex_lock(&rdev->mutex);
2971
2972 /* sanity check */
2973 if (!rdev->desc->ops->get_mode) {
2974 ret = -EINVAL;
2975 goto out;
2976 }
2977
2978 ret = rdev->desc->ops->get_mode(rdev);
2979out:
2980 mutex_unlock(&rdev->mutex);
2981 return ret;
2982}
2983
2984/**
2985 * regulator_get_mode - get regulator operating mode
2986 * @regulator: regulator source
2987 *
2988 * Get the current regulator operating mode.
2989 */
2990unsigned int regulator_get_mode(struct regulator *regulator)
2991{
2992 return _regulator_get_mode(regulator->rdev);
2993}
2994EXPORT_SYMBOL_GPL(regulator_get_mode);
2995
2996/**
2997 * regulator_set_optimum_mode - set regulator optimum operating mode
2998 * @regulator: regulator source
2999 * @uA_load: load current
3000 *
3001 * Notifies the regulator core of a new device load. This is then used by
3002 * DRMS (if enabled by constraints) to set the most efficient regulator
3003 * operating mode for the new regulator loading.
3004 *
3005 * Consumer devices notify their supply regulator of the maximum power
3006 * they will require (can be taken from device datasheet in the power
3007 * consumption tables) when they change operational status and hence power
3008 * state. Examples of operational state changes that can affect power
3009 * consumption are :-
3010 *
3011 * o Device is opened / closed.
3012 * o Device I/O is about to begin or has just finished.
3013 * o Device is idling in between work.
3014 *
3015 * This information is also exported via sysfs to userspace.
3016 *
3017 * DRMS will sum the total requested load on the regulator and change
3018 * to the most efficient operating mode if platform constraints allow.
3019 *
3020 * Returns the new regulator mode or error.
3021 */
3022int regulator_set_optimum_mode(struct regulator *regulator, int uA_load)
3023{
3024 struct regulator_dev *rdev = regulator->rdev;
Bjorn Andersson8460ef32015-01-27 18:46:31 -08003025 int ret;
Stephen Boydd92d95b62012-07-02 19:21:06 -07003026
Liam Girdwood414c70c2008-04-30 15:59:04 +01003027 mutex_lock(&rdev->mutex);
Liam Girdwood414c70c2008-04-30 15:59:04 +01003028 regulator->uA_load = uA_load;
Bjorn Andersson8460ef32015-01-27 18:46:31 -08003029 ret = drms_uA_update(rdev);
Liam Girdwood414c70c2008-04-30 15:59:04 +01003030 mutex_unlock(&rdev->mutex);
Bjorn Andersson8460ef32015-01-27 18:46:31 -08003031
Liam Girdwood414c70c2008-04-30 15:59:04 +01003032 return ret;
3033}
3034EXPORT_SYMBOL_GPL(regulator_set_optimum_mode);
3035
3036/**
Mark Brownf59c8f92012-08-31 10:36:37 -07003037 * regulator_allow_bypass - allow the regulator to go into bypass mode
3038 *
3039 * @regulator: Regulator to configure
Nishanth Menon9345dfb2013-02-28 18:44:54 -06003040 * @enable: enable or disable bypass mode
Mark Brownf59c8f92012-08-31 10:36:37 -07003041 *
3042 * Allow the regulator to go into bypass mode if all other consumers
3043 * for the regulator also enable bypass mode and the machine
3044 * constraints allow this. Bypass mode means that the regulator is
3045 * simply passing the input directly to the output with no regulation.
3046 */
3047int regulator_allow_bypass(struct regulator *regulator, bool enable)
3048{
3049 struct regulator_dev *rdev = regulator->rdev;
3050 int ret = 0;
3051
3052 if (!rdev->desc->ops->set_bypass)
3053 return 0;
3054
3055 if (rdev->constraints &&
3056 !(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_BYPASS))
3057 return 0;
3058
3059 mutex_lock(&rdev->mutex);
3060
3061 if (enable && !regulator->bypass) {
3062 rdev->bypass_count++;
3063
3064 if (rdev->bypass_count == rdev->open_count) {
3065 ret = rdev->desc->ops->set_bypass(rdev, enable);
3066 if (ret != 0)
3067 rdev->bypass_count--;
3068 }
3069
3070 } else if (!enable && regulator->bypass) {
3071 rdev->bypass_count--;
3072
3073 if (rdev->bypass_count != rdev->open_count) {
3074 ret = rdev->desc->ops->set_bypass(rdev, enable);
3075 if (ret != 0)
3076 rdev->bypass_count++;
3077 }
3078 }
3079
3080 if (ret == 0)
3081 regulator->bypass = enable;
3082
3083 mutex_unlock(&rdev->mutex);
3084
3085 return ret;
3086}
3087EXPORT_SYMBOL_GPL(regulator_allow_bypass);
3088
3089/**
Liam Girdwood414c70c2008-04-30 15:59:04 +01003090 * regulator_register_notifier - register regulator event notifier
3091 * @regulator: regulator source
Mark Brown69279fb2008-12-31 12:52:41 +00003092 * @nb: notifier block
Liam Girdwood414c70c2008-04-30 15:59:04 +01003093 *
3094 * Register notifier block to receive regulator events.
3095 */
3096int regulator_register_notifier(struct regulator *regulator,
3097 struct notifier_block *nb)
3098{
3099 return blocking_notifier_chain_register(&regulator->rdev->notifier,
3100 nb);
3101}
3102EXPORT_SYMBOL_GPL(regulator_register_notifier);
3103
3104/**
3105 * regulator_unregister_notifier - unregister regulator event notifier
3106 * @regulator: regulator source
Mark Brown69279fb2008-12-31 12:52:41 +00003107 * @nb: notifier block
Liam Girdwood414c70c2008-04-30 15:59:04 +01003108 *
3109 * Unregister regulator event notifier block.
3110 */
3111int regulator_unregister_notifier(struct regulator *regulator,
3112 struct notifier_block *nb)
3113{
3114 return blocking_notifier_chain_unregister(&regulator->rdev->notifier,
3115 nb);
3116}
3117EXPORT_SYMBOL_GPL(regulator_unregister_notifier);
3118
Jonathan Cameronb136fb42009-01-19 18:20:58 +00003119/* notify regulator consumers and downstream regulator consumers.
3120 * Note mutex must be held by caller.
3121 */
Heiko Stübner71795692014-08-28 12:36:04 -07003122static int _notifier_call_chain(struct regulator_dev *rdev,
Liam Girdwood414c70c2008-04-30 15:59:04 +01003123 unsigned long event, void *data)
3124{
Liam Girdwood414c70c2008-04-30 15:59:04 +01003125 /* call rdev chain first */
Heiko Stübner71795692014-08-28 12:36:04 -07003126 return blocking_notifier_call_chain(&rdev->notifier, event, data);
Liam Girdwood414c70c2008-04-30 15:59:04 +01003127}
3128
3129/**
3130 * regulator_bulk_get - get multiple regulator consumers
3131 *
3132 * @dev: Device to supply
3133 * @num_consumers: Number of consumers to register
3134 * @consumers: Configuration of consumers; clients are stored here.
3135 *
3136 * @return 0 on success, an errno on failure.
3137 *
3138 * This helper function allows drivers to get several regulator
3139 * consumers in one operation. If any of the regulators cannot be
3140 * acquired then any regulators that were allocated will be freed
3141 * before returning to the caller.
3142 */
3143int regulator_bulk_get(struct device *dev, int num_consumers,
3144 struct regulator_bulk_data *consumers)
3145{
3146 int i;
3147 int ret;
3148
3149 for (i = 0; i < num_consumers; i++)
3150 consumers[i].consumer = NULL;
3151
3152 for (i = 0; i < num_consumers; i++) {
3153 consumers[i].consumer = regulator_get(dev,
3154 consumers[i].supply);
3155 if (IS_ERR(consumers[i].consumer)) {
Liam Girdwood414c70c2008-04-30 15:59:04 +01003156 ret = PTR_ERR(consumers[i].consumer);
Mark Brown5b307622009-10-13 13:06:49 +01003157 dev_err(dev, "Failed to get supply '%s': %d\n",
3158 consumers[i].supply, ret);
Liam Girdwood414c70c2008-04-30 15:59:04 +01003159 consumers[i].consumer = NULL;
3160 goto err;
3161 }
3162 }
3163
3164 return 0;
3165
3166err:
Axel Linb29c7692012-02-20 10:32:16 +08003167 while (--i >= 0)
Liam Girdwood414c70c2008-04-30 15:59:04 +01003168 regulator_put(consumers[i].consumer);
3169
3170 return ret;
3171}
3172EXPORT_SYMBOL_GPL(regulator_bulk_get);
3173
Mark Brownf21e0e82011-05-24 08:12:40 +08003174static void regulator_bulk_enable_async(void *data, async_cookie_t cookie)
3175{
3176 struct regulator_bulk_data *bulk = data;
3177
3178 bulk->ret = regulator_enable(bulk->consumer);
3179}
3180
Liam Girdwood414c70c2008-04-30 15:59:04 +01003181/**
3182 * regulator_bulk_enable - enable multiple regulator consumers
3183 *
3184 * @num_consumers: Number of consumers
3185 * @consumers: Consumer data; clients are stored here.
3186 * @return 0 on success, an errno on failure
3187 *
3188 * This convenience API allows consumers to enable multiple regulator
3189 * clients in a single API call. If any consumers cannot be enabled
3190 * then any others that were enabled will be disabled again prior to
3191 * return.
3192 */
3193int regulator_bulk_enable(int num_consumers,
3194 struct regulator_bulk_data *consumers)
3195{
Dan Williams2955b472012-07-09 19:33:25 -07003196 ASYNC_DOMAIN_EXCLUSIVE(async_domain);
Liam Girdwood414c70c2008-04-30 15:59:04 +01003197 int i;
Mark Brownf21e0e82011-05-24 08:12:40 +08003198 int ret = 0;
Liam Girdwood414c70c2008-04-30 15:59:04 +01003199
Mark Brown6492bc12012-04-19 13:19:07 +01003200 for (i = 0; i < num_consumers; i++) {
3201 if (consumers[i].consumer->always_on)
3202 consumers[i].ret = 0;
3203 else
3204 async_schedule_domain(regulator_bulk_enable_async,
3205 &consumers[i], &async_domain);
3206 }
Mark Brownf21e0e82011-05-24 08:12:40 +08003207
3208 async_synchronize_full_domain(&async_domain);
3209
3210 /* If any consumer failed we need to unwind any that succeeded */
Liam Girdwood414c70c2008-04-30 15:59:04 +01003211 for (i = 0; i < num_consumers; i++) {
Mark Brownf21e0e82011-05-24 08:12:40 +08003212 if (consumers[i].ret != 0) {
3213 ret = consumers[i].ret;
Liam Girdwood414c70c2008-04-30 15:59:04 +01003214 goto err;
Mark Brownf21e0e82011-05-24 08:12:40 +08003215 }
Liam Girdwood414c70c2008-04-30 15:59:04 +01003216 }
3217
3218 return 0;
3219
3220err:
Andrzej Hajdafbe31052013-03-01 12:24:05 +01003221 for (i = 0; i < num_consumers; i++) {
3222 if (consumers[i].ret < 0)
3223 pr_err("Failed to enable %s: %d\n", consumers[i].supply,
3224 consumers[i].ret);
3225 else
3226 regulator_disable(consumers[i].consumer);
3227 }
Liam Girdwood414c70c2008-04-30 15:59:04 +01003228
3229 return ret;
3230}
3231EXPORT_SYMBOL_GPL(regulator_bulk_enable);
3232
3233/**
3234 * regulator_bulk_disable - disable multiple regulator consumers
3235 *
3236 * @num_consumers: Number of consumers
3237 * @consumers: Consumer data; clients are stored here.
3238 * @return 0 on success, an errno on failure
3239 *
3240 * This convenience API allows consumers to disable multiple regulator
Sylwester Nawrocki49e22632012-01-25 12:35:38 +01003241 * clients in a single API call. If any consumers cannot be disabled
3242 * then any others that were disabled will be enabled again prior to
Liam Girdwood414c70c2008-04-30 15:59:04 +01003243 * return.
3244 */
3245int regulator_bulk_disable(int num_consumers,
3246 struct regulator_bulk_data *consumers)
3247{
3248 int i;
Mark Brown01e86f42012-03-28 21:36:38 +01003249 int ret, r;
Liam Girdwood414c70c2008-04-30 15:59:04 +01003250
Sylwester Nawrocki49e22632012-01-25 12:35:38 +01003251 for (i = num_consumers - 1; i >= 0; --i) {
Liam Girdwood414c70c2008-04-30 15:59:04 +01003252 ret = regulator_disable(consumers[i].consumer);
3253 if (ret != 0)
3254 goto err;
3255 }
3256
3257 return 0;
3258
3259err:
Joe Perches5da84fd2010-11-30 05:53:48 -08003260 pr_err("Failed to disable %s: %d\n", consumers[i].supply, ret);
Mark Brown01e86f42012-03-28 21:36:38 +01003261 for (++i; i < num_consumers; ++i) {
3262 r = regulator_enable(consumers[i].consumer);
3263 if (r != 0)
3264 pr_err("Failed to reename %s: %d\n",
3265 consumers[i].supply, r);
3266 }
Liam Girdwood414c70c2008-04-30 15:59:04 +01003267
3268 return ret;
3269}
3270EXPORT_SYMBOL_GPL(regulator_bulk_disable);
3271
3272/**
Donggeun Kime1de2f42012-01-03 16:22:03 +09003273 * regulator_bulk_force_disable - force disable multiple regulator consumers
3274 *
3275 * @num_consumers: Number of consumers
3276 * @consumers: Consumer data; clients are stored here.
3277 * @return 0 on success, an errno on failure
3278 *
3279 * This convenience API allows consumers to forcibly disable multiple regulator
3280 * clients in a single API call.
3281 * NOTE: This should be used for situations when device damage will
3282 * likely occur if the regulators are not disabled (e.g. over temp).
3283 * Although regulator_force_disable function call for some consumers can
3284 * return error numbers, the function is called for all consumers.
3285 */
3286int regulator_bulk_force_disable(int num_consumers,
3287 struct regulator_bulk_data *consumers)
3288{
3289 int i;
3290 int ret;
3291
3292 for (i = 0; i < num_consumers; i++)
3293 consumers[i].ret =
3294 regulator_force_disable(consumers[i].consumer);
3295
3296 for (i = 0; i < num_consumers; i++) {
3297 if (consumers[i].ret != 0) {
3298 ret = consumers[i].ret;
3299 goto out;
3300 }
3301 }
3302
3303 return 0;
3304out:
3305 return ret;
3306}
3307EXPORT_SYMBOL_GPL(regulator_bulk_force_disable);
3308
3309/**
Liam Girdwood414c70c2008-04-30 15:59:04 +01003310 * regulator_bulk_free - free multiple regulator consumers
3311 *
3312 * @num_consumers: Number of consumers
3313 * @consumers: Consumer data; clients are stored here.
3314 *
3315 * This convenience API allows consumers to free multiple regulator
3316 * clients in a single API call.
3317 */
3318void regulator_bulk_free(int num_consumers,
3319 struct regulator_bulk_data *consumers)
3320{
3321 int i;
3322
3323 for (i = 0; i < num_consumers; i++) {
3324 regulator_put(consumers[i].consumer);
3325 consumers[i].consumer = NULL;
3326 }
3327}
3328EXPORT_SYMBOL_GPL(regulator_bulk_free);
3329
3330/**
3331 * regulator_notifier_call_chain - call regulator event notifier
Mark Brown69279fb2008-12-31 12:52:41 +00003332 * @rdev: regulator source
Liam Girdwood414c70c2008-04-30 15:59:04 +01003333 * @event: notifier block
Mark Brown69279fb2008-12-31 12:52:41 +00003334 * @data: callback-specific data.
Liam Girdwood414c70c2008-04-30 15:59:04 +01003335 *
3336 * Called by regulator drivers to notify clients a regulator event has
3337 * occurred. We also notify regulator clients downstream.
Jonathan Cameronb136fb42009-01-19 18:20:58 +00003338 * Note lock must be held by caller.
Liam Girdwood414c70c2008-04-30 15:59:04 +01003339 */
3340int regulator_notifier_call_chain(struct regulator_dev *rdev,
3341 unsigned long event, void *data)
3342{
3343 _notifier_call_chain(rdev, event, data);
3344 return NOTIFY_DONE;
3345
3346}
3347EXPORT_SYMBOL_GPL(regulator_notifier_call_chain);
3348
Mark Brownbe721972009-08-04 20:09:52 +02003349/**
3350 * regulator_mode_to_status - convert a regulator mode into a status
3351 *
3352 * @mode: Mode to convert
3353 *
3354 * Convert a regulator mode into a status.
3355 */
3356int regulator_mode_to_status(unsigned int mode)
3357{
3358 switch (mode) {
3359 case REGULATOR_MODE_FAST:
3360 return REGULATOR_STATUS_FAST;
3361 case REGULATOR_MODE_NORMAL:
3362 return REGULATOR_STATUS_NORMAL;
3363 case REGULATOR_MODE_IDLE:
3364 return REGULATOR_STATUS_IDLE;
Krystian Garbaciak03ffcf32012-07-12 11:50:38 +01003365 case REGULATOR_MODE_STANDBY:
Mark Brownbe721972009-08-04 20:09:52 +02003366 return REGULATOR_STATUS_STANDBY;
3367 default:
Krystian Garbaciak1beaf762012-07-12 13:53:35 +01003368 return REGULATOR_STATUS_UNDEFINED;
Mark Brownbe721972009-08-04 20:09:52 +02003369 }
3370}
3371EXPORT_SYMBOL_GPL(regulator_mode_to_status);
3372
Takashi Iwai39f802d2015-01-30 20:29:31 +01003373static struct attribute *regulator_dev_attrs[] = {
3374 &dev_attr_name.attr,
3375 &dev_attr_num_users.attr,
3376 &dev_attr_type.attr,
3377 &dev_attr_microvolts.attr,
3378 &dev_attr_microamps.attr,
3379 &dev_attr_opmode.attr,
3380 &dev_attr_state.attr,
3381 &dev_attr_status.attr,
3382 &dev_attr_bypass.attr,
3383 &dev_attr_requested_microamps.attr,
3384 &dev_attr_min_microvolts.attr,
3385 &dev_attr_max_microvolts.attr,
3386 &dev_attr_min_microamps.attr,
3387 &dev_attr_max_microamps.attr,
3388 &dev_attr_suspend_standby_state.attr,
3389 &dev_attr_suspend_mem_state.attr,
3390 &dev_attr_suspend_disk_state.attr,
3391 &dev_attr_suspend_standby_microvolts.attr,
3392 &dev_attr_suspend_mem_microvolts.attr,
3393 &dev_attr_suspend_disk_microvolts.attr,
3394 &dev_attr_suspend_standby_mode.attr,
3395 &dev_attr_suspend_mem_mode.attr,
3396 &dev_attr_suspend_disk_mode.attr,
3397 NULL
3398};
3399
David Brownell7ad68e22008-11-11 17:39:02 -08003400/*
3401 * To avoid cluttering sysfs (and memory) with useless state, only
3402 * create attributes that can be meaningfully displayed.
3403 */
Takashi Iwai39f802d2015-01-30 20:29:31 +01003404static umode_t regulator_attr_is_visible(struct kobject *kobj,
3405 struct attribute *attr, int idx)
David Brownell7ad68e22008-11-11 17:39:02 -08003406{
Takashi Iwai39f802d2015-01-30 20:29:31 +01003407 struct device *dev = kobj_to_dev(kobj);
3408 struct regulator_dev *rdev = container_of(dev, struct regulator_dev, dev);
Guodong Xu272e2312014-08-13 19:33:38 +08003409 const struct regulator_ops *ops = rdev->desc->ops;
Takashi Iwai39f802d2015-01-30 20:29:31 +01003410 umode_t mode = attr->mode;
3411
3412 /* these three are always present */
3413 if (attr == &dev_attr_name.attr ||
3414 attr == &dev_attr_num_users.attr ||
3415 attr == &dev_attr_type.attr)
3416 return mode;
David Brownell7ad68e22008-11-11 17:39:02 -08003417
3418 /* some attributes need specific methods to be displayed */
Takashi Iwai39f802d2015-01-30 20:29:31 +01003419 if (attr == &dev_attr_microvolts.attr) {
3420 if ((ops->get_voltage && ops->get_voltage(rdev) >= 0) ||
3421 (ops->get_voltage_sel && ops->get_voltage_sel(rdev) >= 0) ||
3422 (ops->list_voltage && ops->list_voltage(rdev, 0) >= 0) ||
3423 (rdev->desc->fixed_uV && rdev->desc->n_voltages == 1))
3424 return mode;
3425 return 0;
Mark Brownf59c8f92012-08-31 10:36:37 -07003426 }
David Brownell7ad68e22008-11-11 17:39:02 -08003427
Takashi Iwai39f802d2015-01-30 20:29:31 +01003428 if (attr == &dev_attr_microamps.attr)
3429 return ops->get_current_limit ? mode : 0;
3430
3431 if (attr == &dev_attr_opmode.attr)
3432 return ops->get_mode ? mode : 0;
3433
3434 if (attr == &dev_attr_state.attr)
3435 return (rdev->ena_pin || ops->is_enabled) ? mode : 0;
3436
3437 if (attr == &dev_attr_status.attr)
3438 return ops->get_status ? mode : 0;
3439
3440 if (attr == &dev_attr_bypass.attr)
3441 return ops->get_bypass ? mode : 0;
3442
David Brownell7ad68e22008-11-11 17:39:02 -08003443 /* some attributes are type-specific */
Takashi Iwai39f802d2015-01-30 20:29:31 +01003444 if (attr == &dev_attr_requested_microamps.attr)
3445 return rdev->desc->type == REGULATOR_CURRENT ? mode : 0;
David Brownell7ad68e22008-11-11 17:39:02 -08003446
3447 /* all the other attributes exist to support constraints;
3448 * don't show them if there are no constraints, or if the
3449 * relevant supporting methods are missing.
3450 */
3451 if (!rdev->constraints)
Takashi Iwai39f802d2015-01-30 20:29:31 +01003452 return 0;
David Brownell7ad68e22008-11-11 17:39:02 -08003453
3454 /* constraints need specific supporting methods */
Takashi Iwai39f802d2015-01-30 20:29:31 +01003455 if (attr == &dev_attr_min_microvolts.attr ||
3456 attr == &dev_attr_max_microvolts.attr)
3457 return (ops->set_voltage || ops->set_voltage_sel) ? mode : 0;
David Brownell7ad68e22008-11-11 17:39:02 -08003458
Takashi Iwai39f802d2015-01-30 20:29:31 +01003459 if (attr == &dev_attr_min_microamps.attr ||
3460 attr == &dev_attr_max_microamps.attr)
3461 return ops->set_current_limit ? mode : 0;
David Brownell7ad68e22008-11-11 17:39:02 -08003462
Takashi Iwai39f802d2015-01-30 20:29:31 +01003463 if (attr == &dev_attr_suspend_standby_state.attr ||
3464 attr == &dev_attr_suspend_mem_state.attr ||
3465 attr == &dev_attr_suspend_disk_state.attr)
3466 return mode;
David Brownell7ad68e22008-11-11 17:39:02 -08003467
Takashi Iwai39f802d2015-01-30 20:29:31 +01003468 if (attr == &dev_attr_suspend_standby_microvolts.attr ||
3469 attr == &dev_attr_suspend_mem_microvolts.attr ||
3470 attr == &dev_attr_suspend_disk_microvolts.attr)
3471 return ops->set_suspend_voltage ? mode : 0;
David Brownell7ad68e22008-11-11 17:39:02 -08003472
Takashi Iwai39f802d2015-01-30 20:29:31 +01003473 if (attr == &dev_attr_suspend_standby_mode.attr ||
3474 attr == &dev_attr_suspend_mem_mode.attr ||
3475 attr == &dev_attr_suspend_disk_mode.attr)
3476 return ops->set_suspend_mode ? mode : 0;
3477
3478 return mode;
David Brownell7ad68e22008-11-11 17:39:02 -08003479}
3480
Takashi Iwai39f802d2015-01-30 20:29:31 +01003481static const struct attribute_group regulator_dev_group = {
3482 .attrs = regulator_dev_attrs,
3483 .is_visible = regulator_attr_is_visible,
3484};
3485
3486static const struct attribute_group *regulator_dev_groups[] = {
3487 &regulator_dev_group,
3488 NULL
3489};
3490
3491static void regulator_dev_release(struct device *dev)
3492{
3493 struct regulator_dev *rdev = dev_get_drvdata(dev);
3494 kfree(rdev);
3495}
3496
3497static struct class regulator_class = {
3498 .name = "regulator",
3499 .dev_release = regulator_dev_release,
3500 .dev_groups = regulator_dev_groups,
3501};
3502
Mark Brown1130e5b2010-12-21 23:49:31 +00003503static void rdev_init_debugfs(struct regulator_dev *rdev)
3504{
Mark Brown1130e5b2010-12-21 23:49:31 +00003505 rdev->debugfs = debugfs_create_dir(rdev_get_name(rdev), debugfs_root);
Stephen Boyd24751432012-02-20 22:50:42 -08003506 if (!rdev->debugfs) {
Mark Brown1130e5b2010-12-21 23:49:31 +00003507 rdev_warn(rdev, "Failed to create debugfs directory\n");
Mark Brown1130e5b2010-12-21 23:49:31 +00003508 return;
3509 }
3510
3511 debugfs_create_u32("use_count", 0444, rdev->debugfs,
3512 &rdev->use_count);
3513 debugfs_create_u32("open_count", 0444, rdev->debugfs,
3514 &rdev->open_count);
Mark Brownf59c8f92012-08-31 10:36:37 -07003515 debugfs_create_u32("bypass_count", 0444, rdev->debugfs,
3516 &rdev->bypass_count);
Mark Brown1130e5b2010-12-21 23:49:31 +00003517}
3518
Liam Girdwood414c70c2008-04-30 15:59:04 +01003519/**
3520 * regulator_register - register regulator
Mark Brown69279fb2008-12-31 12:52:41 +00003521 * @regulator_desc: regulator to register
Krzysztof Kozlowskif47531b2015-01-12 09:01:39 +01003522 * @cfg: runtime configuration for regulator
Liam Girdwood414c70c2008-04-30 15:59:04 +01003523 *
3524 * Called by regulator drivers to register a regulator.
Axel Lin03846182013-01-03 21:01:47 +08003525 * Returns a valid pointer to struct regulator_dev on success
3526 * or an ERR_PTR() on error.
Liam Girdwood414c70c2008-04-30 15:59:04 +01003527 */
Mark Brown65f26842012-04-03 20:46:53 +01003528struct regulator_dev *
3529regulator_register(const struct regulator_desc *regulator_desc,
Krzysztof Kozlowski1b3de222015-01-05 12:48:41 +01003530 const struct regulator_config *cfg)
Liam Girdwood414c70c2008-04-30 15:59:04 +01003531{
Mark Brown9a8f5e02011-11-29 18:11:19 +00003532 const struct regulation_constraints *constraints = NULL;
Mark Brownc1727082012-04-04 00:50:22 +01003533 const struct regulator_init_data *init_data;
Krzysztof Kozlowski1b3de222015-01-05 12:48:41 +01003534 struct regulator_config *config = NULL;
Aniroop Mathur72dca062014-12-28 22:08:38 +05303535 static atomic_t regulator_no = ATOMIC_INIT(-1);
Liam Girdwood414c70c2008-04-30 15:59:04 +01003536 struct regulator_dev *rdev;
Mark Brown32c8fad2012-04-11 10:19:12 +01003537 struct device *dev;
Liam Girdwooda5766f12008-10-10 13:22:20 +01003538 int ret, i;
Rajendra Nayak69511a42011-11-18 16:47:20 +05303539 const char *supply = NULL;
Liam Girdwood414c70c2008-04-30 15:59:04 +01003540
Krzysztof Kozlowski1b3de222015-01-05 12:48:41 +01003541 if (regulator_desc == NULL || cfg == NULL)
Liam Girdwood414c70c2008-04-30 15:59:04 +01003542 return ERR_PTR(-EINVAL);
3543
Krzysztof Kozlowski1b3de222015-01-05 12:48:41 +01003544 dev = cfg->dev;
Mark Browndcf70112012-05-08 18:09:12 +01003545 WARN_ON(!dev);
Mark Brown32c8fad2012-04-11 10:19:12 +01003546
Liam Girdwood414c70c2008-04-30 15:59:04 +01003547 if (regulator_desc->name == NULL || regulator_desc->ops == NULL)
3548 return ERR_PTR(-EINVAL);
3549
Diego Lizierocd78dfc2009-04-14 03:04:47 +02003550 if (regulator_desc->type != REGULATOR_VOLTAGE &&
3551 regulator_desc->type != REGULATOR_CURRENT)
Liam Girdwood414c70c2008-04-30 15:59:04 +01003552 return ERR_PTR(-EINVAL);
3553
Mark Brown476c2d82010-12-10 17:28:07 +00003554 /* Only one of each should be implemented */
3555 WARN_ON(regulator_desc->ops->get_voltage &&
3556 regulator_desc->ops->get_voltage_sel);
Mark Browne8eef822010-12-12 14:36:17 +00003557 WARN_ON(regulator_desc->ops->set_voltage &&
3558 regulator_desc->ops->set_voltage_sel);
Mark Brown476c2d82010-12-10 17:28:07 +00003559
3560 /* If we're using selectors we must implement list_voltage. */
3561 if (regulator_desc->ops->get_voltage_sel &&
3562 !regulator_desc->ops->list_voltage) {
3563 return ERR_PTR(-EINVAL);
3564 }
Mark Browne8eef822010-12-12 14:36:17 +00003565 if (regulator_desc->ops->set_voltage_sel &&
3566 !regulator_desc->ops->list_voltage) {
3567 return ERR_PTR(-EINVAL);
3568 }
Mark Brown476c2d82010-12-10 17:28:07 +00003569
Liam Girdwood414c70c2008-04-30 15:59:04 +01003570 rdev = kzalloc(sizeof(struct regulator_dev), GFP_KERNEL);
3571 if (rdev == NULL)
3572 return ERR_PTR(-ENOMEM);
3573
Krzysztof Kozlowski1b3de222015-01-05 12:48:41 +01003574 /*
3575 * Duplicate the config so the driver could override it after
3576 * parsing init data.
3577 */
3578 config = kmemdup(cfg, sizeof(*cfg), GFP_KERNEL);
3579 if (config == NULL) {
3580 kfree(rdev);
3581 return ERR_PTR(-ENOMEM);
3582 }
3583
Krzysztof Kozlowskibfa21a02015-01-05 12:48:42 +01003584 init_data = regulator_of_get_init_data(dev, regulator_desc, config,
Mark Browna0c7b162014-09-09 23:13:57 +01003585 &rdev->dev.of_node);
3586 if (!init_data) {
3587 init_data = config->init_data;
3588 rdev->dev.of_node = of_node_get(config->of_node);
3589 }
3590
Liam Girdwood414c70c2008-04-30 15:59:04 +01003591 mutex_lock(&regulator_list_mutex);
3592
3593 mutex_init(&rdev->mutex);
Mark Brownc1727082012-04-04 00:50:22 +01003594 rdev->reg_data = config->driver_data;
Liam Girdwood414c70c2008-04-30 15:59:04 +01003595 rdev->owner = regulator_desc->owner;
3596 rdev->desc = regulator_desc;
Mark Brown3a4b0a02012-05-08 18:10:45 +01003597 if (config->regmap)
3598 rdev->regmap = config->regmap;
AnilKumar Ch52b84da2012-09-07 20:45:05 +05303599 else if (dev_get_regmap(dev, NULL))
Mark Brown3a4b0a02012-05-08 18:10:45 +01003600 rdev->regmap = dev_get_regmap(dev, NULL);
AnilKumar Ch52b84da2012-09-07 20:45:05 +05303601 else if (dev->parent)
3602 rdev->regmap = dev_get_regmap(dev->parent, NULL);
Liam Girdwood414c70c2008-04-30 15:59:04 +01003603 INIT_LIST_HEAD(&rdev->consumer_list);
Liam Girdwood414c70c2008-04-30 15:59:04 +01003604 INIT_LIST_HEAD(&rdev->list);
Liam Girdwood414c70c2008-04-30 15:59:04 +01003605 BLOCKING_INIT_NOTIFIER_HEAD(&rdev->notifier);
Mark Brownda07ecd2011-09-11 09:53:50 +01003606 INIT_DELAYED_WORK(&rdev->disable_work, regulator_disable_work);
Liam Girdwood414c70c2008-04-30 15:59:04 +01003607
Liam Girdwooda5766f12008-10-10 13:22:20 +01003608 /* preform any regulator specific init */
Mark Brown9a8f5e02011-11-29 18:11:19 +00003609 if (init_data && init_data->regulator_init) {
Liam Girdwooda5766f12008-10-10 13:22:20 +01003610 ret = init_data->regulator_init(rdev->reg_data);
David Brownell4fca9542008-11-11 17:38:53 -08003611 if (ret < 0)
3612 goto clean;
Liam Girdwooda5766f12008-10-10 13:22:20 +01003613 }
Liam Girdwood414c70c2008-04-30 15:59:04 +01003614
Liam Girdwooda5766f12008-10-10 13:22:20 +01003615 /* register with sysfs */
3616 rdev->dev.class = &regulator_class;
3617 rdev->dev.parent = dev;
Aniroop Mathur72dca062014-12-28 22:08:38 +05303618 dev_set_name(&rdev->dev, "regulator.%lu",
Aniroop Mathur39138812014-12-29 22:36:48 +05303619 (unsigned long) atomic_inc_return(&regulator_no));
Liam Girdwooda5766f12008-10-10 13:22:20 +01003620 ret = device_register(&rdev->dev);
Vasiliy Kulikovad7725c2010-09-19 16:55:01 +04003621 if (ret != 0) {
3622 put_device(&rdev->dev);
David Brownell4fca9542008-11-11 17:38:53 -08003623 goto clean;
Vasiliy Kulikovad7725c2010-09-19 16:55:01 +04003624 }
Liam Girdwooda5766f12008-10-10 13:22:20 +01003625
3626 dev_set_drvdata(&rdev->dev, rdev);
3627
Markus Pargmann76f439d2014-10-08 15:47:05 +02003628 if ((config->ena_gpio || config->ena_gpio_initialized) &&
3629 gpio_is_valid(config->ena_gpio)) {
Kim, Milof19b00d2013-02-18 06:50:39 +00003630 ret = regulator_ena_gpio_request(rdev, config);
Mark Brown65f73502012-06-27 14:14:38 +01003631 if (ret != 0) {
3632 rdev_err(rdev, "Failed to request enable GPIO%d: %d\n",
3633 config->ena_gpio, ret);
Andrew Lunnb2da55d2012-10-28 16:01:11 +01003634 goto wash;
Mark Brown65f73502012-06-27 14:14:38 +01003635 }
3636
Mark Brown65f73502012-06-27 14:14:38 +01003637 if (config->ena_gpio_flags & GPIOF_OUT_INIT_HIGH)
3638 rdev->ena_gpio_state = 1;
3639
Kim, Milo7b74d142013-02-18 06:50:55 +00003640 if (config->ena_gpio_invert)
Mark Brown65f73502012-06-27 14:14:38 +01003641 rdev->ena_gpio_state = !rdev->ena_gpio_state;
3642 }
3643
Mike Rapoport74f544c2008-11-25 14:53:53 +02003644 /* set regulator constraints */
Mark Brown9a8f5e02011-11-29 18:11:19 +00003645 if (init_data)
3646 constraints = &init_data->constraints;
3647
3648 ret = set_machine_constraints(rdev, constraints);
Mike Rapoport74f544c2008-11-25 14:53:53 +02003649 if (ret < 0)
3650 goto scrub;
3651
Mark Brown9a8f5e02011-11-29 18:11:19 +00003652 if (init_data && init_data->supply_regulator)
Rajendra Nayak69511a42011-11-18 16:47:20 +05303653 supply = init_data->supply_regulator;
3654 else if (regulator_desc->supply_name)
3655 supply = regulator_desc->supply_name;
3656
3657 if (supply) {
Mark Brown0178f3e2010-04-26 15:18:14 +01003658 struct regulator_dev *r;
Mark Brown0178f3e2010-04-26 15:18:14 +01003659
Mark Brown6d191a52012-03-29 14:19:02 +01003660 r = regulator_dev_lookup(dev, supply, &ret);
Mark Brown0178f3e2010-04-26 15:18:14 +01003661
Andrew Bresticker0f7b87f2013-04-04 15:27:47 -07003662 if (ret == -ENODEV) {
3663 /*
3664 * No supply was specified for this regulator and
3665 * there will never be one.
3666 */
3667 ret = 0;
3668 goto add_dev;
3669 } else if (!r) {
Rajendra Nayak69511a42011-11-18 16:47:20 +05303670 dev_err(dev, "Failed to find supply %s\n", supply);
Mark Brown04bf3012012-03-11 13:07:56 +00003671 ret = -EPROBE_DEFER;
Mark Brown0178f3e2010-04-26 15:18:14 +01003672 goto scrub;
3673 }
3674
3675 ret = set_supply(rdev, r);
3676 if (ret < 0)
3677 goto scrub;
Laxman Dewanganb2296bd2012-01-02 13:08:45 +05303678
3679 /* Enable supply if rail is enabled */
Mark Brownb1a86832012-05-14 00:40:14 +01003680 if (_regulator_is_enabled(rdev)) {
Laxman Dewanganb2296bd2012-01-02 13:08:45 +05303681 ret = regulator_enable(rdev->supply);
3682 if (ret < 0)
3683 goto scrub;
3684 }
Mark Brown0178f3e2010-04-26 15:18:14 +01003685 }
3686
Andrew Bresticker0f7b87f2013-04-04 15:27:47 -07003687add_dev:
Liam Girdwooda5766f12008-10-10 13:22:20 +01003688 /* add consumers devices */
Mark Brown9a8f5e02011-11-29 18:11:19 +00003689 if (init_data) {
3690 for (i = 0; i < init_data->num_consumer_supplies; i++) {
3691 ret = set_consumer_device_supply(rdev,
Mark Brown9a8f5e02011-11-29 18:11:19 +00003692 init_data->consumer_supplies[i].dev_name,
Mark Brown23c2f042011-02-24 17:39:09 +00003693 init_data->consumer_supplies[i].supply);
Mark Brown9a8f5e02011-11-29 18:11:19 +00003694 if (ret < 0) {
3695 dev_err(dev, "Failed to set supply %s\n",
3696 init_data->consumer_supplies[i].supply);
3697 goto unset_supplies;
3698 }
Mark Brown23c2f042011-02-24 17:39:09 +00003699 }
Liam Girdwooda5766f12008-10-10 13:22:20 +01003700 }
3701
3702 list_add(&rdev->list, &regulator_list);
Mark Brown1130e5b2010-12-21 23:49:31 +00003703
3704 rdev_init_debugfs(rdev);
Liam Girdwooda5766f12008-10-10 13:22:20 +01003705out:
Liam Girdwood414c70c2008-04-30 15:59:04 +01003706 mutex_unlock(&regulator_list_mutex);
Krzysztof Kozlowski1b3de222015-01-05 12:48:41 +01003707 kfree(config);
Liam Girdwood414c70c2008-04-30 15:59:04 +01003708 return rdev;
David Brownell4fca9542008-11-11 17:38:53 -08003709
Jani Nikulad4033b52010-04-29 10:55:11 +03003710unset_supplies:
3711 unset_regulator_supplies(rdev);
3712
David Brownell4fca9542008-11-11 17:38:53 -08003713scrub:
Mark Browne81dba852012-05-13 18:35:56 +01003714 if (rdev->supply)
Charles Keepax23ff2f02012-11-14 09:39:31 +00003715 _regulator_put(rdev->supply);
Kim, Milof19b00d2013-02-18 06:50:39 +00003716 regulator_ena_gpio_free(rdev);
Axel Lin1a6958e72011-07-15 10:50:43 +08003717 kfree(rdev->constraints);
Andrew Lunnb2da55d2012-10-28 16:01:11 +01003718wash:
David Brownell4fca9542008-11-11 17:38:53 -08003719 device_unregister(&rdev->dev);
Paul Walmsley53032da2009-04-25 05:28:36 -06003720 /* device core frees rdev */
3721 rdev = ERR_PTR(ret);
3722 goto out;
3723
David Brownell4fca9542008-11-11 17:38:53 -08003724clean:
3725 kfree(rdev);
3726 rdev = ERR_PTR(ret);
3727 goto out;
Liam Girdwood414c70c2008-04-30 15:59:04 +01003728}
3729EXPORT_SYMBOL_GPL(regulator_register);
3730
3731/**
3732 * regulator_unregister - unregister regulator
Mark Brown69279fb2008-12-31 12:52:41 +00003733 * @rdev: regulator to unregister
Liam Girdwood414c70c2008-04-30 15:59:04 +01003734 *
3735 * Called by regulator drivers to unregister a regulator.
3736 */
3737void regulator_unregister(struct regulator_dev *rdev)
3738{
3739 if (rdev == NULL)
3740 return;
3741
Mark Brown891636e2013-07-08 09:14:45 +01003742 if (rdev->supply) {
3743 while (rdev->use_count--)
3744 regulator_disable(rdev->supply);
Mark Browne032b372012-03-28 21:17:55 +01003745 regulator_put(rdev->supply);
Mark Brown891636e2013-07-08 09:14:45 +01003746 }
Liam Girdwood414c70c2008-04-30 15:59:04 +01003747 mutex_lock(&regulator_list_mutex);
Mark Brown1130e5b2010-12-21 23:49:31 +00003748 debugfs_remove_recursive(rdev->debugfs);
Tejun Heo43829732012-08-20 14:51:24 -07003749 flush_work(&rdev->disable_work.work);
Mark Brown6bf87d12009-07-21 16:00:25 +01003750 WARN_ON(rdev->open_count);
Mike Rapoport0f1d7472009-01-22 16:00:29 +02003751 unset_regulator_supplies(rdev);
Liam Girdwood414c70c2008-04-30 15:59:04 +01003752 list_del(&rdev->list);
Mark Brownf8c12fe2010-11-29 15:55:17 +00003753 kfree(rdev->constraints);
Kim, Milof19b00d2013-02-18 06:50:39 +00003754 regulator_ena_gpio_free(rdev);
Charles Keepax63c7c9e2014-04-03 15:32:17 +01003755 of_node_put(rdev->dev.of_node);
Lothar Waßmann58fb5cf2011-11-28 15:38:37 +01003756 device_unregister(&rdev->dev);
Liam Girdwood414c70c2008-04-30 15:59:04 +01003757 mutex_unlock(&regulator_list_mutex);
3758}
3759EXPORT_SYMBOL_GPL(regulator_unregister);
3760
3761/**
Mark Browncf7bbcd2008-12-31 12:52:43 +00003762 * regulator_suspend_prepare - prepare regulators for system wide suspend
Liam Girdwood414c70c2008-04-30 15:59:04 +01003763 * @state: system suspend state
3764 *
3765 * Configure each regulator with it's suspend operating parameters for state.
3766 * This will usually be called by machine suspend code prior to supending.
3767 */
3768int regulator_suspend_prepare(suspend_state_t state)
3769{
3770 struct regulator_dev *rdev;
3771 int ret = 0;
3772
3773 /* ON is handled by regulator active state */
3774 if (state == PM_SUSPEND_ON)
3775 return -EINVAL;
3776
3777 mutex_lock(&regulator_list_mutex);
3778 list_for_each_entry(rdev, &regulator_list, list) {
3779
3780 mutex_lock(&rdev->mutex);
3781 ret = suspend_prepare(rdev, state);
3782 mutex_unlock(&rdev->mutex);
3783
3784 if (ret < 0) {
Joe Perches5da84fd2010-11-30 05:53:48 -08003785 rdev_err(rdev, "failed to prepare\n");
Liam Girdwood414c70c2008-04-30 15:59:04 +01003786 goto out;
3787 }
3788 }
3789out:
3790 mutex_unlock(&regulator_list_mutex);
3791 return ret;
3792}
3793EXPORT_SYMBOL_GPL(regulator_suspend_prepare);
3794
3795/**
MyungJoo Ham7a32b582011-03-11 10:13:59 +09003796 * regulator_suspend_finish - resume regulators from system wide suspend
3797 *
3798 * Turn on regulators that might be turned off by regulator_suspend_prepare
3799 * and that should be turned on according to the regulators properties.
3800 */
3801int regulator_suspend_finish(void)
3802{
3803 struct regulator_dev *rdev;
3804 int ret = 0, error;
3805
3806 mutex_lock(&regulator_list_mutex);
3807 list_for_each_entry(rdev, &regulator_list, list) {
MyungJoo Ham7a32b582011-03-11 10:13:59 +09003808 mutex_lock(&rdev->mutex);
Markus Pargmann30c21972014-02-20 17:36:03 +01003809 if (rdev->use_count > 0 || rdev->constraints->always_on) {
3810 error = _regulator_do_enable(rdev);
MyungJoo Ham7a32b582011-03-11 10:13:59 +09003811 if (error)
3812 ret = error;
3813 } else {
Mark Brown87b28412013-11-27 16:13:10 +00003814 if (!have_full_constraints())
MyungJoo Ham7a32b582011-03-11 10:13:59 +09003815 goto unlock;
Mark Brownb1a86832012-05-14 00:40:14 +01003816 if (!_regulator_is_enabled(rdev))
MyungJoo Ham7a32b582011-03-11 10:13:59 +09003817 goto unlock;
3818
Markus Pargmann66fda752014-02-20 17:36:04 +01003819 error = _regulator_do_disable(rdev);
MyungJoo Ham7a32b582011-03-11 10:13:59 +09003820 if (error)
3821 ret = error;
3822 }
3823unlock:
3824 mutex_unlock(&rdev->mutex);
3825 }
3826 mutex_unlock(&regulator_list_mutex);
3827 return ret;
3828}
3829EXPORT_SYMBOL_GPL(regulator_suspend_finish);
3830
3831/**
Mark Brownca725562009-03-16 19:36:34 +00003832 * regulator_has_full_constraints - the system has fully specified constraints
3833 *
3834 * Calling this function will cause the regulator API to disable all
3835 * regulators which have a zero use count and don't have an always_on
3836 * constraint in a late_initcall.
3837 *
3838 * The intention is that this will become the default behaviour in a
3839 * future kernel release so users are encouraged to use this facility
3840 * now.
3841 */
3842void regulator_has_full_constraints(void)
3843{
3844 has_full_constraints = 1;
3845}
3846EXPORT_SYMBOL_GPL(regulator_has_full_constraints);
3847
3848/**
Liam Girdwood414c70c2008-04-30 15:59:04 +01003849 * rdev_get_drvdata - get rdev regulator driver data
Mark Brown69279fb2008-12-31 12:52:41 +00003850 * @rdev: regulator
Liam Girdwood414c70c2008-04-30 15:59:04 +01003851 *
3852 * Get rdev regulator driver private data. This call can be used in the
3853 * regulator driver context.
3854 */
3855void *rdev_get_drvdata(struct regulator_dev *rdev)
3856{
3857 return rdev->reg_data;
3858}
3859EXPORT_SYMBOL_GPL(rdev_get_drvdata);
3860
3861/**
3862 * regulator_get_drvdata - get regulator driver data
3863 * @regulator: regulator
3864 *
3865 * Get regulator driver private data. This call can be used in the consumer
3866 * driver context when non API regulator specific functions need to be called.
3867 */
3868void *regulator_get_drvdata(struct regulator *regulator)
3869{
3870 return regulator->rdev->reg_data;
3871}
3872EXPORT_SYMBOL_GPL(regulator_get_drvdata);
3873
3874/**
3875 * regulator_set_drvdata - set regulator driver data
3876 * @regulator: regulator
3877 * @data: data
3878 */
3879void regulator_set_drvdata(struct regulator *regulator, void *data)
3880{
3881 regulator->rdev->reg_data = data;
3882}
3883EXPORT_SYMBOL_GPL(regulator_set_drvdata);
3884
3885/**
3886 * regulator_get_id - get regulator ID
Mark Brown69279fb2008-12-31 12:52:41 +00003887 * @rdev: regulator
Liam Girdwood414c70c2008-04-30 15:59:04 +01003888 */
3889int rdev_get_id(struct regulator_dev *rdev)
3890{
3891 return rdev->desc->id;
3892}
3893EXPORT_SYMBOL_GPL(rdev_get_id);
3894
Liam Girdwooda5766f12008-10-10 13:22:20 +01003895struct device *rdev_get_dev(struct regulator_dev *rdev)
3896{
3897 return &rdev->dev;
3898}
3899EXPORT_SYMBOL_GPL(rdev_get_dev);
3900
3901void *regulator_get_init_drvdata(struct regulator_init_data *reg_init_data)
3902{
3903 return reg_init_data->driver_data;
3904}
3905EXPORT_SYMBOL_GPL(regulator_get_init_drvdata);
3906
Mark Brownba55a972011-08-23 17:39:10 +01003907#ifdef CONFIG_DEBUG_FS
3908static ssize_t supply_map_read_file(struct file *file, char __user *user_buf,
3909 size_t count, loff_t *ppos)
3910{
3911 char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
3912 ssize_t len, ret = 0;
3913 struct regulator_map *map;
3914
3915 if (!buf)
3916 return -ENOMEM;
3917
3918 list_for_each_entry(map, &regulator_map_list, list) {
3919 len = snprintf(buf + ret, PAGE_SIZE - ret,
3920 "%s -> %s.%s\n",
3921 rdev_get_name(map->regulator), map->dev_name,
3922 map->supply);
3923 if (len >= 0)
3924 ret += len;
3925 if (ret > PAGE_SIZE) {
3926 ret = PAGE_SIZE;
3927 break;
3928 }
3929 }
3930
3931 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
3932
3933 kfree(buf);
3934
3935 return ret;
3936}
Stephen Boyd24751432012-02-20 22:50:42 -08003937#endif
Mark Brownba55a972011-08-23 17:39:10 +01003938
3939static const struct file_operations supply_map_fops = {
Stephen Boyd24751432012-02-20 22:50:42 -08003940#ifdef CONFIG_DEBUG_FS
Mark Brownba55a972011-08-23 17:39:10 +01003941 .read = supply_map_read_file,
3942 .llseek = default_llseek,
Mark Brownba55a972011-08-23 17:39:10 +01003943#endif
Stephen Boyd24751432012-02-20 22:50:42 -08003944};
Mark Brownba55a972011-08-23 17:39:10 +01003945
Liam Girdwood414c70c2008-04-30 15:59:04 +01003946static int __init regulator_init(void)
3947{
Mark Brown34abbd62010-02-12 10:18:08 +00003948 int ret;
3949
Mark Brown34abbd62010-02-12 10:18:08 +00003950 ret = class_register(&regulator_class);
3951
Mark Brown1130e5b2010-12-21 23:49:31 +00003952 debugfs_root = debugfs_create_dir("regulator", NULL);
Stephen Boyd24751432012-02-20 22:50:42 -08003953 if (!debugfs_root)
Mark Brown1130e5b2010-12-21 23:49:31 +00003954 pr_warn("regulator: Failed to create debugfs directory\n");
Mark Brownba55a972011-08-23 17:39:10 +01003955
Mark Brownf4d562c2012-02-20 21:01:04 +00003956 debugfs_create_file("supply_map", 0444, debugfs_root, NULL,
3957 &supply_map_fops);
Mark Brown1130e5b2010-12-21 23:49:31 +00003958
Mark Brown34abbd62010-02-12 10:18:08 +00003959 regulator_dummy_init();
3960
3961 return ret;
Liam Girdwood414c70c2008-04-30 15:59:04 +01003962}
3963
3964/* init early to allow our consumers to complete system booting */
3965core_initcall(regulator_init);
Mark Brownca725562009-03-16 19:36:34 +00003966
3967static int __init regulator_init_complete(void)
3968{
3969 struct regulator_dev *rdev;
Guodong Xu272e2312014-08-13 19:33:38 +08003970 const struct regulator_ops *ops;
Mark Brownca725562009-03-16 19:36:34 +00003971 struct regulation_constraints *c;
3972 int enabled, ret;
Mark Brownca725562009-03-16 19:36:34 +00003973
Mark Brown86f5fcf2012-07-06 18:19:13 +01003974 /*
3975 * Since DT doesn't provide an idiomatic mechanism for
3976 * enabling full constraints and since it's much more natural
3977 * with DT to provide them just assume that a DT enabled
3978 * system has full constraints.
3979 */
3980 if (of_have_populated_dt())
3981 has_full_constraints = true;
3982
Mark Brownca725562009-03-16 19:36:34 +00003983 mutex_lock(&regulator_list_mutex);
3984
3985 /* If we have a full configuration then disable any regulators
Mark Browne9535832014-06-01 19:15:16 +01003986 * we have permission to change the status for and which are
3987 * not in use or always_on. This is effectively the default
3988 * for DT and ACPI as they have full constraints.
Mark Brownca725562009-03-16 19:36:34 +00003989 */
3990 list_for_each_entry(rdev, &regulator_list, list) {
3991 ops = rdev->desc->ops;
3992 c = rdev->constraints;
3993
Markus Pargmann66fda752014-02-20 17:36:04 +01003994 if (c && c->always_on)
Mark Brownca725562009-03-16 19:36:34 +00003995 continue;
3996
Mark Browne9535832014-06-01 19:15:16 +01003997 if (c && !(c->valid_ops_mask & REGULATOR_CHANGE_STATUS))
3998 continue;
3999
Mark Brownca725562009-03-16 19:36:34 +00004000 mutex_lock(&rdev->mutex);
4001
4002 if (rdev->use_count)
4003 goto unlock;
4004
4005 /* If we can't read the status assume it's on. */
4006 if (ops->is_enabled)
4007 enabled = ops->is_enabled(rdev);
4008 else
4009 enabled = 1;
4010
4011 if (!enabled)
4012 goto unlock;
4013
Mark Brown87b28412013-11-27 16:13:10 +00004014 if (have_full_constraints()) {
Mark Brownca725562009-03-16 19:36:34 +00004015 /* We log since this may kill the system if it
4016 * goes wrong. */
Joe Perches5da84fd2010-11-30 05:53:48 -08004017 rdev_info(rdev, "disabling\n");
Markus Pargmann66fda752014-02-20 17:36:04 +01004018 ret = _regulator_do_disable(rdev);
Jingoo Han0d25d092014-01-08 10:02:16 +09004019 if (ret != 0)
Joe Perches5da84fd2010-11-30 05:53:48 -08004020 rdev_err(rdev, "couldn't disable: %d\n", ret);
Mark Brownca725562009-03-16 19:36:34 +00004021 } else {
4022 /* The intention is that in future we will
4023 * assume that full constraints are provided
4024 * so warn even if we aren't going to do
4025 * anything here.
4026 */
Joe Perches5da84fd2010-11-30 05:53:48 -08004027 rdev_warn(rdev, "incomplete constraints, leaving on\n");
Mark Brownca725562009-03-16 19:36:34 +00004028 }
4029
4030unlock:
4031 mutex_unlock(&rdev->mutex);
4032 }
4033
4034 mutex_unlock(&regulator_list_mutex);
4035
4036 return 0;
4037}
Saravana Kannanfd482a32014-04-23 18:10:50 -05004038late_initcall_sync(regulator_init_complete);