projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge remote-tracking branch 'asoc/topic/core' into asoc-next
[deliverable/linux.git] / drivers / regulator / core.c
CommitLineData
414c70cb
LG		 1/*
2 * core.c -- Voltage/Current Regulator framework.
3 *
4 * Copyright 2007, 2008 Wolfson Microelectronics PLC.
a5766f11 5 * Copyright 2008 SlimLogic Ltd.
414c70cb 6 *
a5766f11 7 * Author: Liam Girdwood <lrg@slimlogic.co.uk>
414c70cb
LG		 8 *
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License as published by the
11 * Free Software Foundation; either version 2 of the License, or (at your
12 * option) any later version.
13 *
14 */
15
16#include <linux/kernel.h>
17#include <linux/init.h>
1130e5b3 18#include <linux/debugfs.h>
414c70cb 19#include <linux/device.h>
5a0e3ad6 20#include <linux/slab.h>
f21e0e81 21#include <linux/async.h>
414c70cb
LG		 22#include <linux/err.h>
23#include <linux/mutex.h>
24#include <linux/suspend.h>
31aae2be 25#include <linux/delay.h>
65f73508 26#include <linux/gpio.h>
69511a45 27#include <linux/of.h>
65b19ce6 28#include <linux/regmap.h>
69511a45 29#include <linux/regulator/of_regulator.h>
414c70cb
LG		 30#include <linux/regulator/consumer.h>
31#include <linux/regulator/driver.h>
32#include <linux/regulator/machine.h>
65602c32 33#include <linux/module.h>
414c70cb 34
02fa3ec0
MB		 35#define CREATE_TRACE_POINTS
36#include <trace/events/regulator.h>
37
34abbd68
MB		 38#include "dummy.h"
39
7d51a0db
MB		 40#define rdev_crit(rdev, fmt, ...) \
41 pr_crit("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
5da84fd9
JP		 42#define rdev_err(rdev, fmt, ...) \
43 pr_err("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
44#define rdev_warn(rdev, fmt, ...) \
45 pr_warn("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
46#define rdev_info(rdev, fmt, ...) \
47 pr_info("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
48#define rdev_dbg(rdev, fmt, ...) \
49 pr_debug("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
50
414c70cb
LG		 51static DEFINE_MUTEX(regulator_list_mutex);
52static LIST_HEAD(regulator_list);
53static LIST_HEAD(regulator_map_list);
f19b00da 54static LIST_HEAD(regulator_ena_gpio_list);
21cf891a 55static bool has_full_constraints;
688fe99a 56static bool board_wants_dummy_regulator;
414c70cb 57
1130e5b3 58static struct dentry *debugfs_root;
1130e5b3 59
8dc5390d 60/*
414c70cb
LG		 61 * struct regulator_map
62 *
63 * Used to provide symbolic supply names to devices.
64 */
65struct regulator_map {
66 struct list_head list;
40f9244f 67 const char *dev_name; /* The dev_name() for the consumer */
414c70cb 68 const char *supply;
a5766f11 69 struct regulator_dev *regulator;
414c70cb
LG		 70};
71
f19b00da
KM		 72/*
73 * struct regulator_enable_gpio
74 *
75 * Management for shared enable GPIO pin
76 */
77struct regulator_enable_gpio {
78 struct list_head list;
79 int gpio;
80 u32 enable_count; /* a number of enabled shared GPIO */
81 u32 request_count; /* a number of requested shared GPIO */
82 unsigned int ena_gpio_invert:1;
83};
84
414c70cb
LG		 85/*
86 * struct regulator
87 *
88 * One for each consumer device.
89 */
90struct regulator {
91 struct device *dev;
92 struct list_head list;
6492bc1b 93 unsigned int always_on:1;
f59c8f9f 94 unsigned int bypass:1;
414c70cb
LG		 95 int uA_load;
96 int min_uV;
97 int max_uV;
414c70cb
LG		 98 char *supply_name;
99 struct device_attribute dev_attr;
100 struct regulator_dev *rdev;
5de70519 101 struct dentry *debugfs;
414c70cb
LG		 102};
103
104static int _regulator_is_enabled(struct regulator_dev *rdev);
3801b86a 105static int _regulator_disable(struct regulator_dev *rdev);
414c70cb
LG		 106static int _regulator_get_voltage(struct regulator_dev *rdev);
107static int _regulator_get_current_limit(struct regulator_dev *rdev);
108static unsigned int _regulator_get_mode(struct regulator_dev *rdev);
109static void _notifier_call_chain(struct regulator_dev *rdev,
110 unsigned long event, void *data);
75790251
MB		 111static int _regulator_do_set_voltage(struct regulator_dev *rdev,
112 int min_uV, int max_uV);
3801b86a
MB		 113static struct regulator *create_regulator(struct regulator_dev *rdev,
114 struct device *dev,
115 const char *supply_name);
414c70cb 116
1083c393
MB		 117static const char *rdev_get_name(struct regulator_dev *rdev)
118{
119 if (rdev->constraints && rdev->constraints->name)
120 return rdev->constraints->name;
121 else if (rdev->desc->name)
122 return rdev->desc->name;
123 else
124 return "";
125}
126
69511a45
RN		 127/**
128 * of_get_regulator - get a regulator device node based on supply name
129 * @dev: Device pointer for the consumer (of regulator) device
130 * @supply: regulator supply name
131 *
132 * Extract the regulator device node corresponding to the supply name.
167d41dc 133 * returns the device node corresponding to the regulator if found, else
69511a45
RN		 134 * returns NULL.
135 */
136static struct device_node *of_get_regulator(struct device *dev, const char *supply)
137{
138 struct device_node *regnode = NULL;
139 char prop_name[32]; /* 32 is max size of property name */
140
141 dev_dbg(dev, "Looking up %s-supply from device tree\n", supply);
142
143 snprintf(prop_name, 32, "%s-supply", supply);
144 regnode = of_parse_phandle(dev->of_node, prop_name, 0);
145
146 if (!regnode) {
16fbcc3b 147 dev_dbg(dev, "Looking up %s property in node %s failed",
69511a45
RN		 148 prop_name, dev->of_node->full_name);
149 return NULL;
150 }
151 return regnode;
152}
153
6492bc1b
MB		 154static int _regulator_can_change_status(struct regulator_dev *rdev)
155{
156 if (!rdev->constraints)
157 return 0;
158
159 if (rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_STATUS)
160 return 1;
161 else
162 return 0;
163}
164
414c70cb
LG		 165/* Platform voltage constraint check */
166static int regulator_check_voltage(struct regulator_dev *rdev,
167 int *min_uV, int *max_uV)
168{
169 BUG_ON(*min_uV > *max_uV);
170
171 if (!rdev->constraints) {
5da84fd9 172 rdev_err(rdev, "no constraints\n");
414c70cb
LG		 173 return -ENODEV;
174 }
175 if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) {
5da84fd9 176 rdev_err(rdev, "operation not allowed\n");
414c70cb
LG		 177 return -EPERM;
178 }
179
180 if (*max_uV > rdev->constraints->max_uV)
181 *max_uV = rdev->constraints->max_uV;
182 if (*min_uV < rdev->constraints->min_uV)
183 *min_uV = rdev->constraints->min_uV;
184
89f425ed
MB		 185 if (*min_uV > *max_uV) {
186 rdev_err(rdev, "unsupportable voltage range: %d-%duV\n",
54abd335 187 *min_uV, *max_uV);
414c70cb 188 return -EINVAL;
89f425ed 189 }
414c70cb
LG		 190
191 return 0;
192}
193
05fda3b1
TP		 194/* Make sure we select a voltage that suits the needs of all
195 * regulator consumers
196 */
197static int regulator_check_consumers(struct regulator_dev *rdev,
198 int *min_uV, int *max_uV)
199{
200 struct regulator *regulator;
201
202 list_for_each_entry(regulator, &rdev->consumer_list, list) {
4aa922c0
MB		 203 /*
204 * Assume consumers that didn't say anything are OK
205 * with anything in the constraint range.
206 */
207 if (!regulator->min_uV && !regulator->max_uV)
208 continue;
209
05fda3b1
TP		 210 if (*max_uV > regulator->max_uV)
211 *max_uV = regulator->max_uV;
212 if (*min_uV < regulator->min_uV)
213 *min_uV = regulator->min_uV;
214 }
215
dd8004af 216 if (*min_uV > *max_uV) {
9c7b4e8a
RD		 217 rdev_err(rdev, "Restricting voltage, %u-%uuV\n",
218 *min_uV, *max_uV);
05fda3b1 219 return -EINVAL;
dd8004af 220 }
05fda3b1
TP		 221
222 return 0;
223}
224
414c70cb
LG		 225/* current constraint check */
226static int regulator_check_current_limit(struct regulator_dev *rdev,
227 int *min_uA, int *max_uA)
228{
229 BUG_ON(*min_uA > *max_uA);
230
231 if (!rdev->constraints) {
5da84fd9 232 rdev_err(rdev, "no constraints\n");
414c70cb
LG		 233 return -ENODEV;
234 }
235 if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_CURRENT)) {
5da84fd9 236 rdev_err(rdev, "operation not allowed\n");
414c70cb
LG		 237 return -EPERM;
238 }
239
240 if (*max_uA > rdev->constraints->max_uA)
241 *max_uA = rdev->constraints->max_uA;
242 if (*min_uA < rdev->constraints->min_uA)
243 *min_uA = rdev->constraints->min_uA;
244
89f425ed
MB		 245 if (*min_uA > *max_uA) {
246 rdev_err(rdev, "unsupportable current range: %d-%duA\n",
54abd335 247 *min_uA, *max_uA);
414c70cb 248 return -EINVAL;
89f425ed 249 }
414c70cb
LG		 250
251 return 0;
252}
253
254/* operating mode constraint check */
2c608234 255static int regulator_mode_constrain(struct regulator_dev *rdev, int *mode)
414c70cb 256{
2c608234 257 switch (*mode) {
e573520b
DB		 258 case REGULATOR_MODE_FAST:
259 case REGULATOR_MODE_NORMAL:
260 case REGULATOR_MODE_IDLE:
261 case REGULATOR_MODE_STANDBY:
262 break;
263 default:
89f425ed 264 rdev_err(rdev, "invalid mode %x specified\n", *mode);
e573520b
DB		 265 return -EINVAL;
266 }
267
414c70cb 268 if (!rdev->constraints) {
5da84fd9 269 rdev_err(rdev, "no constraints\n");
414c70cb
LG		 270 return -ENODEV;
271 }
272 if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_MODE)) {
5da84fd9 273 rdev_err(rdev, "operation not allowed\n");
414c70cb
LG		 274 return -EPERM;
275 }
2c608234
MB		 276
277 /* The modes are bitmasks, the most power hungry modes having
278 * the lowest values. If the requested mode isn't supported
279 * try higher modes. */
280 while (*mode) {
281 if (rdev->constraints->valid_modes_mask & *mode)
282 return 0;
283 *mode /= 2;
414c70cb 284 }
2c608234
MB		 285
286 return -EINVAL;
414c70cb
LG		 287}
288
289/* dynamic regulator mode switching constraint check */
290static int regulator_check_drms(struct regulator_dev *rdev)
291{
292 if (!rdev->constraints) {
5da84fd9 293 rdev_err(rdev, "no constraints\n");
414c70cb
LG		 294 return -ENODEV;
295 }
296 if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_DRMS)) {
5da84fd9 297 rdev_err(rdev, "operation not allowed\n");
414c70cb
LG		 298 return -EPERM;
299 }
300 return 0;
301}
302
414c70cb
LG		 303static ssize_t regulator_uV_show(struct device *dev,
304 struct device_attribute *attr, char *buf)
305{
a5766f11 306 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb
LG		 307 ssize_t ret;
308
309 mutex_lock(&rdev->mutex);
310 ret = sprintf(buf, "%d\n", _regulator_get_voltage(rdev));
311 mutex_unlock(&rdev->mutex);
312
313 return ret;
314}
7ad68e2f 315static DEVICE_ATTR(microvolts, 0444, regulator_uV_show, NULL);
414c70cb
LG		 316
317static ssize_t regulator_uA_show(struct device *dev,
318 struct device_attribute *attr, char *buf)
319{
a5766f11 320 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb
LG		 321
322 return sprintf(buf, "%d\n", _regulator_get_current_limit(rdev));
323}
7ad68e2f 324static DEVICE_ATTR(microamps, 0444, regulator_uA_show, NULL);
414c70cb 325
587cea27
GKH		 326static ssize_t name_show(struct device *dev, struct device_attribute *attr,
327 char *buf)
bc558a60
MB		 328{
329 struct regulator_dev *rdev = dev_get_drvdata(dev);
bc558a60 330
1083c393 331 return sprintf(buf, "%s\n", rdev_get_name(rdev));
bc558a60 332}
587cea27 333static DEVICE_ATTR_RO(name);
bc558a60 334
4fca9545 335static ssize_t regulator_print_opmode(char *buf, int mode)
414c70cb 336{
414c70cb
LG		 337 switch (mode) {
338 case REGULATOR_MODE_FAST:
339 return sprintf(buf, "fast\n");
340 case REGULATOR_MODE_NORMAL:
341 return sprintf(buf, "normal\n");
342 case REGULATOR_MODE_IDLE:
343 return sprintf(buf, "idle\n");
344 case REGULATOR_MODE_STANDBY:
345 return sprintf(buf, "standby\n");
346 }
347 return sprintf(buf, "unknown\n");
348}
349
4fca9545
DB		 350static ssize_t regulator_opmode_show(struct device *dev,
351 struct device_attribute *attr, char *buf)
414c70cb 352{
a5766f11 353 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb 354
4fca9545
DB		 355 return regulator_print_opmode(buf, _regulator_get_mode(rdev));
356}
7ad68e2f 357static DEVICE_ATTR(opmode, 0444, regulator_opmode_show, NULL);
4fca9545
DB		 358
359static ssize_t regulator_print_state(char *buf, int state)
360{
414c70cb
LG		 361 if (state > 0)
362 return sprintf(buf, "enabled\n");
363 else if (state == 0)
364 return sprintf(buf, "disabled\n");
365 else
366 return sprintf(buf, "unknown\n");
367}
368
4fca9545
DB		 369static ssize_t regulator_state_show(struct device *dev,
370 struct device_attribute *attr, char *buf)
371{
372 struct regulator_dev *rdev = dev_get_drvdata(dev);
9332546f
MB		 373 ssize_t ret;
374
375 mutex_lock(&rdev->mutex);
376 ret = regulator_print_state(buf, _regulator_is_enabled(rdev));
377 mutex_unlock(&rdev->mutex);
4fca9545 378
9332546f 379 return ret;
4fca9545 380}
7ad68e2f 381static DEVICE_ATTR(state, 0444, regulator_state_show, NULL);
4fca9545 382
853116a1
DB		 383static ssize_t regulator_status_show(struct device *dev,
384 struct device_attribute *attr, char *buf)
385{
386 struct regulator_dev *rdev = dev_get_drvdata(dev);
387 int status;
388 char *label;
389
390 status = rdev->desc->ops->get_status(rdev);
391 if (status < 0)
392 return status;
393
394 switch (status) {
395 case REGULATOR_STATUS_OFF:
396 label = "off";
397 break;
398 case REGULATOR_STATUS_ON:
399 label = "on";
400 break;
401 case REGULATOR_STATUS_ERROR:
402 label = "error";
403 break;
404 case REGULATOR_STATUS_FAST:
405 label = "fast";
406 break;
407 case REGULATOR_STATUS_NORMAL:
408 label = "normal";
409 break;
410 case REGULATOR_STATUS_IDLE:
411 label = "idle";
412 break;
413 case REGULATOR_STATUS_STANDBY:
414 label = "standby";
415 break;
f59c8f9f
MB		 416 case REGULATOR_STATUS_BYPASS:
417 label = "bypass";
418 break;
1beaf762
KG		 419 case REGULATOR_STATUS_UNDEFINED:
420 label = "undefined";
421 break;
853116a1
DB		 422 default:
423 return -ERANGE;
424 }
425
426 return sprintf(buf, "%s\n", label);
427}
428static DEVICE_ATTR(status, 0444, regulator_status_show, NULL);
429
414c70cb
LG		 430static ssize_t regulator_min_uA_show(struct device *dev,
431 struct device_attribute *attr, char *buf)
432{
a5766f11 433 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb
LG		 434
435 if (!rdev->constraints)
436 return sprintf(buf, "constraint not defined\n");
437
438 return sprintf(buf, "%d\n", rdev->constraints->min_uA);
439}
7ad68e2f 440static DEVICE_ATTR(min_microamps, 0444, regulator_min_uA_show, NULL);
414c70cb
LG		 441
442static ssize_t regulator_max_uA_show(struct device *dev,
443 struct device_attribute *attr, char *buf)
444{
a5766f11 445 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb
LG		 446
447 if (!rdev->constraints)
448 return sprintf(buf, "constraint not defined\n");
449
450 return sprintf(buf, "%d\n", rdev->constraints->max_uA);
451}
7ad68e2f 452static DEVICE_ATTR(max_microamps, 0444, regulator_max_uA_show, NULL);
414c70cb
LG		 453
454static ssize_t regulator_min_uV_show(struct device *dev,
455 struct device_attribute *attr, char *buf)
456{
a5766f11 457 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb
LG		 458
459 if (!rdev->constraints)
460 return sprintf(buf, "constraint not defined\n");
461
462 return sprintf(buf, "%d\n", rdev->constraints->min_uV);
463}
7ad68e2f 464static DEVICE_ATTR(min_microvolts, 0444, regulator_min_uV_show, NULL);
414c70cb
LG		 465
466static ssize_t regulator_max_uV_show(struct device *dev,
467 struct device_attribute *attr, char *buf)
468{
a5766f11 469 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb
LG		 470
471 if (!rdev->constraints)
472 return sprintf(buf, "constraint not defined\n");
473
474 return sprintf(buf, "%d\n", rdev->constraints->max_uV);
475}
7ad68e2f 476static DEVICE_ATTR(max_microvolts, 0444, regulator_max_uV_show, NULL);
414c70cb
LG		 477
478static ssize_t regulator_total_uA_show(struct device *dev,
479 struct device_attribute *attr, char *buf)
480{
a5766f11 481 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb
LG		 482 struct regulator *regulator;
483 int uA = 0;
484
485 mutex_lock(&rdev->mutex);
486 list_for_each_entry(regulator, &rdev->consumer_list, list)
fa2984d4 487 uA += regulator->uA_load;
414c70cb
LG		 488 mutex_unlock(&rdev->mutex);
489 return sprintf(buf, "%d\n", uA);
490}
7ad68e2f 491static DEVICE_ATTR(requested_microamps, 0444, regulator_total_uA_show, NULL);
414c70cb 492
587cea27
GKH		 493static ssize_t num_users_show(struct device *dev, struct device_attribute *attr,
494 char *buf)
414c70cb 495{
a5766f11 496 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb
LG		 497 return sprintf(buf, "%d\n", rdev->use_count);
498}
587cea27 499static DEVICE_ATTR_RO(num_users);
414c70cb 500
587cea27
GKH		 501static ssize_t type_show(struct device *dev, struct device_attribute *attr,
502 char *buf)
414c70cb 503{
a5766f11 504 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb
LG		 505
506 switch (rdev->desc->type) {
507 case REGULATOR_VOLTAGE:
508 return sprintf(buf, "voltage\n");
509 case REGULATOR_CURRENT:
510 return sprintf(buf, "current\n");
511 }
512 return sprintf(buf, "unknown\n");
513}
587cea27 514static DEVICE_ATTR_RO(type);
414c70cb
LG		 515
516static ssize_t regulator_suspend_mem_uV_show(struct device *dev,
517 struct device_attribute *attr, char *buf)
518{
a5766f11 519 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb 520
414c70cb
LG		 521 return sprintf(buf, "%d\n", rdev->constraints->state_mem.uV);
522}
7ad68e2f
DB		 523static DEVICE_ATTR(suspend_mem_microvolts, 0444,
524 regulator_suspend_mem_uV_show, NULL);
414c70cb
LG		 525
526static ssize_t regulator_suspend_disk_uV_show(struct device *dev,
527 struct device_attribute *attr, char *buf)
528{
a5766f11 529 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb 530
414c70cb
LG		 531 return sprintf(buf, "%d\n", rdev->constraints->state_disk.uV);
532}
7ad68e2f
DB		 533static DEVICE_ATTR(suspend_disk_microvolts, 0444,
534 regulator_suspend_disk_uV_show, NULL);
414c70cb
LG		 535
536static ssize_t regulator_suspend_standby_uV_show(struct device *dev,
537 struct device_attribute *attr, char *buf)
538{
a5766f11 539 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb 540
414c70cb
LG		 541 return sprintf(buf, "%d\n", rdev->constraints->state_standby.uV);
542}
7ad68e2f
DB		 543static DEVICE_ATTR(suspend_standby_microvolts, 0444,
544 regulator_suspend_standby_uV_show, NULL);
414c70cb 545
414c70cb
LG		 546static ssize_t regulator_suspend_mem_mode_show(struct device *dev,
547 struct device_attribute *attr, char *buf)
548{
a5766f11 549 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb 550
4fca9545
DB		 551 return regulator_print_opmode(buf,
552 rdev->constraints->state_mem.mode);
414c70cb 553}
7ad68e2f
DB		 554static DEVICE_ATTR(suspend_mem_mode, 0444,
555 regulator_suspend_mem_mode_show, NULL);
414c70cb
LG		 556
557static ssize_t regulator_suspend_disk_mode_show(struct device *dev,
558 struct device_attribute *attr, char *buf)
559{
a5766f11 560 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb 561
4fca9545
DB		 562 return regulator_print_opmode(buf,
563 rdev->constraints->state_disk.mode);
414c70cb 564}
7ad68e2f
DB		 565static DEVICE_ATTR(suspend_disk_mode, 0444,
566 regulator_suspend_disk_mode_show, NULL);
414c70cb
LG		 567
568static ssize_t regulator_suspend_standby_mode_show(struct device *dev,
569 struct device_attribute *attr, char *buf)
570{
a5766f11 571 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb 572
4fca9545
DB		 573 return regulator_print_opmode(buf,
574 rdev->constraints->state_standby.mode);
414c70cb 575}
7ad68e2f
DB		 576static DEVICE_ATTR(suspend_standby_mode, 0444,
577 regulator_suspend_standby_mode_show, NULL);
414c70cb
LG		 578
579static ssize_t regulator_suspend_mem_state_show(struct device *dev,
580 struct device_attribute *attr, char *buf)
581{
a5766f11 582 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb 583
4fca9545
DB		 584 return regulator_print_state(buf,
585 rdev->constraints->state_mem.enabled);
414c70cb 586}
7ad68e2f
DB		 587static DEVICE_ATTR(suspend_mem_state, 0444,
588 regulator_suspend_mem_state_show, NULL);
414c70cb
LG		 589
590static ssize_t regulator_suspend_disk_state_show(struct device *dev,
591 struct device_attribute *attr, char *buf)
592{
a5766f11 593 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb 594
4fca9545
DB		 595 return regulator_print_state(buf,
596 rdev->constraints->state_disk.enabled);
414c70cb 597}
7ad68e2f
DB		 598static DEVICE_ATTR(suspend_disk_state, 0444,
599 regulator_suspend_disk_state_show, NULL);
414c70cb
LG		 600
601static ssize_t regulator_suspend_standby_state_show(struct device *dev,
602 struct device_attribute *attr, char *buf)
603{
a5766f11 604 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb 605
4fca9545
DB		 606 return regulator_print_state(buf,
607 rdev->constraints->state_standby.enabled);
414c70cb 608}
7ad68e2f
DB		 609static DEVICE_ATTR(suspend_standby_state, 0444,
610 regulator_suspend_standby_state_show, NULL);
611
f59c8f9f
MB		 612static ssize_t regulator_bypass_show(struct device *dev,
613 struct device_attribute *attr, char *buf)
614{
615 struct regulator_dev *rdev = dev_get_drvdata(dev);
616 const char *report;
617 bool bypass;
618 int ret;
619
620 ret = rdev->desc->ops->get_bypass(rdev, &bypass);
621
622 if (ret != 0)
623 report = "unknown";
624 else if (bypass)
625 report = "enabled";
626 else
627 report = "disabled";
628
629 return sprintf(buf, "%s\n", report);
630}
631static DEVICE_ATTR(bypass, 0444,
632 regulator_bypass_show, NULL);
bc558a60 633
7ad68e2f
DB		 634/*
635 * These are the only attributes are present for all regulators.
636 * Other attributes are a function of regulator functionality.
637 */
587cea27
GKH		 638static struct attribute *regulator_dev_attrs[] = {
639 &dev_attr_name.attr,
640 &dev_attr_num_users.attr,
641 &dev_attr_type.attr,
642 NULL,
414c70cb 643};
587cea27 644ATTRIBUTE_GROUPS(regulator_dev);
414c70cb
LG		 645
646static void regulator_dev_release(struct device *dev)
647{
a5766f11 648 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb
LG		 649 kfree(rdev);
650}
651
652static struct class regulator_class = {
653 .name = "regulator",
654 .dev_release = regulator_dev_release,
587cea27 655 .dev_groups = regulator_dev_groups,
414c70cb
LG		 656};
657
658/* Calculate the new optimum regulator operating mode based on the new total
659 * consumer load. All locks held by caller */
660static void drms_uA_update(struct regulator_dev *rdev)
661{
662 struct regulator *sibling;
663 int current_uA = 0, output_uV, input_uV, err;
664 unsigned int mode;
665
666 err = regulator_check_drms(rdev);
667 if (err < 0 || !rdev->desc->ops->get_optimum_mode ||
476c2d83
MB		 668 (!rdev->desc->ops->get_voltage &&
669 !rdev->desc->ops->get_voltage_sel) ||
670 !rdev->desc->ops->set_mode)
036de8ef 671 return;
414c70cb
LG		 672
673 /* get output voltage */
1bf5a1f8 674 output_uV = _regulator_get_voltage(rdev);
414c70cb
LG		 675 if (output_uV <= 0)
676 return;
677
678 /* get input voltage */
1bf5a1f8
MB		 679 input_uV = 0;
680 if (rdev->supply)
3f24f5ad 681 input_uV = regulator_get_voltage(rdev->supply);
1bf5a1f8 682 if (input_uV <= 0)
414c70cb
LG		 683 input_uV = rdev->constraints->input_uV;
684 if (input_uV <= 0)
685 return;
686
687 /* calc total requested load */
688 list_for_each_entry(sibling, &rdev->consumer_list, list)
fa2984d4 689 current_uA += sibling->uA_load;
414c70cb
LG		 690
691 /* now get the optimum mode for our new total regulator load */
692 mode = rdev->desc->ops->get_optimum_mode(rdev, input_uV,
693 output_uV, current_uA);
694
695 /* check the new mode is allowed */
2c608234 696 err = regulator_mode_constrain(rdev, &mode);
414c70cb
LG		 697 if (err == 0)
698 rdev->desc->ops->set_mode(rdev, mode);
699}
700
701static int suspend_set_state(struct regulator_dev *rdev,
702 struct regulator_state *rstate)
703{
704 int ret = 0;
638f85c5
MB		 705
706 /* If we have no suspend mode configration don't set anything;
8ac0e95d
AL		 707 * only warn if the driver implements set_suspend_voltage or
708 * set_suspend_mode callback.
638f85c5
MB		 709 */
710 if (!rstate->enabled && !rstate->disabled) {
8ac0e95d
AL		 711 if (rdev->desc->ops->set_suspend_voltage ||
712 rdev->desc->ops->set_suspend_mode)
5da84fd9 713 rdev_warn(rdev, "No configuration\n");
638f85c5
MB		 714 return 0;
715 }
716
717 if (rstate->enabled && rstate->disabled) {
5da84fd9 718 rdev_err(rdev, "invalid configuration\n");
638f85c5
MB		 719 return -EINVAL;
720 }
414c70cb 721
8ac0e95d 722 if (rstate->enabled && rdev->desc->ops->set_suspend_enable)
414c70cb 723 ret = rdev->desc->ops->set_suspend_enable(rdev);
8ac0e95d 724 else if (rstate->disabled && rdev->desc->ops->set_suspend_disable)
414c70cb 725 ret = rdev->desc->ops->set_suspend_disable(rdev);
8ac0e95d
AL		 726 else /* OK if set_suspend_enable or set_suspend_disable is NULL */
727 ret = 0;
728
414c70cb 729 if (ret < 0) {
5da84fd9 730 rdev_err(rdev, "failed to enabled/disable\n");
414c70cb
LG		 731 return ret;
732 }
733
734 if (rdev->desc->ops->set_suspend_voltage && rstate->uV > 0) {
735 ret = rdev->desc->ops->set_suspend_voltage(rdev, rstate->uV);
736 if (ret < 0) {
5da84fd9 737 rdev_err(rdev, "failed to set voltage\n");
414c70cb
LG		 738 return ret;
739 }
740 }
741
742 if (rdev->desc->ops->set_suspend_mode && rstate->mode > 0) {
743 ret = rdev->desc->ops->set_suspend_mode(rdev, rstate->mode);
744 if (ret < 0) {
5da84fd9 745 rdev_err(rdev, "failed to set mode\n");
414c70cb
LG		 746 return ret;
747 }
748 }
749 return ret;
750}
751
752/* locks held by caller */
753static int suspend_prepare(struct regulator_dev *rdev, suspend_state_t state)
754{
755 if (!rdev->constraints)
756 return -EINVAL;
757
758 switch (state) {
759 case PM_SUSPEND_STANDBY:
760 return suspend_set_state(rdev,
761 &rdev->constraints->state_standby);
762 case PM_SUSPEND_MEM:
763 return suspend_set_state(rdev,
764 &rdev->constraints->state_mem);
765 case PM_SUSPEND_MAX:
766 return suspend_set_state(rdev,
767 &rdev->constraints->state_disk);
768 default:
769 return -EINVAL;
770 }
771}
772
773static void print_constraints(struct regulator_dev *rdev)
774{
775 struct regulation_constraints *constraints = rdev->constraints;
973e9a27 776 char buf[80] = "";
8f031b48
MB		 777 int count = 0;
778 int ret;
414c70cb 779
8f031b48 780 if (constraints->min_uV && constraints->max_uV) {
414c70cb 781 if (constraints->min_uV == constraints->max_uV)
8f031b48
MB		 782 count += sprintf(buf + count, "%d mV ",
783 constraints->min_uV / 1000);
414c70cb 784 else
8f031b48
MB		 785 count += sprintf(buf + count, "%d <--> %d mV ",
786 constraints->min_uV / 1000,
787 constraints->max_uV / 1000);
788 }
789
790 if (!constraints->min_uV ||
791 constraints->min_uV != constraints->max_uV) {
792 ret = _regulator_get_voltage(rdev);
793 if (ret > 0)
794 count += sprintf(buf + count, "at %d mV ", ret / 1000);
795 }
796
bf5892a8
MB		 797 if (constraints->uV_offset)
798 count += sprintf(buf, "%dmV offset ",
799 constraints->uV_offset / 1000);
800
8f031b48 801 if (constraints->min_uA && constraints->max_uA) {
414c70cb 802 if (constraints->min_uA == constraints->max_uA)
8f031b48
MB		 803 count += sprintf(buf + count, "%d mA ",
804 constraints->min_uA / 1000);
414c70cb 805 else
8f031b48
MB		 806 count += sprintf(buf + count, "%d <--> %d mA ",
807 constraints->min_uA / 1000,
808 constraints->max_uA / 1000);
809 }
810
811 if (!constraints->min_uA ||
812 constraints->min_uA != constraints->max_uA) {
813 ret = _regulator_get_current_limit(rdev);
814 if (ret > 0)
e4a6376b 815 count += sprintf(buf + count, "at %d mA ", ret / 1000);
414c70cb 816 }
8f031b48 817
414c70cb
LG		 818 if (constraints->valid_modes_mask & REGULATOR_MODE_FAST)
819 count += sprintf(buf + count, "fast ");
820 if (constraints->valid_modes_mask & REGULATOR_MODE_NORMAL)
821 count += sprintf(buf + count, "normal ");
822 if (constraints->valid_modes_mask & REGULATOR_MODE_IDLE)
823 count += sprintf(buf + count, "idle ");
824 if (constraints->valid_modes_mask & REGULATOR_MODE_STANDBY)
825 count += sprintf(buf + count, "standby");
826
215b8b05
UKK		 827 if (!count)
828 sprintf(buf, "no parameters");
829
13ce29f8 830 rdev_info(rdev, "%s\n", buf);
4a682922
MB		 831
832 if ((constraints->min_uV != constraints->max_uV) &&
833 !(constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE))
834 rdev_warn(rdev,
835 "Voltage range but no REGULATOR_CHANGE_VOLTAGE\n");
414c70cb
LG		 836}
837
e79055d6 838static int machine_constraints_voltage(struct regulator_dev *rdev,
1083c393 839 struct regulation_constraints *constraints)
a5766f11 840{
e5fda26c 841 struct regulator_ops *ops = rdev->desc->ops;
af5866c9
MB		 842 int ret;
843
844 /* do we need to apply the constraint voltage */
845 if (rdev->constraints->apply_uV &&
75790251
MB		 846 rdev->constraints->min_uV == rdev->constraints->max_uV) {
847 ret = _regulator_do_set_voltage(rdev,
848 rdev->constraints->min_uV,
849 rdev->constraints->max_uV);
850 if (ret < 0) {
851 rdev_err(rdev, "failed to apply %duV constraint\n",
852 rdev->constraints->min_uV);
75790251
MB		 853 return ret;
854 }
af5866c9 855 }
e06f5b4f 856
4367cfdc
DB		 857 /* constrain machine-level voltage specs to fit
858 * the actual range supported by this regulator.
859 */
860 if (ops->list_voltage && rdev->desc->n_voltages) {
861 int count = rdev->desc->n_voltages;
862 int i;
863 int min_uV = INT_MAX;
864 int max_uV = INT_MIN;
865 int cmin = constraints->min_uV;
866 int cmax = constraints->max_uV;
867
3e590918
MB		 868 /* it's safe to autoconfigure fixed-voltage supplies
869 and the constraints are used by list_voltage. */
4367cfdc 870 if (count == 1 && !cmin) {
3e590918 871 cmin = 1;
4367cfdc 872 cmax = INT_MAX;
3e590918
MB		 873 constraints->min_uV = cmin;
874 constraints->max_uV = cmax;
4367cfdc
DB		 875 }
876
3e2b9abd
MB		 877 /* voltage constraints are optional */
878 if ((cmin == 0) && (cmax == 0))
e79055d6 879 return 0;
3e2b9abd 880
4367cfdc 881 /* else require explicit machine-level constraints */
3e2b9abd 882 if (cmin <= 0 || cmax <= 0 || cmax < cmin) {
5da84fd9 883 rdev_err(rdev, "invalid voltage constraints\n");
e79055d6 884 return -EINVAL;
4367cfdc
DB		 885 }
886
887 /* initial: [cmin..cmax] valid, [min_uV..max_uV] not */
888 for (i = 0; i < count; i++) {
889 int value;
890
891 value = ops->list_voltage(rdev, i);
892 if (value <= 0)
893 continue;
894
895 /* maybe adjust [min_uV..max_uV] */
896 if (value >= cmin && value < min_uV)
897 min_uV = value;
898 if (value <= cmax && value > max_uV)
899 max_uV = value;
900 }
901
902 /* final: [min_uV..max_uV] valid iff constraints valid */
903 if (max_uV < min_uV) {
fff15bef
MB		 904 rdev_err(rdev,
905 "unsupportable voltage constraints %u-%uuV\n",
906 min_uV, max_uV);
e79055d6 907 return -EINVAL;
4367cfdc
DB		 908 }
909
910 /* use regulator's subset of machine constraints */
911 if (constraints->min_uV < min_uV) {
5da84fd9
JP		 912 rdev_dbg(rdev, "override min_uV, %d -> %d\n",
913 constraints->min_uV, min_uV);
4367cfdc
DB		 914 constraints->min_uV = min_uV;
915 }
916 if (constraints->max_uV > max_uV) {
5da84fd9
JP		 917 rdev_dbg(rdev, "override max_uV, %d -> %d\n",
918 constraints->max_uV, max_uV);
4367cfdc
DB		 919 constraints->max_uV = max_uV;
920 }
921 }
922
e79055d6
MB		 923 return 0;
924}
925
926/**
927 * set_machine_constraints - sets regulator constraints
928 * @rdev: regulator source
929 * @constraints: constraints to apply
930 *
931 * Allows platform initialisation code to define and constrain
932 * regulator circuits e.g. valid voltage/current ranges, etc. NOTE:
933 * Constraints *must* be set by platform code in order for some
934 * regulator operations to proceed i.e. set_voltage, set_current_limit,
935 * set_mode.
936 */
937static int set_machine_constraints(struct regulator_dev *rdev,
f8c12fe3 938 const struct regulation_constraints *constraints)
e79055d6
MB		 939{
940 int ret = 0;
e79055d6
MB		 941 struct regulator_ops *ops = rdev->desc->ops;
942
9a8f5e07
MB		 943 if (constraints)
944 rdev->constraints = kmemdup(constraints, sizeof(*constraints),
945 GFP_KERNEL);
946 else
947 rdev->constraints = kzalloc(sizeof(*constraints),
948 GFP_KERNEL);
f8c12fe3
MB		 949 if (!rdev->constraints)
950 return -ENOMEM;
af5866c9 951
f8c12fe3 952 ret = machine_constraints_voltage(rdev, rdev->constraints);
e79055d6
MB		 953 if (ret != 0)
954 goto out;
955
a5766f11 956 /* do we need to setup our suspend state */
9a8f5e07 957 if (rdev->constraints->initial_state) {
f8c12fe3 958 ret = suspend_prepare(rdev, rdev->constraints->initial_state);
e06f5b4f 959 if (ret < 0) {
5da84fd9 960 rdev_err(rdev, "failed to set suspend state\n");
e06f5b4f
MB		 961 goto out;
962 }
963 }
a5766f11 964
9a8f5e07 965 if (rdev->constraints->initial_mode) {
a308466c 966 if (!ops->set_mode) {
5da84fd9 967 rdev_err(rdev, "no set_mode operation\n");
a308466c
MB		 968 ret = -EINVAL;
969 goto out;
970 }
971
f8c12fe3 972 ret = ops->set_mode(rdev, rdev->constraints->initial_mode);
a308466c 973 if (ret < 0) {
5da84fd9 974 rdev_err(rdev, "failed to set initial mode: %d\n", ret);
a308466c
MB		 975 goto out;
976 }
977 }
978
cacf90f2
MB		 979 /* If the constraints say the regulator should be on at this point
980 * and we have control then make sure it is enabled.
981 */
f8c12fe3
MB		 982 if ((rdev->constraints->always_on || rdev->constraints->boot_on) &&
983 ops->enable) {
e5fda26c
MB		 984 ret = ops->enable(rdev);
985 if (ret < 0) {
5da84fd9 986 rdev_err(rdev, "failed to enable\n");
e5fda26c
MB		 987 goto out;
988 }
989 }
990
1653ccf4
YSB		 991 if ((rdev->constraints->ramp_delay || rdev->constraints->ramp_disable)
992 && ops->set_ramp_delay) {
6f0b2c69
YSB		 993 ret = ops->set_ramp_delay(rdev, rdev->constraints->ramp_delay);
994 if (ret < 0) {
995 rdev_err(rdev, "failed to set ramp_delay\n");
996 goto out;
997 }
998 }
999
a5766f11 1000 print_constraints(rdev);
1a6958e7 1001 return 0;
a5766f11 1002out:
1a6958e7
AL		 1003 kfree(rdev->constraints);
1004 rdev->constraints = NULL;
a5766f11
LG		 1005 return ret;
1006}
1007
1008/**
1009 * set_supply - set regulator supply regulator
69279fb9
MB		 1010 * @rdev: regulator name
1011 * @supply_rdev: supply regulator name
a5766f11
LG		 1012 *
1013 * Called by platform initialisation code to set the supply regulator for this
1014 * regulator. This ensures that a regulators supply will also be enabled by the
1015 * core if it's child is enabled.
1016 */
1017static int set_supply(struct regulator_dev *rdev,
3801b86a 1018 struct regulator_dev *supply_rdev)
a5766f11
LG		 1019{
1020 int err;
1021
3801b86a
MB		 1022 rdev_info(rdev, "supplied by %s\n", rdev_get_name(supply_rdev));
1023
1024 rdev->supply = create_regulator(supply_rdev, &rdev->dev, "SUPPLY");
32c78de8
AL		 1025 if (rdev->supply == NULL) {
1026 err = -ENOMEM;
3801b86a 1027 return err;
a5766f11 1028 }
57ad526a 1029 supply_rdev->open_count++;
3801b86a
MB		 1030
1031 return 0;
a5766f11
LG		 1032}
1033
1034/**
06c63f93 1035 * set_consumer_device_supply - Bind a regulator to a symbolic supply
69279fb9 1036 * @rdev: regulator source
40f9244f 1037 * @consumer_dev_name: dev_name() string for device supply applies to
69279fb9 1038 * @supply: symbolic name for supply
a5766f11
LG		 1039 *
1040 * Allows platform initialisation code to map physical regulator
1041 * sources to symbolic names for supplies for use by devices. Devices
1042 * should use these symbolic names to request regulators, avoiding the
1043 * need to provide board-specific regulator names as platform data.
1044 */
1045static int set_consumer_device_supply(struct regulator_dev *rdev,
737f360d
MB		 1046 const char *consumer_dev_name,
1047 const char *supply)
a5766f11
LG		 1048{
1049 struct regulator_map *node;
9ed2099e 1050 int has_dev;
a5766f11
LG		 1051
1052 if (supply == NULL)
1053 return -EINVAL;
1054
9ed2099e
MB		 1055 if (consumer_dev_name != NULL)
1056 has_dev = 1;
1057 else
1058 has_dev = 0;
1059
6001e13c 1060 list_for_each_entry(node, &regulator_map_list, list) {
23b5cc2a
JN		 1061 if (node->dev_name && consumer_dev_name) {
1062 if (strcmp(node->dev_name, consumer_dev_name) != 0)
1063 continue;
1064 } else if (node->dev_name || consumer_dev_name) {
6001e13c 1065 continue;
23b5cc2a
JN		 1066 }
1067
6001e13c
DB		 1068 if (strcmp(node->supply, supply) != 0)
1069 continue;
1070
737f360d
MB		 1071 pr_debug("%s: %s/%s is '%s' supply; fail %s/%s\n",
1072 consumer_dev_name,
1073 dev_name(&node->regulator->dev),
1074 node->regulator->desc->name,
1075 supply,
1076 dev_name(&rdev->dev), rdev_get_name(rdev));
6001e13c
DB		 1077 return -EBUSY;
1078 }
1079
9ed2099e 1080 node = kzalloc(sizeof(struct regulator_map), GFP_KERNEL);
a5766f11
LG		 1081 if (node == NULL)
1082 return -ENOMEM;
1083
1084 node->regulator = rdev;
a5766f11
LG		 1085 node->supply = supply;
1086
9ed2099e
MB		 1087 if (has_dev) {
1088 node->dev_name = kstrdup(consumer_dev_name, GFP_KERNEL);
1089 if (node->dev_name == NULL) {
1090 kfree(node);
1091 return -ENOMEM;
1092 }
40f9244f
MB		 1093 }
1094
a5766f11
LG		 1095 list_add(&node->list, &regulator_map_list);
1096 return 0;
1097}
1098
0f1d747b
MR		 1099static void unset_regulator_supplies(struct regulator_dev *rdev)
1100{
1101 struct regulator_map *node, *n;
1102
1103 list_for_each_entry_safe(node, n, &regulator_map_list, list) {
1104 if (rdev == node->regulator) {
1105 list_del(&node->list);
40f9244f 1106 kfree(node->dev_name);
0f1d747b 1107 kfree(node);
0f1d747b
MR		 1108 }
1109 }
1110}
1111
f5726ae3 1112#define REG_STR_SIZE 64
414c70cb
LG		 1113
1114static struct regulator *create_regulator(struct regulator_dev *rdev,
1115 struct device *dev,
1116 const char *supply_name)
1117{
1118 struct regulator *regulator;
1119 char buf[REG_STR_SIZE];
1120 int err, size;
1121
1122 regulator = kzalloc(sizeof(*regulator), GFP_KERNEL);
1123 if (regulator == NULL)
1124 return NULL;
1125
1126 mutex_lock(&rdev->mutex);
1127 regulator->rdev = rdev;
1128 list_add(&regulator->list, &rdev->consumer_list);
1129
1130 if (dev) {
e2c98eaf
SG		 1131 regulator->dev = dev;
1132
222cc7b1 1133 /* Add a link to the device sysfs entry */
414c70cb
LG		 1134 size = scnprintf(buf, REG_STR_SIZE, "%s-%s",
1135 dev->kobj.name, supply_name);
1136 if (size >= REG_STR_SIZE)
222cc7b1 1137 goto overflow_err;
414c70cb
LG		 1138
1139 regulator->supply_name = kstrdup(buf, GFP_KERNEL);
1140 if (regulator->supply_name == NULL)
222cc7b1 1141 goto overflow_err;
414c70cb
LG		 1142
1143 err = sysfs_create_link(&rdev->dev.kobj, &dev->kobj,
1144 buf);
1145 if (err) {
5da84fd9
JP		 1146 rdev_warn(rdev, "could not add device link %s err %d\n",
1147 dev->kobj.name, err);
222cc7b1 1148 /* non-fatal */
414c70cb 1149 }
5de70519
MB		 1150 } else {
1151 regulator->supply_name = kstrdup(supply_name, GFP_KERNEL);
1152 if (regulator->supply_name == NULL)
222cc7b1 1153 goto overflow_err;
5de70519
MB		 1154 }
1155
5de70519
MB		 1156 regulator->debugfs = debugfs_create_dir(regulator->supply_name,
1157 rdev->debugfs);
24751434 1158 if (!regulator->debugfs) {
5de70519 1159 rdev_warn(rdev, "Failed to create debugfs directory\n");
5de70519
MB		 1160 } else {
1161 debugfs_create_u32("uA_load", 0444, regulator->debugfs,
1162 &regulator->uA_load);
1163 debugfs_create_u32("min_uV", 0444, regulator->debugfs,
1164 &regulator->min_uV);
1165 debugfs_create_u32("max_uV", 0444, regulator->debugfs,
1166 &regulator->max_uV);
414c70cb 1167 }
5de70519 1168
6492bc1b
MB		 1169 /*
1170 * Check now if the regulator is an always on regulator - if
1171 * it is then we don't need to do nearly so much work for
1172 * enable/disable calls.
1173 */
1174 if (!_regulator_can_change_status(rdev) &&
1175 _regulator_is_enabled(rdev))
1176 regulator->always_on = true;
1177
414c70cb
LG		 1178 mutex_unlock(&rdev->mutex);
1179 return regulator;
414c70cb
LG		 1180overflow_err:
1181 list_del(&regulator->list);
1182 kfree(regulator);
1183 mutex_unlock(&rdev->mutex);
1184 return NULL;
1185}
1186
31aae2be
MB		 1187static int _regulator_get_enable_time(struct regulator_dev *rdev)
1188{
1189 if (!rdev->desc->ops->enable_time)
79511ed3 1190 return rdev->desc->enable_time;
31aae2be
MB		 1191 return rdev->desc->ops->enable_time(rdev);
1192}
1193
69511a45 1194static struct regulator_dev *regulator_dev_lookup(struct device *dev,
6d191a5f
MB		 1195 const char *supply,
1196 int *ret)
69511a45
RN		 1197{
1198 struct regulator_dev *r;
1199 struct device_node *node;
576ca436
MB		 1200 struct regulator_map *map;
1201 const char *devname = NULL;
69511a45
RN		 1202
1203 /* first do a dt based lookup */
1204 if (dev && dev->of_node) {
1205 node = of_get_regulator(dev, supply);
6d191a5f 1206 if (node) {
69511a45
RN		 1207 list_for_each_entry(r, &regulator_list, list)
1208 if (r->dev.parent &&
1209 node == r->dev.of_node)
1210 return r;
6d191a5f
MB		 1211 } else {
1212 /*
1213 * If we couldn't even get the node then it's
1214 * not just that the device didn't register
1215 * yet, there's no node and we'll never
1216 * succeed.
1217 */
1218 *ret = -ENODEV;
1219 }
69511a45
RN		 1220 }
1221
1222 /* if not found, try doing it non-dt way */
576ca436
MB		 1223 if (dev)
1224 devname = dev_name(dev);
1225
69511a45
RN		 1226 list_for_each_entry(r, &regulator_list, list)
1227 if (strcmp(rdev_get_name(r), supply) == 0)
1228 return r;
1229
576ca436
MB		 1230 list_for_each_entry(map, &regulator_map_list, list) {
1231 /* If the mapping has a device set up it must match */
1232 if (map->dev_name &&
1233 (!devname || strcmp(map->dev_name, devname)))
1234 continue;
1235
1236 if (strcmp(map->supply, supply) == 0)
1237 return map->regulator;
1238 }
1239
1240
69511a45
RN		 1241 return NULL;
1242}
1243
5ffbd136
MB		 1244/* Internal regulator request function */
1245static struct regulator *_regulator_get(struct device *dev, const char *id,
84fcf447 1246 bool exclusive)
414c70cb
LG		 1247{
1248 struct regulator_dev *rdev;
04bf3011 1249 struct regulator *regulator = ERR_PTR(-EPROBE_DEFER);
40f9244f 1250 const char *devname = NULL;
1e4b545c 1251 int ret = 0;
414c70cb
LG		 1252
1253 if (id == NULL) {
5da84fd9 1254 pr_err("get() with no identifier\n");
414c70cb
LG		 1255 return regulator;
1256 }
1257
40f9244f
MB		 1258 if (dev)
1259 devname = dev_name(dev);
1260
414c70cb
LG		 1261 mutex_lock(&regulator_list_mutex);
1262
6d191a5f 1263 rdev = regulator_dev_lookup(dev, id, &ret);
69511a45
RN		 1264 if (rdev)
1265 goto found;
1266
1e4b545c
NM		 1267 /*
1268 * If we have return value from dev_lookup fail, we do not expect to
1269 * succeed, so, quit with appropriate error value
1270 */
1271 if (ret) {
1272 regulator = ERR_PTR(ret);
1273 goto out;
1274 }
1275
688fe99a
MB		 1276 if (board_wants_dummy_regulator) {
1277 rdev = dummy_regulator_rdev;
1278 goto found;
1279 }
1280
34abbd68
MB		 1281#ifdef CONFIG_REGULATOR_DUMMY
1282 if (!devname)
1283 devname = "deviceless";
1284
1285 /* If the board didn't flag that it was fully constrained then
1286 * substitute in a dummy regulator so consumers can continue.
1287 */
1288 if (!has_full_constraints) {
5da84fd9
JP		 1289 pr_warn("%s supply %s not found, using dummy regulator\n",
1290 devname, id);
34abbd68
MB		 1291 rdev = dummy_regulator_rdev;
1292 goto found;
1293 }
1294#endif
1295
414c70cb
LG		 1296 mutex_unlock(&regulator_list_mutex);
1297 return regulator;
1298
1299found:
5ffbd136
MB		 1300 if (rdev->exclusive) {
1301 regulator = ERR_PTR(-EPERM);
1302 goto out;
1303 }
1304
1305 if (exclusive && rdev->open_count) {
1306 regulator = ERR_PTR(-EBUSY);
1307 goto out;
1308 }
1309
a5766f11
LG		 1310 if (!try_module_get(rdev->owner))
1311 goto out;
1312
414c70cb
LG		 1313 regulator = create_regulator(rdev, dev, id);
1314 if (regulator == NULL) {
1315 regulator = ERR_PTR(-ENOMEM);
1316 module_put(rdev->owner);
bcda4321 1317 goto out;
414c70cb
LG		 1318 }
1319
5ffbd136
MB		 1320 rdev->open_count++;
1321 if (exclusive) {
1322 rdev->exclusive = 1;
1323
1324 ret = _regulator_is_enabled(rdev);
1325 if (ret > 0)
1326 rdev->use_count = 1;
1327 else
1328 rdev->use_count = 0;
1329 }
1330
a5766f11 1331out:
414c70cb 1332 mutex_unlock(&regulator_list_mutex);
5ffbd136 1333
414c70cb
LG		 1334 return regulator;
1335}
5ffbd136
MB		 1336
1337/**
1338 * regulator_get - lookup and obtain a reference to a regulator.
1339 * @dev: device for regulator "consumer"
1340 * @id: Supply name or regulator ID.
1341 *
1342 * Returns a struct regulator corresponding to the regulator producer,
1343 * or IS_ERR() condition containing errno.
1344 *
1345 * Use of supply names configured via regulator_set_device_supply() is
1346 * strongly encouraged. It is recommended that the supply name used
1347 * should match the name used for the supply and/or the relevant
1348 * device pins in the datasheet.
1349 */
1350struct regulator *regulator_get(struct device *dev, const char *id)
1351{
84fcf447 1352 return _regulator_get(dev, id, false);
5ffbd136 1353}
414c70cb
LG		 1354EXPORT_SYMBOL_GPL(regulator_get);
1355
070b9079
SB		 1356static void devm_regulator_release(struct device *dev, void *res)
1357{
1358 regulator_put(*(struct regulator **)res);
1359}
1360
1361/**
1362 * devm_regulator_get - Resource managed regulator_get()
1363 * @dev: device for regulator "consumer"
1364 * @id: Supply name or regulator ID.
1365 *
1366 * Managed regulator_get(). Regulators returned from this function are
1367 * automatically regulator_put() on driver detach. See regulator_get() for more
1368 * information.
1369 */
1370struct regulator *devm_regulator_get(struct device *dev, const char *id)
1371{
1372 struct regulator **ptr, *regulator;
1373
1374 ptr = devres_alloc(devm_regulator_release, sizeof(*ptr), GFP_KERNEL);
1375 if (!ptr)
1376 return ERR_PTR(-ENOMEM);
1377
1378 regulator = regulator_get(dev, id);
1379 if (!IS_ERR(regulator)) {
1380 *ptr = regulator;
1381 devres_add(dev, ptr);
1382 } else {
1383 devres_free(ptr);
1384 }
1385
1386 return regulator;
1387}
1388EXPORT_SYMBOL_GPL(devm_regulator_get);
1389
5ffbd136
MB		 1390/**
1391 * regulator_get_exclusive - obtain exclusive access to a regulator.
1392 * @dev: device for regulator "consumer"
1393 * @id: Supply name or regulator ID.
1394 *
1395 * Returns a struct regulator corresponding to the regulator producer,
1396 * or IS_ERR() condition containing errno. Other consumers will be
1397 * unable to obtain this reference is held and the use count for the
1398 * regulator will be initialised to reflect the current state of the
1399 * regulator.
1400 *
1401 * This is intended for use by consumers which cannot tolerate shared
1402 * use of the regulator such as those which need to force the
1403 * regulator off for correct operation of the hardware they are
1404 * controlling.
1405 *
1406 * Use of supply names configured via regulator_set_device_supply() is
1407 * strongly encouraged. It is recommended that the supply name used
1408 * should match the name used for the supply and/or the relevant
1409 * device pins in the datasheet.
1410 */
1411struct regulator *regulator_get_exclusive(struct device *dev, const char *id)
1412{
84fcf447 1413 return _regulator_get(dev, id, true);
5ffbd136
MB		 1414}
1415EXPORT_SYMBOL_GPL(regulator_get_exclusive);
1416
de1dd9fd
MB		 1417/**
1418 * regulator_get_optional - obtain optional access to a regulator.
1419 * @dev: device for regulator "consumer"
1420 * @id: Supply name or regulator ID.
1421 *
1422 * Returns a struct regulator corresponding to the regulator producer,
1423 * or IS_ERR() condition containing errno. Other consumers will be
1424 * unable to obtain this reference is held and the use count for the
1425 * regulator will be initialised to reflect the current state of the
1426 * regulator.
1427 *
1428 * This is intended for use by consumers for devices which can have
1429 * some supplies unconnected in normal use, such as some MMC devices.
1430 * It can allow the regulator core to provide stub supplies for other
1431 * supplies requested using normal regulator_get() calls without
1432 * disrupting the operation of drivers that can handle absent
1433 * supplies.
1434 *
1435 * Use of supply names configured via regulator_set_device_supply() is
1436 * strongly encouraged. It is recommended that the supply name used
1437 * should match the name used for the supply and/or the relevant
1438 * device pins in the datasheet.
1439 */
1440struct regulator *regulator_get_optional(struct device *dev, const char *id)
1441{
1442 return _regulator_get(dev, id, 0);
1443}
1444EXPORT_SYMBOL_GPL(regulator_get_optional);
1445
1446/**
1447 * devm_regulator_get_optional - Resource managed regulator_get_optional()
1448 * @dev: device for regulator "consumer"
1449 * @id: Supply name or regulator ID.
1450 *
1451 * Managed regulator_get_optional(). Regulators returned from this
1452 * function are automatically regulator_put() on driver detach. See
1453 * regulator_get_optional() for more information.
1454 */
1455struct regulator *devm_regulator_get_optional(struct device *dev,
1456 const char *id)
1457{
1458 struct regulator **ptr, *regulator;
1459
1460 ptr = devres_alloc(devm_regulator_release, sizeof(*ptr), GFP_KERNEL);
1461 if (!ptr)
1462 return ERR_PTR(-ENOMEM);
1463
1464 regulator = regulator_get_optional(dev, id);
1465 if (!IS_ERR(regulator)) {
1466 *ptr = regulator;
1467 devres_add(dev, ptr);
1468 } else {
1469 devres_free(ptr);
1470 }
1471
1472 return regulator;
1473}
1474EXPORT_SYMBOL_GPL(devm_regulator_get_optional);
1475
23ff2f0f
CK		 1476/* Locks held by regulator_put() */
1477static void _regulator_put(struct regulator *regulator)
414c70cb
LG		 1478{
1479 struct regulator_dev *rdev;
1480
1481 if (regulator == NULL || IS_ERR(regulator))
1482 return;
1483
414c70cb
LG		 1484 rdev = regulator->rdev;
1485
5de70519 1486 debugfs_remove_recursive(regulator->debugfs);
5de70519 1487
414c70cb 1488 /* remove any sysfs entries */
e2c98eaf 1489 if (regulator->dev)
414c70cb 1490 sysfs_remove_link(&rdev->dev.kobj, regulator->supply_name);
5de70519 1491 kfree(regulator->supply_name);
414c70cb
LG		 1492 list_del(&regulator->list);
1493 kfree(regulator);
1494
5ffbd136
MB		 1495 rdev->open_count--;
1496 rdev->exclusive = 0;
1497
414c70cb 1498 module_put(rdev->owner);
23ff2f0f
CK		 1499}
1500
9efdd276
MK		 1501/**
1502 * devm_regulator_get_exclusive - Resource managed regulator_get_exclusive()
1503 * @dev: device for regulator "consumer"
1504 * @id: Supply name or regulator ID.
1505 *
1506 * Managed regulator_get_exclusive(). Regulators returned from this function
1507 * are automatically regulator_put() on driver detach. See regulator_get() for
1508 * more information.
1509 */
1510struct regulator *devm_regulator_get_exclusive(struct device *dev,
1511 const char *id)
1512{
1513 struct regulator **ptr, *regulator;
1514
1515 ptr = devres_alloc(devm_regulator_release, sizeof(*ptr), GFP_KERNEL);
1516 if (!ptr)
1517 return ERR_PTR(-ENOMEM);
1518
1519 regulator = _regulator_get(dev, id, 1);
1520 if (!IS_ERR(regulator)) {
1521 *ptr = regulator;
1522 devres_add(dev, ptr);
1523 } else {
1524 devres_free(ptr);
1525 }
1526
1527 return regulator;
1528}
1529EXPORT_SYMBOL_GPL(devm_regulator_get_exclusive);
1530
23ff2f0f
CK		 1531/**
1532 * regulator_put - "free" the regulator source
1533 * @regulator: regulator source
1534 *
1535 * Note: drivers must ensure that all regulator_enable calls made on this
1536 * regulator source are balanced by regulator_disable calls prior to calling
1537 * this function.
1538 */
1539void regulator_put(struct regulator *regulator)
1540{
1541 mutex_lock(&regulator_list_mutex);
1542 _regulator_put(regulator);
414c70cb
LG		 1543 mutex_unlock(&regulator_list_mutex);
1544}
1545EXPORT_SYMBOL_GPL(regulator_put);
1546
d5ad34f7
MB		 1547static int devm_regulator_match(struct device *dev, void *res, void *data)
1548{
1549 struct regulator **r = res;
1550 if (!r || !*r) {
1551 WARN_ON(!r || !*r);
1552 return 0;
1553 }
1554 return *r == data;
1555}
1556
1557/**
1558 * devm_regulator_put - Resource managed regulator_put()
1559 * @regulator: regulator to free
1560 *
1561 * Deallocate a regulator allocated with devm_regulator_get(). Normally
1562 * this function will not need to be called and the resource management
1563 * code will ensure that the resource is freed.
1564 */
1565void devm_regulator_put(struct regulator *regulator)
1566{
1567 int rc;
1568
361ff501 1569 rc = devres_release(regulator->dev, devm_regulator_release,
d5ad34f7 1570 devm_regulator_match, regulator);
230a5a1c 1571 if (rc != 0)
968c2c17 1572 WARN_ON(rc);
d5ad34f7
MB		 1573}
1574EXPORT_SYMBOL_GPL(devm_regulator_put);
1575
f19b00da
KM		 1576/* Manage enable GPIO list. Same GPIO pin can be shared among regulators */
1577static int regulator_ena_gpio_request(struct regulator_dev *rdev,
1578 const struct regulator_config *config)
1579{
1580 struct regulator_enable_gpio *pin;
1581 int ret;
1582
1583 list_for_each_entry(pin, &regulator_ena_gpio_list, list) {
1584 if (pin->gpio == config->ena_gpio) {
1585 rdev_dbg(rdev, "GPIO %d is already used\n",
1586 config->ena_gpio);
1587 goto update_ena_gpio_to_rdev;
1588 }
1589 }
1590
1591 ret = gpio_request_one(config->ena_gpio,
1592 GPIOF_DIR_OUT | config->ena_gpio_flags,
1593 rdev_get_name(rdev));
1594 if (ret)
1595 return ret;
1596
1597 pin = kzalloc(sizeof(struct regulator_enable_gpio), GFP_KERNEL);
1598 if (pin == NULL) {
1599 gpio_free(config->ena_gpio);
1600 return -ENOMEM;
1601 }
1602
1603 pin->gpio = config->ena_gpio;
1604 pin->ena_gpio_invert = config->ena_gpio_invert;
1605 list_add(&pin->list, &regulator_ena_gpio_list);
1606
1607update_ena_gpio_to_rdev:
1608 pin->request_count++;
1609 rdev->ena_pin = pin;
1610 return 0;
1611}
1612
1613static void regulator_ena_gpio_free(struct regulator_dev *rdev)
1614{
1615 struct regulator_enable_gpio *pin, *n;
1616
1617 if (!rdev->ena_pin)
1618 return;
1619
1620 /* Free the GPIO only in case of no use */
1621 list_for_each_entry_safe(pin, n, &regulator_ena_gpio_list, list) {
1622 if (pin->gpio == rdev->ena_pin->gpio) {
1623 if (pin->request_count <= 1) {
1624 pin->request_count = 0;
1625 gpio_free(pin->gpio);
1626 list_del(&pin->list);
1627 kfree(pin);
1628 } else {
1629 pin->request_count--;
1630 }
1631 }
1632 }
1633}
1634
967cfb18 1635/**
31d6eebf
RD		 1636 * regulator_ena_gpio_ctrl - balance enable_count of each GPIO and actual GPIO pin control
1637 * @rdev: regulator_dev structure
1638 * @enable: enable GPIO at initial use?
1639 *
967cfb18
KM		 1640 * GPIO is enabled in case of initial use. (enable_count is 0)
1641 * GPIO is disabled when it is not shared any more. (enable_count <= 1)
1642 */
1643static int regulator_ena_gpio_ctrl(struct regulator_dev *rdev, bool enable)
1644{
1645 struct regulator_enable_gpio *pin = rdev->ena_pin;
1646
1647 if (!pin)
1648 return -EINVAL;
1649
1650 if (enable) {
1651 /* Enable GPIO at initial use */
1652 if (pin->enable_count == 0)
1653 gpio_set_value_cansleep(pin->gpio,
1654 !pin->ena_gpio_invert);
1655
1656 pin->enable_count++;
1657 } else {
1658 if (pin->enable_count > 1) {
1659 pin->enable_count--;
1660 return 0;
1661 }
1662
1663 /* Disable GPIO if not used */
1664 if (pin->enable_count <= 1) {
1665 gpio_set_value_cansleep(pin->gpio,
1666 pin->ena_gpio_invert);
1667 pin->enable_count = 0;
1668 }
1669 }
1670
1671 return 0;
1672}
1673
5c5659d0
MB		 1674static int _regulator_do_enable(struct regulator_dev *rdev)
1675{
1676 int ret, delay;
1677
1678 /* Query before enabling in case configuration dependent. */
1679 ret = _regulator_get_enable_time(rdev);
1680 if (ret >= 0) {
1681 delay = ret;
1682 } else {
1683 rdev_warn(rdev, "enable_time() failed: %d\n", ret);
1684 delay = 0;
1685 }
1686
1687 trace_regulator_enable(rdev_get_name(rdev));
1688
967cfb18
KM		 1689 if (rdev->ena_pin) {
1690 ret = regulator_ena_gpio_ctrl(rdev, true);
1691 if (ret < 0)
1692 return ret;
65f73508
MB		 1693 rdev->ena_gpio_state = 1;
1694 } else if (rdev->desc->ops->enable) {
5c5659d0
MB		 1695 ret = rdev->desc->ops->enable(rdev);
1696 if (ret < 0)
1697 return ret;
1698 } else {
1699 return -EINVAL;
1700 }
1701
1702 /* Allow the regulator to ramp; it would be useful to extend
1703 * this for bulk operations so that the regulators can ramp
1704 * together. */
1705 trace_regulator_enable_delay(rdev_get_name(rdev));
1706
1707 if (delay >= 1000) {
1708 mdelay(delay / 1000);
1709 udelay(delay % 1000);
1710 } else if (delay) {
1711 udelay(delay);
1712 }
1713
1714 trace_regulator_enable_complete(rdev_get_name(rdev));
1715
1716 return 0;
1717}
1718
414c70cb
LG		 1719/* locks held by regulator_enable() */
1720static int _regulator_enable(struct regulator_dev *rdev)
1721{
5c5659d0 1722 int ret;
414c70cb 1723
414c70cb 1724 /* check voltage and requested load before enabling */
9a2372fa
MB		 1725 if (rdev->constraints &&
1726 (rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_DRMS))
1727 drms_uA_update(rdev);
414c70cb 1728
9a2372fa
MB		 1729 if (rdev->use_count == 0) {
1730 /* The regulator may on if it's not switchable or left on */
1731 ret = _regulator_is_enabled(rdev);
1732 if (ret == -EINVAL || ret == 0) {
1733 if (!_regulator_can_change_status(rdev))
1734 return -EPERM;
1735
5c5659d0 1736 ret = _regulator_do_enable(rdev);
31aae2be
MB		 1737 if (ret < 0)
1738 return ret;
1739
a7433cff 1740 } else if (ret < 0) {
5da84fd9 1741 rdev_err(rdev, "is_enabled() failed: %d\n", ret);
414c70cb
LG		 1742 return ret;
1743 }
a7433cff 1744 /* Fallthrough on positive return values - already enabled */
414c70cb
LG		 1745 }
1746
9a2372fa
MB		 1747 rdev->use_count++;
1748
1749 return 0;
414c70cb
LG		 1750}
1751
1752/**
1753 * regulator_enable - enable regulator output
1754 * @regulator: regulator source
1755 *
cf7bbcdf
MB		 1756 * Request that the regulator be enabled with the regulator output at
1757 * the predefined voltage or current value. Calls to regulator_enable()
1758 * must be balanced with calls to regulator_disable().
1759 *
414c70cb 1760 * NOTE: the output value can be set by other drivers, boot loader or may be
cf7bbcdf 1761 * hardwired in the regulator.
414c70cb
LG		 1762 */
1763int regulator_enable(struct regulator *regulator)
1764{
412aec61
DB		 1765 struct regulator_dev *rdev = regulator->rdev;
1766 int ret = 0;
414c70cb 1767
6492bc1b
MB		 1768 if (regulator->always_on)
1769 return 0;
1770
3801b86a
MB		 1771 if (rdev->supply) {
1772 ret = regulator_enable(rdev->supply);
1773 if (ret != 0)
1774 return ret;
1775 }
1776
412aec61 1777 mutex_lock(&rdev->mutex);
cd94b505 1778 ret = _regulator_enable(rdev);
412aec61 1779 mutex_unlock(&rdev->mutex);
3801b86a 1780
d1685e4e 1781 if (ret != 0 && rdev->supply)
3801b86a
MB		 1782 regulator_disable(rdev->supply);
1783
414c70cb
LG		 1784 return ret;
1785}
1786EXPORT_SYMBOL_GPL(regulator_enable);
1787
5c5659d0
MB		 1788static int _regulator_do_disable(struct regulator_dev *rdev)
1789{
1790 int ret;
1791
1792 trace_regulator_disable(rdev_get_name(rdev));
1793
967cfb18
KM		 1794 if (rdev->ena_pin) {
1795 ret = regulator_ena_gpio_ctrl(rdev, false);
1796 if (ret < 0)
1797 return ret;
5c5659d0
MB		 1798 rdev->ena_gpio_state = 0;
1799
1800 } else if (rdev->desc->ops->disable) {
1801 ret = rdev->desc->ops->disable(rdev);
1802 if (ret != 0)
1803 return ret;
1804 }
1805
1806 trace_regulator_disable_complete(rdev_get_name(rdev));
1807
1808 _notifier_call_chain(rdev, REGULATOR_EVENT_DISABLE,
1809 NULL);
1810 return 0;
1811}
1812
414c70cb 1813/* locks held by regulator_disable() */
3801b86a 1814static int _regulator_disable(struct regulator_dev *rdev)
414c70cb
LG		 1815{
1816 int ret = 0;
1817
cd94b505 1818 if (WARN(rdev->use_count <= 0,
43e7ee33 1819 "unbalanced disables for %s\n", rdev_get_name(rdev)))
cd94b505
DB		 1820 return -EIO;
1821
414c70cb 1822 /* are we the last user and permitted to disable ? */
60ef66fc
MB		 1823 if (rdev->use_count == 1 &&
1824 (rdev->constraints && !rdev->constraints->always_on)) {
414c70cb
LG		 1825
1826 /* we are last user */
5c5659d0
MB		 1827 if (_regulator_can_change_status(rdev)) {
1828 ret = _regulator_do_disable(rdev);
414c70cb 1829 if (ret < 0) {
5da84fd9 1830 rdev_err(rdev, "failed to disable\n");
414c70cb
LG		 1831 return ret;
1832 }
1833 }
1834
414c70cb
LG		 1835 rdev->use_count = 0;
1836 } else if (rdev->use_count > 1) {
1837
1838 if (rdev->constraints &&
1839 (rdev->constraints->valid_ops_mask &
1840 REGULATOR_CHANGE_DRMS))
1841 drms_uA_update(rdev);
1842
1843 rdev->use_count--;
1844 }
3801b86a 1845
414c70cb
LG		 1846 return ret;
1847}
1848
1849/**
1850 * regulator_disable - disable regulator output
1851 * @regulator: regulator source
1852 *
cf7bbcdf
MB		 1853 * Disable the regulator output voltage or current. Calls to
1854 * regulator_enable() must be balanced with calls to
1855 * regulator_disable().
69279fb9 1856 *
414c70cb 1857 * NOTE: this will only disable the regulator output if no other consumer
cf7bbcdf
MB		 1858 * devices have it enabled, the regulator device supports disabling and
1859 * machine constraints permit this operation.
414c70cb
LG		 1860 */
1861int regulator_disable(struct regulator *regulator)
1862{
412aec61
DB		 1863 struct regulator_dev *rdev = regulator->rdev;
1864 int ret = 0;
414c70cb 1865
6492bc1b
MB		 1866 if (regulator->always_on)
1867 return 0;
1868
412aec61 1869 mutex_lock(&rdev->mutex);
3801b86a 1870 ret = _regulator_disable(rdev);
412aec61 1871 mutex_unlock(&rdev->mutex);
8cbf811d 1872
3801b86a
MB		 1873 if (ret == 0 && rdev->supply)
1874 regulator_disable(rdev->supply);
8cbf811d 1875
414c70cb
LG		 1876 return ret;
1877}
1878EXPORT_SYMBOL_GPL(regulator_disable);
1879
1880/* locks held by regulator_force_disable() */
3801b86a 1881static int _regulator_force_disable(struct regulator_dev *rdev)
414c70cb
LG		 1882{
1883 int ret = 0;
1884
1885 /* force disable */
1886 if (rdev->desc->ops->disable) {
1887 /* ah well, who wants to live forever... */
1888 ret = rdev->desc->ops->disable(rdev);
1889 if (ret < 0) {
5da84fd9 1890 rdev_err(rdev, "failed to force disable\n");
414c70cb
LG		 1891 return ret;
1892 }
1893 /* notify other consumers that power has been forced off */
84b68263
MB		 1894 _notifier_call_chain(rdev, REGULATOR_EVENT_FORCE_DISABLE |
1895 REGULATOR_EVENT_DISABLE, NULL);
414c70cb
LG		 1896 }
1897
414c70cb
LG		 1898 return ret;
1899}
1900
1901/**
1902 * regulator_force_disable - force disable regulator output
1903 * @regulator: regulator source
1904 *
1905 * Forcibly disable the regulator output voltage or current.
1906 * NOTE: this *will* disable the regulator output even if other consumer
1907 * devices have it enabled. This should be used for situations when device
1908 * damage will likely occur if the regulator is not disabled (e.g. over temp).
1909 */
1910int regulator_force_disable(struct regulator *regulator)
1911{
82d15839 1912 struct regulator_dev *rdev = regulator->rdev;
414c70cb
LG		 1913 int ret;
1914
82d15839 1915 mutex_lock(&rdev->mutex);
414c70cb 1916 regulator->uA_load = 0;
3801b86a 1917 ret = _regulator_force_disable(regulator->rdev);
82d15839 1918 mutex_unlock(&rdev->mutex);
8cbf811d 1919
3801b86a
MB		 1920 if (rdev->supply)
1921 while (rdev->open_count--)
1922 regulator_disable(rdev->supply);
8cbf811d 1923
414c70cb
LG		 1924 return ret;
1925}
1926EXPORT_SYMBOL_GPL(regulator_force_disable);
1927
da07ecd9
MB		 1928static void regulator_disable_work(struct work_struct *work)
1929{
1930 struct regulator_dev *rdev = container_of(work, struct regulator_dev,
1931 disable_work.work);
1932 int count, i, ret;
1933
1934 mutex_lock(&rdev->mutex);
1935
1936 BUG_ON(!rdev->deferred_disables);
1937
1938 count = rdev->deferred_disables;
1939 rdev->deferred_disables = 0;
1940
1941 for (i = 0; i < count; i++) {
1942 ret = _regulator_disable(rdev);
1943 if (ret != 0)
1944 rdev_err(rdev, "Deferred disable failed: %d\n", ret);
1945 }
1946
1947 mutex_unlock(&rdev->mutex);
1948
1949 if (rdev->supply) {
1950 for (i = 0; i < count; i++) {
1951 ret = regulator_disable(rdev->supply);
1952 if (ret != 0) {
1953 rdev_err(rdev,
1954 "Supply disable failed: %d\n", ret);
1955 }
1956 }
1957 }
1958}
1959
1960/**
1961 * regulator_disable_deferred - disable regulator output with delay
1962 * @regulator: regulator source
1963 * @ms: miliseconds until the regulator is disabled
1964 *
1965 * Execute regulator_disable() on the regulator after a delay. This
1966 * is intended for use with devices that require some time to quiesce.
1967 *
1968 * NOTE: this will only disable the regulator output if no other consumer
1969 * devices have it enabled, the regulator device supports disabling and
1970 * machine constraints permit this operation.
1971 */
1972int regulator_disable_deferred(struct regulator *regulator, int ms)
1973{
1974 struct regulator_dev *rdev = regulator->rdev;
aa59802d 1975 int ret;
da07ecd9 1976
6492bc1b
MB		 1977 if (regulator->always_on)
1978 return 0;
1979
2b5a24a0
MB		 1980 if (!ms)
1981 return regulator_disable(regulator);
1982
da07ecd9
MB		 1983 mutex_lock(&rdev->mutex);
1984 rdev->deferred_disables++;
1985 mutex_unlock(&rdev->mutex);
1986
070260f0
MB		 1987 ret = queue_delayed_work(system_power_efficient_wq,
1988 &rdev->disable_work,
1989 msecs_to_jiffies(ms));
aa59802d
MB		 1990 if (ret < 0)
1991 return ret;
1992 else
1993 return 0;
da07ecd9
MB		 1994}
1995EXPORT_SYMBOL_GPL(regulator_disable_deferred);
1996
414c70cb
LG		 1997static int _regulator_is_enabled(struct regulator_dev *rdev)
1998{
65f73508 1999 /* A GPIO control always takes precedence */
7b74d149 2000 if (rdev->ena_pin)
65f73508
MB		 2001 return rdev->ena_gpio_state;
2002
9a7f6a4c 2003 /* If we don't know then assume that the regulator is always on */
9332546f 2004 if (!rdev->desc->ops->is_enabled)
9a7f6a4c 2005 return 1;
414c70cb 2006
9332546f 2007 return rdev->desc->ops->is_enabled(rdev);
414c70cb
LG		 2008}
2009
2010/**
2011 * regulator_is_enabled - is the regulator output enabled
2012 * @regulator: regulator source
2013 *
412aec61
DB		 2014 * Returns positive if the regulator driver backing the source/client
2015 * has requested that the device be enabled, zero if it hasn't, else a
2016 * negative errno code.
2017 *
2018 * Note that the device backing this regulator handle can have multiple
2019 * users, so it might be enabled even if regulator_enable() was never
2020 * called for this particular source.
414c70cb
LG		 2021 */
2022int regulator_is_enabled(struct regulator *regulator)
2023{
9332546f
MB		 2024 int ret;
2025
6492bc1b
MB		 2026 if (regulator->always_on)
2027 return 1;
2028
9332546f
MB		 2029 mutex_lock(&regulator->rdev->mutex);
2030 ret = _regulator_is_enabled(regulator->rdev);
2031 mutex_unlock(&regulator->rdev->mutex);
2032
2033 return ret;
414c70cb
LG		 2034}
2035EXPORT_SYMBOL_GPL(regulator_is_enabled);
2036
d1e7de30
MS		 2037/**
2038 * regulator_can_change_voltage - check if regulator can change voltage
2039 * @regulator: regulator source
2040 *
2041 * Returns positive if the regulator driver backing the source/client
2042 * can change its voltage, false otherwise. Usefull for detecting fixed
2043 * or dummy regulators and disabling voltage change logic in the client
2044 * driver.
2045 */
2046int regulator_can_change_voltage(struct regulator *regulator)
2047{
2048 struct regulator_dev *rdev = regulator->rdev;
2049
2050 if (rdev->constraints &&
19280e40
AL		 2051 (rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) {
2052 if (rdev->desc->n_voltages - rdev->desc->linear_min_sel > 1)
2053 return 1;
2054
2055 if (rdev->desc->continuous_voltage_range &&
2056 rdev->constraints->min_uV && rdev->constraints->max_uV &&
2057 rdev->constraints->min_uV != rdev->constraints->max_uV)
2058 return 1;
2059 }
d1e7de30
MS		 2060
2061 return 0;
2062}
2063EXPORT_SYMBOL_GPL(regulator_can_change_voltage);
2064
4367cfdc
DB		 2065/**
2066 * regulator_count_voltages - count regulator_list_voltage() selectors
2067 * @regulator: regulator source
2068 *
2069 * Returns number of selectors, or negative errno. Selectors are
2070 * numbered starting at zero, and typically correspond to bitfields
2071 * in hardware registers.
2072 */
2073int regulator_count_voltages(struct regulator *regulator)
2074{
2075 struct regulator_dev *rdev = regulator->rdev;
2076
2077 return rdev->desc->n_voltages ? : -EINVAL;
2078}
2079EXPORT_SYMBOL_GPL(regulator_count_voltages);
2080
2081/**
2082 * regulator_list_voltage - enumerate supported voltages
2083 * @regulator: regulator source
2084 * @selector: identify voltage to list
2085 * Context: can sleep
2086 *
2087 * Returns a voltage that can be passed to @regulator_set_voltage(),
88393161 2088 * zero if this selector code can't be used on this system, or a
4367cfdc
DB		 2089 * negative errno.
2090 */
2091int regulator_list_voltage(struct regulator *regulator, unsigned selector)
2092{
2093 struct regulator_dev *rdev = regulator->rdev;
2094 struct regulator_ops *ops = rdev->desc->ops;
2095 int ret;
2096
2097 if (!ops->list_voltage || selector >= rdev->desc->n_voltages)
2098 return -EINVAL;
2099
2100 mutex_lock(&rdev->mutex);
2101 ret = ops->list_voltage(rdev, selector);
2102 mutex_unlock(&rdev->mutex);
2103
2104 if (ret > 0) {
2105 if (ret < rdev->constraints->min_uV)
2106 ret = 0;
2107 else if (ret > rdev->constraints->max_uV)
2108 ret = 0;
2109 }
2110
2111 return ret;
2112}
2113EXPORT_SYMBOL_GPL(regulator_list_voltage);
2114
2a668a8b
PW		 2115/**
2116 * regulator_get_linear_step - return the voltage step size between VSEL values
2117 * @regulator: regulator source
2118 *
2119 * Returns the voltage step size between VSEL values for linear
2120 * regulators, or return 0 if the regulator isn't a linear regulator.
2121 */
2122unsigned int regulator_get_linear_step(struct regulator *regulator)
2123{
2124 struct regulator_dev *rdev = regulator->rdev;
2125
2126 return rdev->desc->uV_step;
2127}
2128EXPORT_SYMBOL_GPL(regulator_get_linear_step);
2129
a7a1ad90
MB		 2130/**
2131 * regulator_is_supported_voltage - check if a voltage range can be supported
2132 *
2133 * @regulator: Regulator to check.
2134 * @min_uV: Minimum required voltage in uV.
2135 * @max_uV: Maximum required voltage in uV.
2136 *
2137 * Returns a boolean or a negative error code.
2138 */
2139int regulator_is_supported_voltage(struct regulator *regulator,
2140 int min_uV, int max_uV)
2141{
c5f3939b 2142 struct regulator_dev *rdev = regulator->rdev;
a7a1ad90
MB		 2143 int i, voltages, ret;
2144
c5f3939b
MB		 2145 /* If we can't change voltage check the current voltage */
2146 if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) {
2147 ret = regulator_get_voltage(regulator);
2148 if (ret >= 0)
f0f98b19 2149 return (min_uV <= ret && ret <= max_uV);
c5f3939b
MB		 2150 else
2151 return ret;
2152 }
2153
bd7a2b60
PM		 2154 /* Any voltage within constrains range is fine? */
2155 if (rdev->desc->continuous_voltage_range)
2156 return min_uV >= rdev->constraints->min_uV &&
2157 max_uV <= rdev->constraints->max_uV;
2158
a7a1ad90
MB		 2159 ret = regulator_count_voltages(regulator);
2160 if (ret < 0)
2161 return ret;
2162 voltages = ret;
2163
2164 for (i = 0; i < voltages; i++) {
2165 ret = regulator_list_voltage(regulator, i);
2166
2167 if (ret >= min_uV && ret <= max_uV)
2168 return 1;
2169 }
2170
2171 return 0;
2172}
a398eaa2 2173EXPORT_SYMBOL_GPL(regulator_is_supported_voltage);
a7a1ad90 2174
75790251
MB		 2175static int _regulator_do_set_voltage(struct regulator_dev *rdev,
2176 int min_uV, int max_uV)
2177{
2178 int ret;
77af1b26 2179 int delay = 0;
e113d792 2180 int best_val = 0;
75790251 2181 unsigned int selector;
eba41a5e 2182 int old_selector = -1;
75790251
MB		 2183
2184 trace_regulator_set_voltage(rdev_get_name(rdev), min_uV, max_uV);
2185
bf5892a8
MB		 2186 min_uV += rdev->constraints->uV_offset;
2187 max_uV += rdev->constraints->uV_offset;
2188
eba41a5e
AL		 2189 /*
2190 * If we can't obtain the old selector there is not enough
2191 * info to call set_voltage_time_sel().
2192 */
8b7485ef
AL		 2193 if (_regulator_is_enabled(rdev) &&
2194 rdev->desc->ops->set_voltage_time_sel &&
eba41a5e
AL		 2195 rdev->desc->ops->get_voltage_sel) {
2196 old_selector = rdev->desc->ops->get_voltage_sel(rdev);
2197 if (old_selector < 0)
2198 return old_selector;
2199 }
2200
75790251
MB		 2201 if (rdev->desc->ops->set_voltage) {
2202 ret = rdev->desc->ops->set_voltage(rdev, min_uV, max_uV,
2203 &selector);
e113d792
MB		 2204
2205 if (ret >= 0) {
2206 if (rdev->desc->ops->list_voltage)
2207 best_val = rdev->desc->ops->list_voltage(rdev,
2208 selector);
2209 else
2210 best_val = _regulator_get_voltage(rdev);
2211 }
2212
e8eef82b 2213 } else if (rdev->desc->ops->set_voltage_sel) {
9152c36a 2214 if (rdev->desc->ops->map_voltage) {
e843fc46
MB		 2215 ret = rdev->desc->ops->map_voltage(rdev, min_uV,
2216 max_uV);
9152c36a
AL		 2217 } else {
2218 if (rdev->desc->ops->list_voltage ==
2219 regulator_list_voltage_linear)
2220 ret = regulator_map_voltage_linear(rdev,
2221 min_uV, max_uV);
2222 else
2223 ret = regulator_map_voltage_iterate(rdev,
2224 min_uV, max_uV);
2225 }
e8eef82b 2226
e843fc46 2227 if (ret >= 0) {
e113d792
MB		 2228 best_val = rdev->desc->ops->list_voltage(rdev, ret);
2229 if (min_uV <= best_val && max_uV >= best_val) {
2230 selector = ret;
c66a566a
AL		 2231 if (old_selector == selector)
2232 ret = 0;
2233 else
2234 ret = rdev->desc->ops->set_voltage_sel(
2235 rdev, ret);
e113d792
MB		 2236 } else {
2237 ret = -EINVAL;
2238 }
e8eef82b 2239 }
75790251
MB		 2240 } else {
2241 ret = -EINVAL;
2242 }
e8eef82b 2243
eba41a5e 2244 /* Call set_voltage_time_sel if successfully obtained old_selector */
5b175952
YSB		 2245 if (ret == 0 && !rdev->constraints->ramp_disable && old_selector >= 0
2246 && old_selector != selector) {
77af1b26 2247
eba41a5e
AL		 2248 delay = rdev->desc->ops->set_voltage_time_sel(rdev,
2249 old_selector, selector);
2250 if (delay < 0) {
2251 rdev_warn(rdev, "set_voltage_time_sel() failed: %d\n",
2252 delay);
2253 delay = 0;
e8eef82b 2254 }
75790251 2255
8b96de31
PR		 2256 /* Insert any necessary delays */
2257 if (delay >= 1000) {
2258 mdelay(delay / 1000);
2259 udelay(delay % 1000);
2260 } else if (delay) {
2261 udelay(delay);
2262 }
77af1b26
LW		 2263 }
2264
2f6c797f
AL		 2265 if (ret == 0 && best_val >= 0) {
2266 unsigned long data = best_val;
2267
ded06a52 2268 _notifier_call_chain(rdev, REGULATOR_EVENT_VOLTAGE_CHANGE,
2f6c797f
AL		 2269 (void *)data);
2270 }
ded06a52 2271
eba41a5e 2272 trace_regulator_set_voltage_complete(rdev_get_name(rdev), best_val);
75790251
MB		 2273
2274 return ret;
2275}
2276
414c70cb
LG		 2277/**
2278 * regulator_set_voltage - set regulator output voltage
2279 * @regulator: regulator source
2280 * @min_uV: Minimum required voltage in uV
2281 * @max_uV: Maximum acceptable voltage in uV
2282 *
2283 * Sets a voltage regulator to the desired output voltage. This can be set
2284 * during any regulator state. IOW, regulator can be disabled or enabled.
2285 *
2286 * If the regulator is enabled then the voltage will change to the new value
2287 * immediately otherwise if the regulator is disabled the regulator will
2288 * output at the new voltage when enabled.
2289 *
2290 * NOTE: If the regulator is shared between several devices then the lowest
2291 * request voltage that meets the system constraints will be used.
69279fb9 2292 * Regulator system constraints must be set for this regulator before
414c70cb
LG		 2293 * calling this function otherwise this call will fail.
2294 */
2295int regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV)
2296{
2297 struct regulator_dev *rdev = regulator->rdev;
95a3c23a 2298 int ret = 0;
92d7a558 2299 int old_min_uV, old_max_uV;
414c70cb
LG		 2300
2301 mutex_lock(&rdev->mutex);
2302
95a3c23a
MB		 2303 /* If we're setting the same range as last time the change
2304 * should be a noop (some cpufreq implementations use the same
2305 * voltage for multiple frequencies, for example).
2306 */
2307 if (regulator->min_uV == min_uV && regulator->max_uV == max_uV)
2308 goto out;
2309
414c70cb 2310 /* sanity check */
e8eef82b
MB		 2311 if (!rdev->desc->ops->set_voltage &&
2312 !rdev->desc->ops->set_voltage_sel) {
414c70cb
LG		 2313 ret = -EINVAL;
2314 goto out;
2315 }
2316
2317 /* constraints check */
2318 ret = regulator_check_voltage(rdev, &min_uV, &max_uV);
2319 if (ret < 0)
2320 goto out;
92d7a558
PP		 2321
2322 /* restore original values in case of error */
2323 old_min_uV = regulator->min_uV;
2324 old_max_uV = regulator->max_uV;
414c70cb
LG		 2325 regulator->min_uV = min_uV;
2326 regulator->max_uV = max_uV;
3a93f2a9 2327
05fda3b1
TP		 2328 ret = regulator_check_consumers(rdev, &min_uV, &max_uV);
2329 if (ret < 0)
92d7a558 2330 goto out2;
05fda3b1 2331
75790251 2332 ret = _regulator_do_set_voltage(rdev, min_uV, max_uV);
92d7a558
PP		 2333 if (ret < 0)
2334 goto out2;
2335
414c70cb
LG		 2336out:
2337 mutex_unlock(&rdev->mutex);
2338 return ret;
92d7a558
PP		 2339out2:
2340 regulator->min_uV = old_min_uV;
2341 regulator->max_uV = old_max_uV;
2342 mutex_unlock(&rdev->mutex);
414c70cb
LG		 2343 return ret;
2344}
2345EXPORT_SYMBOL_GPL(regulator_set_voltage);
2346
88cd222b
LW		 2347/**
2348 * regulator_set_voltage_time - get raise/fall time
2349 * @regulator: regulator source
2350 * @old_uV: starting voltage in microvolts
2351 * @new_uV: target voltage in microvolts
2352 *
2353 * Provided with the starting and ending voltage, this function attempts to
2354 * calculate the time in microseconds required to rise or fall to this new
2355 * voltage.
2356 */
2357int regulator_set_voltage_time(struct regulator *regulator,
2358 int old_uV, int new_uV)
2359{
2360 struct regulator_dev *rdev = regulator->rdev;
2361 struct regulator_ops *ops = rdev->desc->ops;
2362 int old_sel = -1;
2363 int new_sel = -1;
2364 int voltage;
2365 int i;
2366
2367 /* Currently requires operations to do this */
2368 if (!ops->list_voltage || !ops->set_voltage_time_sel
2369 || !rdev->desc->n_voltages)
2370 return -EINVAL;
2371
2372 for (i = 0; i < rdev->desc->n_voltages; i++) {
2373 /* We only look for exact voltage matches here */
2374 voltage = regulator_list_voltage(regulator, i);
2375 if (voltage < 0)
2376 return -EINVAL;
2377 if (voltage == 0)
2378 continue;
2379 if (voltage == old_uV)
2380 old_sel = i;
2381 if (voltage == new_uV)
2382 new_sel = i;
2383 }
2384
2385 if (old_sel < 0 || new_sel < 0)
2386 return -EINVAL;
2387
2388 return ops->set_voltage_time_sel(rdev, old_sel, new_sel);
2389}
2390EXPORT_SYMBOL_GPL(regulator_set_voltage_time);
2391
98a175b6 2392/**
296c6566
RD		 2393 * regulator_set_voltage_time_sel - get raise/fall time
2394 * @rdev: regulator source device
98a175b6
YSB		 2395 * @old_selector: selector for starting voltage
2396 * @new_selector: selector for target voltage
2397 *
2398 * Provided with the starting and target voltage selectors, this function
2399 * returns time in microseconds required to rise or fall to this new voltage
2400 *
f11d08c3 2401 * Drivers providing ramp_delay in regulation_constraints can use this as their
398715ab 2402 * set_voltage_time_sel() operation.
98a175b6
YSB		 2403 */
2404int regulator_set_voltage_time_sel(struct regulator_dev *rdev,
2405 unsigned int old_selector,
2406 unsigned int new_selector)
2407{
398715ab 2408 unsigned int ramp_delay = 0;
f11d08c3 2409 int old_volt, new_volt;
398715ab
AL		 2410
2411 if (rdev->constraints->ramp_delay)
2412 ramp_delay = rdev->constraints->ramp_delay;
2413 else if (rdev->desc->ramp_delay)
2414 ramp_delay = rdev->desc->ramp_delay;
2415
2416 if (ramp_delay == 0) {
6f0b2c69 2417 rdev_warn(rdev, "ramp_delay not set\n");
398715ab 2418 return 0;
6f0b2c69 2419 }
398715ab 2420
f11d08c3
AL		 2421 /* sanity check */
2422 if (!rdev->desc->ops->list_voltage)
2423 return -EINVAL;
398715ab 2424
f11d08c3
AL		 2425 old_volt = rdev->desc->ops->list_voltage(rdev, old_selector);
2426 new_volt = rdev->desc->ops->list_voltage(rdev, new_selector);
2427
2428 return DIV_ROUND_UP(abs(new_volt - old_volt), ramp_delay);
98a175b6 2429}
b19dbf71 2430EXPORT_SYMBOL_GPL(regulator_set_voltage_time_sel);
98a175b6 2431
606a2562
MB		 2432/**
2433 * regulator_sync_voltage - re-apply last regulator output voltage
2434 * @regulator: regulator source
2435 *
2436 * Re-apply the last configured voltage. This is intended to be used
2437 * where some external control source the consumer is cooperating with
2438 * has caused the configured voltage to change.
2439 */
2440int regulator_sync_voltage(struct regulator *regulator)
2441{
2442 struct regulator_dev *rdev = regulator->rdev;
2443 int ret, min_uV, max_uV;
2444
2445 mutex_lock(&rdev->mutex);
2446
2447 if (!rdev->desc->ops->set_voltage &&
2448 !rdev->desc->ops->set_voltage_sel) {
2449 ret = -EINVAL;
2450 goto out;
2451 }
2452
2453 /* This is only going to work if we've had a voltage configured. */
2454 if (!regulator->min_uV && !regulator->max_uV) {
2455 ret = -EINVAL;
2456 goto out;
2457 }
2458
2459 min_uV = regulator->min_uV;
2460 max_uV = regulator->max_uV;
2461
2462 /* This should be a paranoia check... */
2463 ret = regulator_check_voltage(rdev, &min_uV, &max_uV);
2464 if (ret < 0)
2465 goto out;
2466
2467 ret = regulator_check_consumers(rdev, &min_uV, &max_uV);
2468 if (ret < 0)
2469 goto out;
2470
2471 ret = _regulator_do_set_voltage(rdev, min_uV, max_uV);
2472
2473out:
2474 mutex_unlock(&rdev->mutex);
2475 return ret;
2476}
2477EXPORT_SYMBOL_GPL(regulator_sync_voltage);
2478
414c70cb
LG		 2479static int _regulator_get_voltage(struct regulator_dev *rdev)
2480{
bf5892a8 2481 int sel, ret;
476c2d83
MB		 2482
2483 if (rdev->desc->ops->get_voltage_sel) {
2484 sel = rdev->desc->ops->get_voltage_sel(rdev);
2485 if (sel < 0)
2486 return sel;
bf5892a8 2487 ret = rdev->desc->ops->list_voltage(rdev, sel);
cb220d16 2488 } else if (rdev->desc->ops->get_voltage) {
bf5892a8 2489 ret = rdev->desc->ops->get_voltage(rdev);
f7df20ec
MB		 2490 } else if (rdev->desc->ops->list_voltage) {
2491 ret = rdev->desc->ops->list_voltage(rdev, 0);
cb220d16 2492 } else {
414c70cb 2493 return -EINVAL;
cb220d16 2494 }
bf5892a8 2495
cb220d16
AL		 2496 if (ret < 0)
2497 return ret;
bf5892a8 2498 return ret - rdev->constraints->uV_offset;
414c70cb
LG		 2499}
2500
2501/**
2502 * regulator_get_voltage - get regulator output voltage
2503 * @regulator: regulator source
2504 *
2505 * This returns the current regulator voltage in uV.
2506 *
2507 * NOTE: If the regulator is disabled it will return the voltage value. This
2508 * function should not be used to determine regulator state.
2509 */
2510int regulator_get_voltage(struct regulator *regulator)
2511{
2512 int ret;
2513
2514 mutex_lock(&regulator->rdev->mutex);
2515
2516 ret = _regulator_get_voltage(regulator->rdev);
2517
2518 mutex_unlock(&regulator->rdev->mutex);
2519
2520 return ret;
2521}
2522EXPORT_SYMBOL_GPL(regulator_get_voltage);
2523
2524/**
2525 * regulator_set_current_limit - set regulator output current limit
2526 * @regulator: regulator source
ce0d10f8 2527 * @min_uA: Minimum supported current in uA
414c70cb
LG		 2528 * @max_uA: Maximum supported current in uA
2529 *
2530 * Sets current sink to the desired output current. This can be set during
2531 * any regulator state. IOW, regulator can be disabled or enabled.
2532 *
2533 * If the regulator is enabled then the current will change to the new value
2534 * immediately otherwise if the regulator is disabled the regulator will
2535 * output at the new current when enabled.
2536 *
2537 * NOTE: Regulator system constraints must be set for this regulator before
2538 * calling this function otherwise this call will fail.
2539 */
2540int regulator_set_current_limit(struct regulator *regulator,
2541 int min_uA, int max_uA)
2542{
2543 struct regulator_dev *rdev = regulator->rdev;
2544 int ret;
2545
2546 mutex_lock(&rdev->mutex);
2547
2548 /* sanity check */
2549 if (!rdev->desc->ops->set_current_limit) {
2550 ret = -EINVAL;
2551 goto out;
2552 }
2553
2554 /* constraints check */
2555 ret = regulator_check_current_limit(rdev, &min_uA, &max_uA);
2556 if (ret < 0)
2557 goto out;
2558
2559 ret = rdev->desc->ops->set_current_limit(rdev, min_uA, max_uA);
2560out:
2561 mutex_unlock(&rdev->mutex);
2562 return ret;
2563}
2564EXPORT_SYMBOL_GPL(regulator_set_current_limit);
2565
2566static int _regulator_get_current_limit(struct regulator_dev *rdev)
2567{
2568 int ret;
2569
2570 mutex_lock(&rdev->mutex);
2571
2572 /* sanity check */
2573 if (!rdev->desc->ops->get_current_limit) {
2574 ret = -EINVAL;
2575 goto out;
2576 }
2577
2578 ret = rdev->desc->ops->get_current_limit(rdev);
2579out:
2580 mutex_unlock(&rdev->mutex);
2581 return ret;
2582}
2583
2584/**
2585 * regulator_get_current_limit - get regulator output current
2586 * @regulator: regulator source
2587 *
2588 * This returns the current supplied by the specified current sink in uA.
2589 *
2590 * NOTE: If the regulator is disabled it will return the current value. This
2591 * function should not be used to determine regulator state.
2592 */
2593int regulator_get_current_limit(struct regulator *regulator)
2594{
2595 return _regulator_get_current_limit(regulator->rdev);
2596}
2597EXPORT_SYMBOL_GPL(regulator_get_current_limit);
2598
2599/**
2600 * regulator_set_mode - set regulator operating mode
2601 * @regulator: regulator source
2602 * @mode: operating mode - one of the REGULATOR_MODE constants
2603 *
2604 * Set regulator operating mode to increase regulator efficiency or improve
2605 * regulation performance.
2606 *
2607 * NOTE: Regulator system constraints must be set for this regulator before
2608 * calling this function otherwise this call will fail.
2609 */
2610int regulator_set_mode(struct regulator *regulator, unsigned int mode)
2611{
2612 struct regulator_dev *rdev = regulator->rdev;
2613 int ret;
500b4ac9 2614 int regulator_curr_mode;
414c70cb
LG		 2615
2616 mutex_lock(&rdev->mutex);
2617
2618 /* sanity check */
2619 if (!rdev->desc->ops->set_mode) {
2620 ret = -EINVAL;
2621 goto out;
2622 }
2623
500b4ac9
SI		 2624 /* return if the same mode is requested */
2625 if (rdev->desc->ops->get_mode) {
2626 regulator_curr_mode = rdev->desc->ops->get_mode(rdev);
2627 if (regulator_curr_mode == mode) {
2628 ret = 0;
2629 goto out;
2630 }
2631 }
2632
414c70cb 2633 /* constraints check */
22c51b47 2634 ret = regulator_mode_constrain(rdev, &mode);
414c70cb
LG		 2635 if (ret < 0)
2636 goto out;
2637
2638 ret = rdev->desc->ops->set_mode(rdev, mode);
2639out:
2640 mutex_unlock(&rdev->mutex);
2641 return ret;
2642}
2643EXPORT_SYMBOL_GPL(regulator_set_mode);
2644
2645static unsigned int _regulator_get_mode(struct regulator_dev *rdev)
2646{
2647 int ret;
2648
2649 mutex_lock(&rdev->mutex);
2650
2651 /* sanity check */
2652 if (!rdev->desc->ops->get_mode) {
2653 ret = -EINVAL;
2654 goto out;
2655 }
2656
2657 ret = rdev->desc->ops->get_mode(rdev);
2658out:
2659 mutex_unlock(&rdev->mutex);
2660 return ret;
2661}
2662
2663/**
2664 * regulator_get_mode - get regulator operating mode
2665 * @regulator: regulator source
2666 *
2667 * Get the current regulator operating mode.
2668 */
2669unsigned int regulator_get_mode(struct regulator *regulator)
2670{
2671 return _regulator_get_mode(regulator->rdev);
2672}
2673EXPORT_SYMBOL_GPL(regulator_get_mode);
2674
2675/**
2676 * regulator_set_optimum_mode - set regulator optimum operating mode
2677 * @regulator: regulator source
2678 * @uA_load: load current
2679 *
2680 * Notifies the regulator core of a new device load. This is then used by
2681 * DRMS (if enabled by constraints) to set the most efficient regulator
2682 * operating mode for the new regulator loading.
2683 *
2684 * Consumer devices notify their supply regulator of the maximum power
2685 * they will require (can be taken from device datasheet in the power
2686 * consumption tables) when they change operational status and hence power
2687 * state. Examples of operational state changes that can affect power
2688 * consumption are :-
2689 *
2690 * o Device is opened / closed.
2691 * o Device I/O is about to begin or has just finished.
2692 * o Device is idling in between work.
2693 *
2694 * This information is also exported via sysfs to userspace.
2695 *
2696 * DRMS will sum the total requested load on the regulator and change
2697 * to the most efficient operating mode if platform constraints allow.
2698 *
2699 * Returns the new regulator mode or error.
2700 */
2701int regulator_set_optimum_mode(struct regulator *regulator, int uA_load)
2702{
2703 struct regulator_dev *rdev = regulator->rdev;
2704 struct regulator *consumer;
d92d95b6 2705 int ret, output_uV, input_uV = 0, total_uA_load = 0;
414c70cb
LG		 2706 unsigned int mode;
2707
d92d95b6
SB		 2708 if (rdev->supply)
2709 input_uV = regulator_get_voltage(rdev->supply);
2710
414c70cb
LG		 2711 mutex_lock(&rdev->mutex);
2712
a4b41483
MB		 2713 /*
2714 * first check to see if we can set modes at all, otherwise just
2715 * tell the consumer everything is OK.
2716 */
414c70cb
LG		 2717 regulator->uA_load = uA_load;
2718 ret = regulator_check_drms(rdev);
a4b41483
MB		 2719 if (ret < 0) {
2720 ret = 0;
414c70cb 2721 goto out;
a4b41483 2722 }
414c70cb 2723
414c70cb
LG		 2724 if (!rdev->desc->ops->get_optimum_mode)
2725 goto out;
2726
a4b41483
MB		 2727 /*
2728 * we can actually do this so any errors are indicators of
2729 * potential real failure.
2730 */
2731 ret = -EINVAL;
2732
854ccbae
AL		 2733 if (!rdev->desc->ops->set_mode)
2734 goto out;
2735
414c70cb 2736 /* get output voltage */
1bf5a1f8 2737 output_uV = _regulator_get_voltage(rdev);
414c70cb 2738 if (output_uV <= 0) {
5da84fd9 2739 rdev_err(rdev, "invalid output voltage found\n");
414c70cb
LG		 2740 goto out;
2741 }
2742
d92d95b6 2743 /* No supply? Use constraint voltage */
1bf5a1f8 2744 if (input_uV <= 0)
414c70cb
LG		 2745 input_uV = rdev->constraints->input_uV;
2746 if (input_uV <= 0) {
5da84fd9 2747 rdev_err(rdev, "invalid input voltage found\n");
414c70cb
LG		 2748 goto out;
2749 }
2750
2751 /* calc total requested load for this regulator */
2752 list_for_each_entry(consumer, &rdev->consumer_list, list)
fa2984d4 2753 total_uA_load += consumer->uA_load;
414c70cb
LG		 2754
2755 mode = rdev->desc->ops->get_optimum_mode(rdev,
2756 input_uV, output_uV,
2757 total_uA_load);
2c608234 2758 ret = regulator_mode_constrain(rdev, &mode);
e573520b 2759 if (ret < 0) {
5da84fd9
JP		 2760 rdev_err(rdev, "failed to get optimum mode @ %d uA %d -> %d uV\n",
2761 total_uA_load, input_uV, output_uV);
414c70cb
LG		 2762 goto out;
2763 }
2764
2765 ret = rdev->desc->ops->set_mode(rdev, mode);
e573520b 2766 if (ret < 0) {
5da84fd9 2767 rdev_err(rdev, "failed to set optimum mode %x\n", mode);
414c70cb
LG		 2768 goto out;
2769 }
2770 ret = mode;
2771out:
2772 mutex_unlock(&rdev->mutex);
2773 return ret;
2774}
2775EXPORT_SYMBOL_GPL(regulator_set_optimum_mode);
2776
f59c8f9f
MB		 2777/**
2778 * regulator_allow_bypass - allow the regulator to go into bypass mode
2779 *
2780 * @regulator: Regulator to configure
9345dfb8 2781 * @enable: enable or disable bypass mode
f59c8f9f
MB		 2782 *
2783 * Allow the regulator to go into bypass mode if all other consumers
2784 * for the regulator also enable bypass mode and the machine
2785 * constraints allow this. Bypass mode means that the regulator is
2786 * simply passing the input directly to the output with no regulation.
2787 */
2788int regulator_allow_bypass(struct regulator *regulator, bool enable)
2789{
2790 struct regulator_dev *rdev = regulator->rdev;
2791 int ret = 0;
2792
2793 if (!rdev->desc->ops->set_bypass)
2794 return 0;
2795
2796 if (rdev->constraints &&
2797 !(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_BYPASS))
2798 return 0;
2799
2800 mutex_lock(&rdev->mutex);
2801
2802 if (enable && !regulator->bypass) {
2803 rdev->bypass_count++;
2804
2805 if (rdev->bypass_count == rdev->open_count) {
2806 ret = rdev->desc->ops->set_bypass(rdev, enable);
2807 if (ret != 0)
2808 rdev->bypass_count--;
2809 }
2810
2811 } else if (!enable && regulator->bypass) {
2812 rdev->bypass_count--;
2813
2814 if (rdev->bypass_count != rdev->open_count) {
2815 ret = rdev->desc->ops->set_bypass(rdev, enable);
2816 if (ret != 0)
2817 rdev->bypass_count++;
2818 }
2819 }
2820
2821 if (ret == 0)
2822 regulator->bypass = enable;
2823
2824 mutex_unlock(&rdev->mutex);
2825
2826 return ret;
2827}
2828EXPORT_SYMBOL_GPL(regulator_allow_bypass);
2829
414c70cb
LG		 2830/**
2831 * regulator_register_notifier - register regulator event notifier
2832 * @regulator: regulator source
69279fb9 2833 * @nb: notifier block
414c70cb
LG		 2834 *
2835 * Register notifier block to receive regulator events.
2836 */
2837int regulator_register_notifier(struct regulator *regulator,
2838 struct notifier_block *nb)
2839{
2840 return blocking_notifier_chain_register(&regulator->rdev->notifier,
2841 nb);
2842}
2843EXPORT_SYMBOL_GPL(regulator_register_notifier);
2844
2845/**
2846 * regulator_unregister_notifier - unregister regulator event notifier
2847 * @regulator: regulator source
69279fb9 2848 * @nb: notifier block
414c70cb
LG		 2849 *
2850 * Unregister regulator event notifier block.
2851 */
2852int regulator_unregister_notifier(struct regulator *regulator,
2853 struct notifier_block *nb)
2854{
2855 return blocking_notifier_chain_unregister(&regulator->rdev->notifier,
2856 nb);
2857}
2858EXPORT_SYMBOL_GPL(regulator_unregister_notifier);
2859
b136fb44
JC		 2860/* notify regulator consumers and downstream regulator consumers.
2861 * Note mutex must be held by caller.
2862 */
414c70cb
LG		 2863static void _notifier_call_chain(struct regulator_dev *rdev,
2864 unsigned long event, void *data)
2865{
414c70cb 2866 /* call rdev chain first */
d8493d21 2867 blocking_notifier_call_chain(&rdev->notifier, event, data);
414c70cb
LG		 2868}
2869
2870/**
2871 * regulator_bulk_get - get multiple regulator consumers
2872 *
2873 * @dev: Device to supply
2874 * @num_consumers: Number of consumers to register
2875 * @consumers: Configuration of consumers; clients are stored here.
2876 *
2877 * @return 0 on success, an errno on failure.
2878 *
2879 * This helper function allows drivers to get several regulator
2880 * consumers in one operation. If any of the regulators cannot be
2881 * acquired then any regulators that were allocated will be freed
2882 * before returning to the caller.
2883 */
2884int regulator_bulk_get(struct device *dev, int num_consumers,
2885 struct regulator_bulk_data *consumers)
2886{
2887 int i;
2888 int ret;
2889
2890 for (i = 0; i < num_consumers; i++)
2891 consumers[i].consumer = NULL;
2892
2893 for (i = 0; i < num_consumers; i++) {
2894 consumers[i].consumer = regulator_get(dev,
2895 consumers[i].supply);
2896 if (IS_ERR(consumers[i].consumer)) {
414c70cb 2897 ret = PTR_ERR(consumers[i].consumer);
5b307627
MB		 2898 dev_err(dev, "Failed to get supply '%s': %d\n",
2899 consumers[i].supply, ret);
414c70cb
LG		 2900 consumers[i].consumer = NULL;
2901 goto err;
2902 }
2903 }
2904
2905 return 0;
2906
2907err:
b29c7690 2908 while (--i >= 0)
414c70cb
LG		 2909 regulator_put(consumers[i].consumer);
2910
2911 return ret;
2912}
2913EXPORT_SYMBOL_GPL(regulator_bulk_get);
2914
e6e74030
MB		 2915/**
2916 * devm_regulator_bulk_get - managed get multiple regulator consumers
2917 *
2918 * @dev: Device to supply
2919 * @num_consumers: Number of consumers to register
2920 * @consumers: Configuration of consumers; clients are stored here.
2921 *
2922 * @return 0 on success, an errno on failure.
2923 *
2924 * This helper function allows drivers to get several regulator
2925 * consumers in one operation with management, the regulators will
2926 * automatically be freed when the device is unbound. If any of the
2927 * regulators cannot be acquired then any regulators that were
2928 * allocated will be freed before returning to the caller.
2929 */
2930int devm_regulator_bulk_get(struct device *dev, int num_consumers,
2931 struct regulator_bulk_data *consumers)
2932{
2933 int i;
2934 int ret;
2935
2936 for (i = 0; i < num_consumers; i++)
2937 consumers[i].consumer = NULL;
2938
2939 for (i = 0; i < num_consumers; i++) {
2940 consumers[i].consumer = devm_regulator_get(dev,
2941 consumers[i].supply);
2942 if (IS_ERR(consumers[i].consumer)) {
2943 ret = PTR_ERR(consumers[i].consumer);
2944 dev_err(dev, "Failed to get supply '%s': %d\n",
2945 consumers[i].supply, ret);
2946 consumers[i].consumer = NULL;
2947 goto err;
2948 }
2949 }
2950
2951 return 0;
2952
2953err:
2954 for (i = 0; i < num_consumers && consumers[i].consumer; i++)
2955 devm_regulator_put(consumers[i].consumer);
2956
2957 return ret;
2958}
2959EXPORT_SYMBOL_GPL(devm_regulator_bulk_get);
2960
f21e0e81
MB		 2961static void regulator_bulk_enable_async(void *data, async_cookie_t cookie)
2962{
2963 struct regulator_bulk_data *bulk = data;
2964
2965 bulk->ret = regulator_enable(bulk->consumer);
2966}
2967
414c70cb
LG		 2968/**
2969 * regulator_bulk_enable - enable multiple regulator consumers
2970 *
2971 * @num_consumers: Number of consumers
2972 * @consumers: Consumer data; clients are stored here.
2973 * @return 0 on success, an errno on failure
2974 *
2975 * This convenience API allows consumers to enable multiple regulator
2976 * clients in a single API call. If any consumers cannot be enabled
2977 * then any others that were enabled will be disabled again prior to
2978 * return.
2979 */
2980int regulator_bulk_enable(int num_consumers,
2981 struct regulator_bulk_data *consumers)
2982{
2955b47d 2983 ASYNC_DOMAIN_EXCLUSIVE(async_domain);
414c70cb 2984 int i;
f21e0e81 2985 int ret = 0;
414c70cb 2986
6492bc1b
MB		 2987 for (i = 0; i < num_consumers; i++) {
2988 if (consumers[i].consumer->always_on)
2989 consumers[i].ret = 0;
2990 else
2991 async_schedule_domain(regulator_bulk_enable_async,
2992 &consumers[i], &async_domain);
2993 }
f21e0e81
MB		 2994
2995 async_synchronize_full_domain(&async_domain);
2996
2997 /* If any consumer failed we need to unwind any that succeeded */
414c70cb 2998 for (i = 0; i < num_consumers; i++) {
f21e0e81
MB		 2999 if (consumers[i].ret != 0) {
3000 ret = consumers[i].ret;
414c70cb 3001 goto err;
f21e0e81 3002 }
414c70cb
LG		 3003 }
3004
3005 return 0;
3006
3007err:
fbe31057
AH		 3008 for (i = 0; i < num_consumers; i++) {
3009 if (consumers[i].ret < 0)
3010 pr_err("Failed to enable %s: %d\n", consumers[i].supply,
3011 consumers[i].ret);
3012 else
3013 regulator_disable(consumers[i].consumer);
3014 }
414c70cb
LG		 3015
3016 return ret;
3017}
3018EXPORT_SYMBOL_GPL(regulator_bulk_enable);
3019
3020/**
3021 * regulator_bulk_disable - disable multiple regulator consumers
3022 *
3023 * @num_consumers: Number of consumers
3024 * @consumers: Consumer data; clients are stored here.
3025 * @return 0 on success, an errno on failure
3026 *
3027 * This convenience API allows consumers to disable multiple regulator
49e22632
SN		 3028 * clients in a single API call. If any consumers cannot be disabled
3029 * then any others that were disabled will be enabled again prior to
414c70cb
LG		 3030 * return.
3031 */
3032int regulator_bulk_disable(int num_consumers,
3033 struct regulator_bulk_data *consumers)
3034{
3035 int i;
01e86f49 3036 int ret, r;
414c70cb 3037
49e22632 3038 for (i = num_consumers - 1; i >= 0; --i) {
414c70cb
LG		 3039 ret = regulator_disable(consumers[i].consumer);
3040 if (ret != 0)
3041 goto err;
3042 }
3043
3044 return 0;
3045
3046err:
5da84fd9 3047 pr_err("Failed to disable %s: %d\n", consumers[i].supply, ret);
01e86f49
MB		 3048 for (++i; i < num_consumers; ++i) {
3049 r = regulator_enable(consumers[i].consumer);
3050 if (r != 0)
3051 pr_err("Failed to reename %s: %d\n",
3052 consumers[i].supply, r);
3053 }
414c70cb
LG		 3054
3055 return ret;
3056}
3057EXPORT_SYMBOL_GPL(regulator_bulk_disable);
3058
e1de2f42
DK		 3059/**
3060 * regulator_bulk_force_disable - force disable multiple regulator consumers
3061 *
3062 * @num_consumers: Number of consumers
3063 * @consumers: Consumer data; clients are stored here.
3064 * @return 0 on success, an errno on failure
3065 *
3066 * This convenience API allows consumers to forcibly disable multiple regulator
3067 * clients in a single API call.
3068 * NOTE: This should be used for situations when device damage will
3069 * likely occur if the regulators are not disabled (e.g. over temp).
3070 * Although regulator_force_disable function call for some consumers can
3071 * return error numbers, the function is called for all consumers.
3072 */
3073int regulator_bulk_force_disable(int num_consumers,
3074 struct regulator_bulk_data *consumers)
3075{
3076 int i;
3077 int ret;
3078
3079 for (i = 0; i < num_consumers; i++)
3080 consumers[i].ret =
3081 regulator_force_disable(consumers[i].consumer);
3082
3083 for (i = 0; i < num_consumers; i++) {
3084 if (consumers[i].ret != 0) {
3085 ret = consumers[i].ret;
3086 goto out;
3087 }
3088 }
3089
3090 return 0;
3091out:
3092 return ret;
3093}
3094EXPORT_SYMBOL_GPL(regulator_bulk_force_disable);
3095
414c70cb
LG		 3096/**
3097 * regulator_bulk_free - free multiple regulator consumers
3098 *
3099 * @num_consumers: Number of consumers
3100 * @consumers: Consumer data; clients are stored here.
3101 *
3102 * This convenience API allows consumers to free multiple regulator
3103 * clients in a single API call.
3104 */
3105void regulator_bulk_free(int num_consumers,
3106 struct regulator_bulk_data *consumers)
3107{
3108 int i;
3109
3110 for (i = 0; i < num_consumers; i++) {
3111 regulator_put(consumers[i].consumer);
3112 consumers[i].consumer = NULL;
3113 }
3114}
3115EXPORT_SYMBOL_GPL(regulator_bulk_free);
3116
3117/**
3118 * regulator_notifier_call_chain - call regulator event notifier
69279fb9 3119 * @rdev: regulator source
414c70cb 3120 * @event: notifier block
69279fb9 3121 * @data: callback-specific data.
414c70cb
LG		 3122 *
3123 * Called by regulator drivers to notify clients a regulator event has
3124 * occurred. We also notify regulator clients downstream.
b136fb44 3125 * Note lock must be held by caller.
414c70cb
LG		 3126 */
3127int regulator_notifier_call_chain(struct regulator_dev *rdev,
3128 unsigned long event, void *data)
3129{
3130 _notifier_call_chain(rdev, event, data);
3131 return NOTIFY_DONE;
3132
3133}
3134EXPORT_SYMBOL_GPL(regulator_notifier_call_chain);
3135
be721979
MB		 3136/**
3137 * regulator_mode_to_status - convert a regulator mode into a status
3138 *
3139 * @mode: Mode to convert
3140 *
3141 * Convert a regulator mode into a status.
3142 */
3143int regulator_mode_to_status(unsigned int mode)
3144{
3145 switch (mode) {
3146 case REGULATOR_MODE_FAST:
3147 return REGULATOR_STATUS_FAST;
3148 case REGULATOR_MODE_NORMAL:
3149 return REGULATOR_STATUS_NORMAL;
3150 case REGULATOR_MODE_IDLE:
3151 return REGULATOR_STATUS_IDLE;
03ffcf3d 3152 case REGULATOR_MODE_STANDBY:
be721979
MB		 3153 return REGULATOR_STATUS_STANDBY;
3154 default:
1beaf762 3155 return REGULATOR_STATUS_UNDEFINED;
be721979
MB		 3156 }
3157}
3158EXPORT_SYMBOL_GPL(regulator_mode_to_status);
3159
7ad68e2f
DB		 3160/*
3161 * To avoid cluttering sysfs (and memory) with useless state, only
3162 * create attributes that can be meaningfully displayed.
3163 */
3164static int add_regulator_attributes(struct regulator_dev *rdev)
3165{
3166 struct device *dev = &rdev->dev;
3167 struct regulator_ops *ops = rdev->desc->ops;
3168 int status = 0;
3169
3170 /* some attributes need specific methods to be displayed */
4c78899b 3171 if ((ops->get_voltage && ops->get_voltage(rdev) >= 0) ||
f2889e65
MB		 3172 (ops->get_voltage_sel && ops->get_voltage_sel(rdev) >= 0) ||
3173 (ops->list_voltage && ops->list_voltage(rdev, 0) >= 0)) {
7ad68e2f
DB		 3174 status = device_create_file(dev, &dev_attr_microvolts);
3175 if (status < 0)
3176 return status;
3177 }
3178 if (ops->get_current_limit) {
3179 status = device_create_file(dev, &dev_attr_microamps);
3180 if (status < 0)
3181 return status;
3182 }
3183 if (ops->get_mode) {
3184 status = device_create_file(dev, &dev_attr_opmode);
3185 if (status < 0)
3186 return status;
3187 }
7b74d149 3188 if (rdev->ena_pin || ops->is_enabled) {
7ad68e2f
DB		 3189 status = device_create_file(dev, &dev_attr_state);
3190 if (status < 0)
3191 return status;
3192 }
853116a1
DB		 3193 if (ops->get_status) {
3194 status = device_create_file(dev, &dev_attr_status);
3195 if (status < 0)
3196 return status;
3197 }
f59c8f9f
MB		 3198 if (ops->get_bypass) {
3199 status = device_create_file(dev, &dev_attr_bypass);
3200 if (status < 0)
3201 return status;
3202 }
7ad68e2f
DB		 3203
3204 /* some attributes are type-specific */
3205 if (rdev->desc->type == REGULATOR_CURRENT) {
3206 status = device_create_file(dev, &dev_attr_requested_microamps);
3207 if (status < 0)
3208 return status;
3209 }
3210
3211 /* all the other attributes exist to support constraints;
3212 * don't show them if there are no constraints, or if the
3213 * relevant supporting methods are missing.
3214 */
3215 if (!rdev->constraints)
3216 return status;
3217
3218 /* constraints need specific supporting methods */
e8eef82b 3219 if (ops->set_voltage || ops->set_voltage_sel) {
7ad68e2f
DB		 3220 status = device_create_file(dev, &dev_attr_min_microvolts);
3221 if (status < 0)
3222 return status;
3223 status = device_create_file(dev, &dev_attr_max_microvolts);
3224 if (status < 0)
3225 return status;
3226 }
3227 if (ops->set_current_limit) {
3228 status = device_create_file(dev, &dev_attr_min_microamps);
3229 if (status < 0)
3230 return status;
3231 status = device_create_file(dev, &dev_attr_max_microamps);
3232 if (status < 0)
3233 return status;
3234 }
3235
7ad68e2f
DB		 3236 status = device_create_file(dev, &dev_attr_suspend_standby_state);
3237 if (status < 0)
3238 return status;
3239 status = device_create_file(dev, &dev_attr_suspend_mem_state);
3240 if (status < 0)
3241 return status;
3242 status = device_create_file(dev, &dev_attr_suspend_disk_state);
3243 if (status < 0)
3244 return status;
3245
3246 if (ops->set_suspend_voltage) {
3247 status = device_create_file(dev,
3248 &dev_attr_suspend_standby_microvolts);
3249 if (status < 0)
3250 return status;
3251 status = device_create_file(dev,
3252 &dev_attr_suspend_mem_microvolts);
3253 if (status < 0)
3254 return status;
3255 status = device_create_file(dev,
3256 &dev_attr_suspend_disk_microvolts);
3257 if (status < 0)
3258 return status;
3259 }
3260
3261 if (ops->set_suspend_mode) {
3262 status = device_create_file(dev,
3263 &dev_attr_suspend_standby_mode);
3264 if (status < 0)
3265 return status;
3266 status = device_create_file(dev,
3267 &dev_attr_suspend_mem_mode);
3268 if (status < 0)
3269 return status;
3270 status = device_create_file(dev,
3271 &dev_attr_suspend_disk_mode);
3272 if (status < 0)
3273 return status;
3274 }
3275
3276 return status;
3277}
3278
1130e5b3
MB		 3279static void rdev_init_debugfs(struct regulator_dev *rdev)
3280{
1130e5b3 3281 rdev->debugfs = debugfs_create_dir(rdev_get_name(rdev), debugfs_root);
24751434 3282 if (!rdev->debugfs) {
1130e5b3 3283 rdev_warn(rdev, "Failed to create debugfs directory\n");
1130e5b3
MB		 3284 return;
3285 }
3286
3287 debugfs_create_u32("use_count", 0444, rdev->debugfs,
3288 &rdev->use_count);
3289 debugfs_create_u32("open_count", 0444, rdev->debugfs,
3290 &rdev->open_count);
f59c8f9f
MB		 3291 debugfs_create_u32("bypass_count", 0444, rdev->debugfs,
3292 &rdev->bypass_count);
1130e5b3
MB		 3293}
3294
414c70cb
LG		 3295/**
3296 * regulator_register - register regulator
69279fb9 3297 * @regulator_desc: regulator to register
c172708d 3298 * @config: runtime configuration for regulator
414c70cb
LG		 3299 *
3300 * Called by regulator drivers to register a regulator.
0384618a
AL		 3301 * Returns a valid pointer to struct regulator_dev on success
3302 * or an ERR_PTR() on error.
414c70cb 3303 */
65f26846
MB		 3304struct regulator_dev *
3305regulator_register(const struct regulator_desc *regulator_desc,
c172708d 3306 const struct regulator_config *config)
414c70cb 3307{
9a8f5e07 3308 const struct regulation_constraints *constraints = NULL;
c172708d 3309 const struct regulator_init_data *init_data;
414c70cb
LG		 3310 static atomic_t regulator_no = ATOMIC_INIT(0);
3311 struct regulator_dev *rdev;
32c8fad4 3312 struct device *dev;
a5766f11 3313 int ret, i;
69511a45 3314 const char *supply = NULL;
414c70cb 3315
c172708d 3316 if (regulator_desc == NULL || config == NULL)
414c70cb
LG		 3317 return ERR_PTR(-EINVAL);
3318
32c8fad4 3319 dev = config->dev;
dcf70112 3320 WARN_ON(!dev);
32c8fad4 3321
414c70cb
LG		 3322 if (regulator_desc->name == NULL || regulator_desc->ops == NULL)
3323 return ERR_PTR(-EINVAL);
3324
cd78dfc6
DL		 3325 if (regulator_desc->type != REGULATOR_VOLTAGE &&
3326 regulator_desc->type != REGULATOR_CURRENT)
414c70cb
LG		 3327 return ERR_PTR(-EINVAL);
3328
476c2d83
MB		 3329 /* Only one of each should be implemented */
3330 WARN_ON(regulator_desc->ops->get_voltage &&
3331 regulator_desc->ops->get_voltage_sel);
e8eef82b
MB		 3332 WARN_ON(regulator_desc->ops->set_voltage &&
3333 regulator_desc->ops->set_voltage_sel);
476c2d83
MB		 3334
3335 /* If we're using selectors we must implement list_voltage. */
3336 if (regulator_desc->ops->get_voltage_sel &&
3337 !regulator_desc->ops->list_voltage) {
3338 return ERR_PTR(-EINVAL);
3339 }
e8eef82b
MB		 3340 if (regulator_desc->ops->set_voltage_sel &&
3341 !regulator_desc->ops->list_voltage) {
3342 return ERR_PTR(-EINVAL);
3343 }
476c2d83 3344
c172708d
MB		 3345 init_data = config->init_data;
3346
414c70cb
LG		 3347 rdev = kzalloc(sizeof(struct regulator_dev), GFP_KERNEL);
3348 if (rdev == NULL)
3349 return ERR_PTR(-ENOMEM);
3350
3351 mutex_lock(&regulator_list_mutex);
3352
3353 mutex_init(&rdev->mutex);
c172708d 3354 rdev->reg_data = config->driver_data;
414c70cb
LG		 3355 rdev->owner = regulator_desc->owner;
3356 rdev->desc = regulator_desc;
3a4b0a07
MB		 3357 if (config->regmap)
3358 rdev->regmap = config->regmap;
52b84dac 3359 else if (dev_get_regmap(dev, NULL))
3a4b0a07 3360 rdev->regmap = dev_get_regmap(dev, NULL);
52b84dac
AC		 3361 else if (dev->parent)
3362 rdev->regmap = dev_get_regmap(dev->parent, NULL);
414c70cb 3363 INIT_LIST_HEAD(&rdev->consumer_list);
414c70cb 3364 INIT_LIST_HEAD(&rdev->list);
414c70cb 3365 BLOCKING_INIT_NOTIFIER_HEAD(&rdev->notifier);
da07ecd9 3366 INIT_DELAYED_WORK(&rdev->disable_work, regulator_disable_work);
414c70cb 3367
a5766f11 3368 /* preform any regulator specific init */
9a8f5e07 3369 if (init_data && init_data->regulator_init) {
a5766f11 3370 ret = init_data->regulator_init(rdev->reg_data);
4fca9545
DB		 3371 if (ret < 0)
3372 goto clean;
a5766f11
LG		 3373 }
3374
a5766f11 3375 /* register with sysfs */
414c70cb 3376 rdev->dev.class = &regulator_class;
c172708d 3377 rdev->dev.of_node = config->of_node;
a5766f11 3378 rdev->dev.parent = dev;
812460a9
KS		 3379 dev_set_name(&rdev->dev, "regulator.%d",
3380 atomic_inc_return(&regulator_no) - 1);
a5766f11 3381 ret = device_register(&rdev->dev);
ad7725cb
VK		 3382 if (ret != 0) {
3383 put_device(&rdev->dev);
4fca9545 3384 goto clean;
ad7725cb 3385 }
a5766f11
LG		 3386
3387 dev_set_drvdata(&rdev->dev, rdev);
3388
b2a1ef47 3389 if (config->ena_gpio && gpio_is_valid(config->ena_gpio)) {
f19b00da 3390 ret = regulator_ena_gpio_request(rdev, config);
65f73508
MB		 3391 if (ret != 0) {
3392 rdev_err(rdev, "Failed to request enable GPIO%d: %d\n",
3393 config->ena_gpio, ret);
b2da55d9 3394 goto wash;
65f73508
MB		 3395 }
3396
65f73508
MB		 3397 if (config->ena_gpio_flags & GPIOF_OUT_INIT_HIGH)
3398 rdev->ena_gpio_state = 1;
3399
7b74d149 3400 if (config->ena_gpio_invert)
65f73508
MB		 3401 rdev->ena_gpio_state = !rdev->ena_gpio_state;
3402 }
3403
74f544c1 3404 /* set regulator constraints */
9a8f5e07
MB		 3405 if (init_data)
3406 constraints = &init_data->constraints;
3407
3408 ret = set_machine_constraints(rdev, constraints);
74f544c1
MR		 3409 if (ret < 0)
3410 goto scrub;
3411
7ad68e2f
DB		 3412 /* add attributes supported by this regulator */
3413 ret = add_regulator_attributes(rdev);
3414 if (ret < 0)
3415 goto scrub;
3416
9a8f5e07 3417 if (init_data && init_data->supply_regulator)
69511a45
RN		 3418 supply = init_data->supply_regulator;
3419 else if (regulator_desc->supply_name)
3420 supply = regulator_desc->supply_name;
3421
3422 if (supply) {
0178f3e2 3423 struct regulator_dev *r;
0178f3e2 3424
6d191a5f 3425 r = regulator_dev_lookup(dev, supply, &ret);
0178f3e2 3426
0f7b87f0
AB		 3427 if (ret == -ENODEV) {
3428 /*
3429 * No supply was specified for this regulator and
3430 * there will never be one.
3431 */
3432 ret = 0;
3433 goto add_dev;
3434 } else if (!r) {
69511a45 3435 dev_err(dev, "Failed to find supply %s\n", supply);
04bf3011 3436 ret = -EPROBE_DEFER;
0178f3e2
MB		 3437 goto scrub;
3438 }
3439
3440 ret = set_supply(rdev, r);
3441 if (ret < 0)
3442 goto scrub;
b2296bd4
LD		 3443
3444 /* Enable supply if rail is enabled */
b1a86831 3445 if (_regulator_is_enabled(rdev)) {
b2296bd4
LD		 3446 ret = regulator_enable(rdev->supply);
3447 if (ret < 0)
3448 goto scrub;
3449 }
0178f3e2
MB		 3450 }
3451
0f7b87f0 3452add_dev:
a5766f11 3453 /* add consumers devices */
9a8f5e07
MB		 3454 if (init_data) {
3455 for (i = 0; i < init_data->num_consumer_supplies; i++) {
3456 ret = set_consumer_device_supply(rdev,
9a8f5e07 3457 init_data->consumer_supplies[i].dev_name,
23c2f041 3458 init_data->consumer_supplies[i].supply);
9a8f5e07
MB		 3459 if (ret < 0) {
3460 dev_err(dev, "Failed to set supply %s\n",
3461 init_data->consumer_supplies[i].supply);
3462 goto unset_supplies;
3463 }
23c2f041 3464 }
414c70cb 3465 }
a5766f11
LG		 3466
3467 list_add(&rdev->list, &regulator_list);
1130e5b3
MB		 3468
3469 rdev_init_debugfs(rdev);
a5766f11 3470out:
414c70cb
LG		 3471 mutex_unlock(&regulator_list_mutex);
3472 return rdev;
4fca9545 3473
d4033b54
JN		 3474unset_supplies:
3475 unset_regulator_supplies(rdev);
3476
4fca9545 3477scrub:
e81dba85 3478 if (rdev->supply)
23ff2f0f 3479 _regulator_put(rdev->supply);
f19b00da 3480 regulator_ena_gpio_free(rdev);
1a6958e7 3481 kfree(rdev->constraints);
b2da55d9 3482wash:
4fca9545 3483 device_unregister(&rdev->dev);
53032daf
PW		 3484 /* device core frees rdev */
3485 rdev = ERR_PTR(ret);
3486 goto out;
3487
4fca9545
DB		 3488clean:
3489 kfree(rdev);
3490 rdev = ERR_PTR(ret);
3491 goto out;
414c70cb
LG		 3492}
3493EXPORT_SYMBOL_GPL(regulator_register);
3494
3495/**
3496 * regulator_unregister - unregister regulator
69279fb9 3497 * @rdev: regulator to unregister
414c70cb
LG		 3498 *
3499 * Called by regulator drivers to unregister a regulator.
3500 */
3501void regulator_unregister(struct regulator_dev *rdev)
3502{
3503 if (rdev == NULL)
3504 return;
3505
891636ea
MB		 3506 if (rdev->supply) {
3507 while (rdev->use_count--)
3508 regulator_disable(rdev->supply);
e032b376 3509 regulator_put(rdev->supply);
891636ea 3510 }
414c70cb 3511 mutex_lock(&regulator_list_mutex);
1130e5b3 3512 debugfs_remove_recursive(rdev->debugfs);
43829731 3513 flush_work(&rdev->disable_work.work);
6bf87d17 3514 WARN_ON(rdev->open_count);
0f1d747b 3515 unset_regulator_supplies(rdev);
414c70cb 3516 list_del(&rdev->list);
f8c12fe3 3517 kfree(rdev->constraints);
f19b00da 3518 regulator_ena_gpio_free(rdev);
58fb5cf5 3519 device_unregister(&rdev->dev);
414c70cb
LG		 3520 mutex_unlock(&regulator_list_mutex);
3521}
3522EXPORT_SYMBOL_GPL(regulator_unregister);
3523
414c70cb 3524/**
cf7bbcdf 3525 * regulator_suspend_prepare - prepare regulators for system wide suspend
414c70cb
LG		 3526 * @state: system suspend state
3527 *
3528 * Configure each regulator with it's suspend operating parameters for state.
3529 * This will usually be called by machine suspend code prior to supending.
3530 */
3531int regulator_suspend_prepare(suspend_state_t state)
3532{
3533 struct regulator_dev *rdev;
3534 int ret = 0;
3535
3536 /* ON is handled by regulator active state */
3537 if (state == PM_SUSPEND_ON)
3538 return -EINVAL;
3539
3540 mutex_lock(&regulator_list_mutex);
3541 list_for_each_entry(rdev, &regulator_list, list) {
3542
3543 mutex_lock(&rdev->mutex);
3544 ret = suspend_prepare(rdev, state);
3545 mutex_unlock(&rdev->mutex);
3546
3547 if (ret < 0) {
5da84fd9 3548 rdev_err(rdev, "failed to prepare\n");
414c70cb
LG		 3549 goto out;
3550 }
3551 }
3552out:
3553 mutex_unlock(&regulator_list_mutex);
3554 return ret;
3555}
3556EXPORT_SYMBOL_GPL(regulator_suspend_prepare);
3557
7a32b589
MH		 3558/**
3559 * regulator_suspend_finish - resume regulators from system wide suspend
3560 *
3561 * Turn on regulators that might be turned off by regulator_suspend_prepare
3562 * and that should be turned on according to the regulators properties.
3563 */
3564int regulator_suspend_finish(void)
3565{
3566 struct regulator_dev *rdev;
3567 int ret = 0, error;
3568
3569 mutex_lock(&regulator_list_mutex);
3570 list_for_each_entry(rdev, &regulator_list, list) {
3571 struct regulator_ops *ops = rdev->desc->ops;
3572
3573 mutex_lock(&rdev->mutex);
3574 if ((rdev->use_count > 0 || rdev->constraints->always_on) &&
3575 ops->enable) {
3576 error = ops->enable(rdev);
3577 if (error)
3578 ret = error;
3579 } else {
3580 if (!has_full_constraints)
3581 goto unlock;
3582 if (!ops->disable)
3583 goto unlock;
b1a86831 3584 if (!_regulator_is_enabled(rdev))
7a32b589
MH		 3585 goto unlock;
3586
3587 error = ops->disable(rdev);
3588 if (error)
3589 ret = error;
3590 }
3591unlock:
3592 mutex_unlock(&rdev->mutex);
3593 }
3594 mutex_unlock(&regulator_list_mutex);
3595 return ret;
3596}
3597EXPORT_SYMBOL_GPL(regulator_suspend_finish);
3598
ca725561
MB		 3599/**
3600 * regulator_has_full_constraints - the system has fully specified constraints
3601 *
3602 * Calling this function will cause the regulator API to disable all
3603 * regulators which have a zero use count and don't have an always_on
3604 * constraint in a late_initcall.
3605 *
3606 * The intention is that this will become the default behaviour in a
3607 * future kernel release so users are encouraged to use this facility
3608 * now.
3609 */
3610void regulator_has_full_constraints(void)
3611{
3612 has_full_constraints = 1;
3613}
3614EXPORT_SYMBOL_GPL(regulator_has_full_constraints);
3615
688fe99a
MB		 3616/**
3617 * regulator_use_dummy_regulator - Provide a dummy regulator when none is found
3618 *
3619 * Calling this function will cause the regulator API to provide a
3620 * dummy regulator to consumers if no physical regulator is found,
3621 * allowing most consumers to proceed as though a regulator were
3622 * configured. This allows systems such as those with software
3623 * controllable regulators for the CPU core only to be brought up more
3624 * readily.
3625 */
3626void regulator_use_dummy_regulator(void)
3627{
3628 board_wants_dummy_regulator = true;
3629}
3630EXPORT_SYMBOL_GPL(regulator_use_dummy_regulator);
3631
414c70cb
LG		 3632/**
3633 * rdev_get_drvdata - get rdev regulator driver data
69279fb9 3634 * @rdev: regulator
414c70cb
LG		 3635 *
3636 * Get rdev regulator driver private data. This call can be used in the
3637 * regulator driver context.
3638 */
3639void *rdev_get_drvdata(struct regulator_dev *rdev)
3640{
3641 return rdev->reg_data;
3642}
3643EXPORT_SYMBOL_GPL(rdev_get_drvdata);
3644
3645/**
3646 * regulator_get_drvdata - get regulator driver data
3647 * @regulator: regulator
3648 *
3649 * Get regulator driver private data. This call can be used in the consumer
3650 * driver context when non API regulator specific functions need to be called.
3651 */
3652void *regulator_get_drvdata(struct regulator *regulator)
3653{
3654 return regulator->rdev->reg_data;
3655}
3656EXPORT_SYMBOL_GPL(regulator_get_drvdata);
3657
3658/**
3659 * regulator_set_drvdata - set regulator driver data
3660 * @regulator: regulator
3661 * @data: data
3662 */
3663void regulator_set_drvdata(struct regulator *regulator, void *data)
3664{
3665 regulator->rdev->reg_data = data;
3666}
3667EXPORT_SYMBOL_GPL(regulator_set_drvdata);
3668
3669/**
3670 * regulator_get_id - get regulator ID
69279fb9 3671 * @rdev: regulator
414c70cb
LG		 3672 */
3673int rdev_get_id(struct regulator_dev *rdev)
3674{
3675 return rdev->desc->id;
3676}
3677EXPORT_SYMBOL_GPL(rdev_get_id);
3678
a5766f11
LG		 3679struct device *rdev_get_dev(struct regulator_dev *rdev)
3680{
3681 return &rdev->dev;
3682}
3683EXPORT_SYMBOL_GPL(rdev_get_dev);
3684
3685void *regulator_get_init_drvdata(struct regulator_init_data *reg_init_data)
3686{
3687 return reg_init_data->driver_data;
3688}
3689EXPORT_SYMBOL_GPL(regulator_get_init_drvdata);
3690
ba55a974
MB		 3691#ifdef CONFIG_DEBUG_FS
3692static ssize_t supply_map_read_file(struct file *file, char __user *user_buf,
3693 size_t count, loff_t *ppos)
3694{
3695 char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
3696 ssize_t len, ret = 0;
3697 struct regulator_map *map;
3698
3699 if (!buf)
3700 return -ENOMEM;
3701
3702 list_for_each_entry(map, &regulator_map_list, list) {
3703 len = snprintf(buf + ret, PAGE_SIZE - ret,
3704 "%s -> %s.%s\n",
3705 rdev_get_name(map->regulator), map->dev_name,
3706 map->supply);
3707 if (len >= 0)
3708 ret += len;
3709 if (ret > PAGE_SIZE) {
3710 ret = PAGE_SIZE;
3711 break;
3712 }
3713 }
3714
3715 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
3716
3717 kfree(buf);
3718
3719 return ret;
3720}
24751434 3721#endif
ba55a974
MB		 3722
3723static const struct file_operations supply_map_fops = {
24751434 3724#ifdef CONFIG_DEBUG_FS
ba55a974
MB		 3725 .read = supply_map_read_file,
3726 .llseek = default_llseek,
ba55a974 3727#endif
24751434 3728};
ba55a974 3729
414c70cb
LG		 3730static int __init regulator_init(void)
3731{
34abbd68
MB		 3732 int ret;
3733
34abbd68
MB		 3734 ret = class_register(&regulator_class);
3735
1130e5b3 3736 debugfs_root = debugfs_create_dir("regulator", NULL);
24751434 3737 if (!debugfs_root)
1130e5b3 3738 pr_warn("regulator: Failed to create debugfs directory\n");
ba55a974 3739
f4d562c6
MB		 3740 debugfs_create_file("supply_map", 0444, debugfs_root, NULL,
3741 &supply_map_fops);
1130e5b3 3742
34abbd68
MB		 3743 regulator_dummy_init();
3744
3745 return ret;
414c70cb
LG		 3746}
3747
3748/* init early to allow our consumers to complete system booting */
3749core_initcall(regulator_init);
ca725561
MB		 3750
3751static int __init regulator_init_complete(void)
3752{
3753 struct regulator_dev *rdev;
3754 struct regulator_ops *ops;
3755 struct regulation_constraints *c;
3756 int enabled, ret;
ca725561 3757
86f5fcfc
MB		 3758 /*
3759 * Since DT doesn't provide an idiomatic mechanism for
3760 * enabling full constraints and since it's much more natural
3761 * with DT to provide them just assume that a DT enabled
3762 * system has full constraints.
3763 */
3764 if (of_have_populated_dt())
3765 has_full_constraints = true;
3766
ca725561
MB		 3767 mutex_lock(&regulator_list_mutex);
3768
3769 /* If we have a full configuration then disable any regulators
3770 * which are not in use or always_on. This will become the
3771 * default behaviour in the future.
3772 */
3773 list_for_each_entry(rdev, &regulator_list, list) {
3774 ops = rdev->desc->ops;
3775 c = rdev->constraints;
3776
f25e0b4f 3777 if (!ops->disable || (c && c->always_on))
ca725561
MB		 3778 continue;
3779
3780 mutex_lock(&rdev->mutex);
3781
3782 if (rdev->use_count)
3783 goto unlock;
3784
3785 /* If we can't read the status assume it's on. */
3786 if (ops->is_enabled)
3787 enabled = ops->is_enabled(rdev);
3788 else
3789 enabled = 1;
3790
3791 if (!enabled)
3792 goto unlock;
3793
3794 if (has_full_constraints) {
3795 /* We log since this may kill the system if it
3796 * goes wrong. */
5da84fd9 3797 rdev_info(rdev, "disabling\n");
ca725561
MB		 3798 ret = ops->disable(rdev);
3799 if (ret != 0) {
5da84fd9 3800 rdev_err(rdev, "couldn't disable: %d\n", ret);
ca725561
MB		 3801 }
3802 } else {
3803 /* The intention is that in future we will
3804 * assume that full constraints are provided
3805 * so warn even if we aren't going to do
3806 * anything here.
3807 */
5da84fd9 3808 rdev_warn(rdev, "incomplete constraints, leaving on\n");
ca725561
MB		 3809 }
3810
3811unlock:
3812 mutex_unlock(&rdev->mutex);
3813 }
3814
3815 mutex_unlock(&regulator_list_mutex);
3816
3817 return 0;
3818}
3819late_initcall(regulator_init_complete);
Linux kernel - Deliverables
This page took 0.735962 seconds and 5 git commands to generate.