projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ASoC: Remove direct register cache accesses from WM8962 driver
[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
1d7372e1 16#define pr_fmt(fmt) "%s: " fmt, __func__
c5e28ed7 17
414c70cb
LG		 18#include <linux/kernel.h>
19#include <linux/init.h>
1130e5b3 20#include <linux/debugfs.h>
414c70cb 21#include <linux/device.h>
5a0e3ad6 22#include <linux/slab.h>
f21e0e81 23#include <linux/async.h>
414c70cb
LG		 24#include <linux/err.h>
25#include <linux/mutex.h>
26#include <linux/suspend.h>
31aae2be 27#include <linux/delay.h>
414c70cb
LG		 28#include <linux/regulator/consumer.h>
29#include <linux/regulator/driver.h>
30#include <linux/regulator/machine.h>
31
02fa3ec0
MB		 32#define CREATE_TRACE_POINTS
33#include <trace/events/regulator.h>
34
34abbd68
MB		 35#include "dummy.h"
36
7d51a0db
MB		 37#define rdev_crit(rdev, fmt, ...) \
38 pr_crit("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
5da84fd9
JP		 39#define rdev_err(rdev, fmt, ...) \
40 pr_err("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
41#define rdev_warn(rdev, fmt, ...) \
42 pr_warn("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
43#define rdev_info(rdev, fmt, ...) \
44 pr_info("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
45#define rdev_dbg(rdev, fmt, ...) \
46 pr_debug("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
47
414c70cb
LG		 48static DEFINE_MUTEX(regulator_list_mutex);
49static LIST_HEAD(regulator_list);
50static LIST_HEAD(regulator_map_list);
21cf891a 51static bool has_full_constraints;
688fe99a 52static bool board_wants_dummy_regulator;
414c70cb 53
1130e5b3
MB		 54#ifdef CONFIG_DEBUG_FS
55static struct dentry *debugfs_root;
56#endif
57
8dc5390d 58/*
414c70cb
LG		 59 * struct regulator_map
60 *
61 * Used to provide symbolic supply names to devices.
62 */
63struct regulator_map {
64 struct list_head list;
40f9244f 65 const char *dev_name; /* The dev_name() for the consumer */
414c70cb 66 const char *supply;
a5766f11 67 struct regulator_dev *regulator;
414c70cb
LG		 68};
69
414c70cb
LG		 70/*
71 * struct regulator
72 *
73 * One for each consumer device.
74 */
75struct regulator {
76 struct device *dev;
77 struct list_head list;
78 int uA_load;
79 int min_uV;
80 int max_uV;
414c70cb
LG		 81 char *supply_name;
82 struct device_attribute dev_attr;
83 struct regulator_dev *rdev;
5de70519
MB		 84#ifdef CONFIG_DEBUG_FS
85 struct dentry *debugfs;
86#endif
414c70cb
LG		 87};
88
89static int _regulator_is_enabled(struct regulator_dev *rdev);
3801b86a 90static int _regulator_disable(struct regulator_dev *rdev);
414c70cb
LG		 91static int _regulator_get_voltage(struct regulator_dev *rdev);
92static int _regulator_get_current_limit(struct regulator_dev *rdev);
93static unsigned int _regulator_get_mode(struct regulator_dev *rdev);
94static void _notifier_call_chain(struct regulator_dev *rdev,
95 unsigned long event, void *data);
75790251
MB		 96static int _regulator_do_set_voltage(struct regulator_dev *rdev,
97 int min_uV, int max_uV);
3801b86a
MB		 98static struct regulator *create_regulator(struct regulator_dev *rdev,
99 struct device *dev,
100 const char *supply_name);
414c70cb 101
1083c393
MB		 102static const char *rdev_get_name(struct regulator_dev *rdev)
103{
104 if (rdev->constraints && rdev->constraints->name)
105 return rdev->constraints->name;
106 else if (rdev->desc->name)
107 return rdev->desc->name;
108 else
109 return "";
110}
111
414c70cb
LG		 112/* gets the regulator for a given consumer device */
113static struct regulator *get_device_regulator(struct device *dev)
114{
115 struct regulator *regulator = NULL;
116 struct regulator_dev *rdev;
117
118 mutex_lock(&regulator_list_mutex);
119 list_for_each_entry(rdev, &regulator_list, list) {
120 mutex_lock(&rdev->mutex);
121 list_for_each_entry(regulator, &rdev->consumer_list, list) {
122 if (regulator->dev == dev) {
123 mutex_unlock(&rdev->mutex);
124 mutex_unlock(&regulator_list_mutex);
125 return regulator;
126 }
127 }
128 mutex_unlock(&rdev->mutex);
129 }
130 mutex_unlock(&regulator_list_mutex);
131 return NULL;
132}
133
134/* Platform voltage constraint check */
135static int regulator_check_voltage(struct regulator_dev *rdev,
136 int *min_uV, int *max_uV)
137{
138 BUG_ON(*min_uV > *max_uV);
139
140 if (!rdev->constraints) {
5da84fd9 141 rdev_err(rdev, "no constraints\n");
414c70cb
LG		 142 return -ENODEV;
143 }
144 if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) {
5da84fd9 145 rdev_err(rdev, "operation not allowed\n");
414c70cb
LG		 146 return -EPERM;
147 }
148
149 if (*max_uV > rdev->constraints->max_uV)
150 *max_uV = rdev->constraints->max_uV;
151 if (*min_uV < rdev->constraints->min_uV)
152 *min_uV = rdev->constraints->min_uV;
153
89f425ed
MB		 154 if (*min_uV > *max_uV) {
155 rdev_err(rdev, "unsupportable voltage range: %d-%duV\n",
54abd335 156 *min_uV, *max_uV);
414c70cb 157 return -EINVAL;
89f425ed 158 }
414c70cb
LG		 159
160 return 0;
161}
162
05fda3b1
TP		 163/* Make sure we select a voltage that suits the needs of all
164 * regulator consumers
165 */
166static int regulator_check_consumers(struct regulator_dev *rdev,
167 int *min_uV, int *max_uV)
168{
169 struct regulator *regulator;
170
171 list_for_each_entry(regulator, &rdev->consumer_list, list) {
4aa922c0
MB		 172 /*
173 * Assume consumers that didn't say anything are OK
174 * with anything in the constraint range.
175 */
176 if (!regulator->min_uV && !regulator->max_uV)
177 continue;
178
05fda3b1
TP		 179 if (*max_uV > regulator->max_uV)
180 *max_uV = regulator->max_uV;
181 if (*min_uV < regulator->min_uV)
182 *min_uV = regulator->min_uV;
183 }
184
185 if (*min_uV > *max_uV)
186 return -EINVAL;
187
188 return 0;
189}
190
414c70cb
LG		 191/* current constraint check */
192static int regulator_check_current_limit(struct regulator_dev *rdev,
193 int *min_uA, int *max_uA)
194{
195 BUG_ON(*min_uA > *max_uA);
196
197 if (!rdev->constraints) {
5da84fd9 198 rdev_err(rdev, "no constraints\n");
414c70cb
LG		 199 return -ENODEV;
200 }
201 if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_CURRENT)) {
5da84fd9 202 rdev_err(rdev, "operation not allowed\n");
414c70cb
LG		 203 return -EPERM;
204 }
205
206 if (*max_uA > rdev->constraints->max_uA)
207 *max_uA = rdev->constraints->max_uA;
208 if (*min_uA < rdev->constraints->min_uA)
209 *min_uA = rdev->constraints->min_uA;
210
89f425ed
MB		 211 if (*min_uA > *max_uA) {
212 rdev_err(rdev, "unsupportable current range: %d-%duA\n",
54abd335 213 *min_uA, *max_uA);
414c70cb 214 return -EINVAL;
89f425ed 215 }
414c70cb
LG		 216
217 return 0;
218}
219
220/* operating mode constraint check */
2c608234 221static int regulator_mode_constrain(struct regulator_dev *rdev, int *mode)
414c70cb 222{
2c608234 223 switch (*mode) {
e573520b
DB		 224 case REGULATOR_MODE_FAST:
225 case REGULATOR_MODE_NORMAL:
226 case REGULATOR_MODE_IDLE:
227 case REGULATOR_MODE_STANDBY:
228 break;
229 default:
89f425ed 230 rdev_err(rdev, "invalid mode %x specified\n", *mode);
e573520b
DB		 231 return -EINVAL;
232 }
233
414c70cb 234 if (!rdev->constraints) {
5da84fd9 235 rdev_err(rdev, "no constraints\n");
414c70cb
LG		 236 return -ENODEV;
237 }
238 if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_MODE)) {
5da84fd9 239 rdev_err(rdev, "operation not allowed\n");
414c70cb
LG		 240 return -EPERM;
241 }
2c608234
MB		 242
243 /* The modes are bitmasks, the most power hungry modes having
244 * the lowest values. If the requested mode isn't supported
245 * try higher modes. */
246 while (*mode) {
247 if (rdev->constraints->valid_modes_mask & *mode)
248 return 0;
249 *mode /= 2;
414c70cb 250 }
2c608234
MB		 251
252 return -EINVAL;
414c70cb
LG		 253}
254
255/* dynamic regulator mode switching constraint check */
256static int regulator_check_drms(struct regulator_dev *rdev)
257{
258 if (!rdev->constraints) {
5da84fd9 259 rdev_err(rdev, "no constraints\n");
414c70cb
LG		 260 return -ENODEV;
261 }
262 if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_DRMS)) {
5da84fd9 263 rdev_err(rdev, "operation not allowed\n");
414c70cb
LG		 264 return -EPERM;
265 }
266 return 0;
267}
268
269static ssize_t device_requested_uA_show(struct device *dev,
270 struct device_attribute *attr, char *buf)
271{
272 struct regulator *regulator;
273
274 regulator = get_device_regulator(dev);
275 if (regulator == NULL)
276 return 0;
277
278 return sprintf(buf, "%d\n", regulator->uA_load);
279}
280
281static ssize_t regulator_uV_show(struct device *dev,
282 struct device_attribute *attr, char *buf)
283{
a5766f11 284 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb
LG		 285 ssize_t ret;
286
287 mutex_lock(&rdev->mutex);
288 ret = sprintf(buf, "%d\n", _regulator_get_voltage(rdev));
289 mutex_unlock(&rdev->mutex);
290
291 return ret;
292}
7ad68e2f 293static DEVICE_ATTR(microvolts, 0444, regulator_uV_show, NULL);
414c70cb
LG		 294
295static ssize_t regulator_uA_show(struct device *dev,
296 struct device_attribute *attr, char *buf)
297{
a5766f11 298 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb
LG		 299
300 return sprintf(buf, "%d\n", _regulator_get_current_limit(rdev));
301}
7ad68e2f 302static DEVICE_ATTR(microamps, 0444, regulator_uA_show, NULL);
414c70cb 303
bc558a60
MB		 304static ssize_t regulator_name_show(struct device *dev,
305 struct device_attribute *attr, char *buf)
306{
307 struct regulator_dev *rdev = dev_get_drvdata(dev);
bc558a60 308
1083c393 309 return sprintf(buf, "%s\n", rdev_get_name(rdev));
bc558a60
MB		 310}
311
4fca9545 312static ssize_t regulator_print_opmode(char *buf, int mode)
414c70cb 313{
414c70cb
LG		 314 switch (mode) {
315 case REGULATOR_MODE_FAST:
316 return sprintf(buf, "fast\n");
317 case REGULATOR_MODE_NORMAL:
318 return sprintf(buf, "normal\n");
319 case REGULATOR_MODE_IDLE:
320 return sprintf(buf, "idle\n");
321 case REGULATOR_MODE_STANDBY:
322 return sprintf(buf, "standby\n");
323 }
324 return sprintf(buf, "unknown\n");
325}
326
4fca9545
DB		 327static ssize_t regulator_opmode_show(struct device *dev,
328 struct device_attribute *attr, char *buf)
414c70cb 329{
a5766f11 330 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb 331
4fca9545
DB		 332 return regulator_print_opmode(buf, _regulator_get_mode(rdev));
333}
7ad68e2f 334static DEVICE_ATTR(opmode, 0444, regulator_opmode_show, NULL);
4fca9545
DB		 335
336static ssize_t regulator_print_state(char *buf, int state)
337{
414c70cb
LG		 338 if (state > 0)
339 return sprintf(buf, "enabled\n");
340 else if (state == 0)
341 return sprintf(buf, "disabled\n");
342 else
343 return sprintf(buf, "unknown\n");
344}
345
4fca9545
DB		 346static ssize_t regulator_state_show(struct device *dev,
347 struct device_attribute *attr, char *buf)
348{
349 struct regulator_dev *rdev = dev_get_drvdata(dev);
9332546f
MB		 350 ssize_t ret;
351
352 mutex_lock(&rdev->mutex);
353 ret = regulator_print_state(buf, _regulator_is_enabled(rdev));
354 mutex_unlock(&rdev->mutex);
4fca9545 355
9332546f 356 return ret;
4fca9545 357}
7ad68e2f 358static DEVICE_ATTR(state, 0444, regulator_state_show, NULL);
4fca9545 359
853116a1
DB		 360static ssize_t regulator_status_show(struct device *dev,
361 struct device_attribute *attr, char *buf)
362{
363 struct regulator_dev *rdev = dev_get_drvdata(dev);
364 int status;
365 char *label;
366
367 status = rdev->desc->ops->get_status(rdev);
368 if (status < 0)
369 return status;
370
371 switch (status) {
372 case REGULATOR_STATUS_OFF:
373 label = "off";
374 break;
375 case REGULATOR_STATUS_ON:
376 label = "on";
377 break;
378 case REGULATOR_STATUS_ERROR:
379 label = "error";
380 break;
381 case REGULATOR_STATUS_FAST:
382 label = "fast";
383 break;
384 case REGULATOR_STATUS_NORMAL:
385 label = "normal";
386 break;
387 case REGULATOR_STATUS_IDLE:
388 label = "idle";
389 break;
390 case REGULATOR_STATUS_STANDBY:
391 label = "standby";
392 break;
393 default:
394 return -ERANGE;
395 }
396
397 return sprintf(buf, "%s\n", label);
398}
399static DEVICE_ATTR(status, 0444, regulator_status_show, NULL);
400
414c70cb
LG		 401static ssize_t regulator_min_uA_show(struct device *dev,
402 struct device_attribute *attr, char *buf)
403{
a5766f11 404 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb
LG		 405
406 if (!rdev->constraints)
407 return sprintf(buf, "constraint not defined\n");
408
409 return sprintf(buf, "%d\n", rdev->constraints->min_uA);
410}
7ad68e2f 411static DEVICE_ATTR(min_microamps, 0444, regulator_min_uA_show, NULL);
414c70cb
LG		 412
413static ssize_t regulator_max_uA_show(struct device *dev,
414 struct device_attribute *attr, char *buf)
415{
a5766f11 416 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb
LG		 417
418 if (!rdev->constraints)
419 return sprintf(buf, "constraint not defined\n");
420
421 return sprintf(buf, "%d\n", rdev->constraints->max_uA);
422}
7ad68e2f 423static DEVICE_ATTR(max_microamps, 0444, regulator_max_uA_show, NULL);
414c70cb
LG		 424
425static ssize_t regulator_min_uV_show(struct device *dev,
426 struct device_attribute *attr, char *buf)
427{
a5766f11 428 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb
LG		 429
430 if (!rdev->constraints)
431 return sprintf(buf, "constraint not defined\n");
432
433 return sprintf(buf, "%d\n", rdev->constraints->min_uV);
434}
7ad68e2f 435static DEVICE_ATTR(min_microvolts, 0444, regulator_min_uV_show, NULL);
414c70cb
LG		 436
437static ssize_t regulator_max_uV_show(struct device *dev,
438 struct device_attribute *attr, char *buf)
439{
a5766f11 440 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb
LG		 441
442 if (!rdev->constraints)
443 return sprintf(buf, "constraint not defined\n");
444
445 return sprintf(buf, "%d\n", rdev->constraints->max_uV);
446}
7ad68e2f 447static DEVICE_ATTR(max_microvolts, 0444, regulator_max_uV_show, NULL);
414c70cb
LG		 448
449static ssize_t regulator_total_uA_show(struct device *dev,
450 struct device_attribute *attr, char *buf)
451{
a5766f11 452 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb
LG		 453 struct regulator *regulator;
454 int uA = 0;
455
456 mutex_lock(&rdev->mutex);
457 list_for_each_entry(regulator, &rdev->consumer_list, list)
fa2984d4 458 uA += regulator->uA_load;
414c70cb
LG		 459 mutex_unlock(&rdev->mutex);
460 return sprintf(buf, "%d\n", uA);
461}
7ad68e2f 462static DEVICE_ATTR(requested_microamps, 0444, regulator_total_uA_show, NULL);
414c70cb
LG		 463
464static ssize_t regulator_num_users_show(struct device *dev,
465 struct device_attribute *attr, char *buf)
466{
a5766f11 467 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb
LG		 468 return sprintf(buf, "%d\n", rdev->use_count);
469}
470
471static ssize_t regulator_type_show(struct device *dev,
472 struct device_attribute *attr, char *buf)
473{
a5766f11 474 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb
LG		 475
476 switch (rdev->desc->type) {
477 case REGULATOR_VOLTAGE:
478 return sprintf(buf, "voltage\n");
479 case REGULATOR_CURRENT:
480 return sprintf(buf, "current\n");
481 }
482 return sprintf(buf, "unknown\n");
483}
484
485static ssize_t regulator_suspend_mem_uV_show(struct device *dev,
486 struct device_attribute *attr, char *buf)
487{
a5766f11 488 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb 489
414c70cb
LG		 490 return sprintf(buf, "%d\n", rdev->constraints->state_mem.uV);
491}
7ad68e2f
DB		 492static DEVICE_ATTR(suspend_mem_microvolts, 0444,
493 regulator_suspend_mem_uV_show, NULL);
414c70cb
LG		 494
495static ssize_t regulator_suspend_disk_uV_show(struct device *dev,
496 struct device_attribute *attr, char *buf)
497{
a5766f11 498 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb 499
414c70cb
LG		 500 return sprintf(buf, "%d\n", rdev->constraints->state_disk.uV);
501}
7ad68e2f
DB		 502static DEVICE_ATTR(suspend_disk_microvolts, 0444,
503 regulator_suspend_disk_uV_show, NULL);
414c70cb
LG		 504
505static ssize_t regulator_suspend_standby_uV_show(struct device *dev,
506 struct device_attribute *attr, char *buf)
507{
a5766f11 508 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb 509
414c70cb
LG		 510 return sprintf(buf, "%d\n", rdev->constraints->state_standby.uV);
511}
7ad68e2f
DB		 512static DEVICE_ATTR(suspend_standby_microvolts, 0444,
513 regulator_suspend_standby_uV_show, NULL);
414c70cb 514
414c70cb
LG		 515static ssize_t regulator_suspend_mem_mode_show(struct device *dev,
516 struct device_attribute *attr, char *buf)
517{
a5766f11 518 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb 519
4fca9545
DB		 520 return regulator_print_opmode(buf,
521 rdev->constraints->state_mem.mode);
414c70cb 522}
7ad68e2f
DB		 523static DEVICE_ATTR(suspend_mem_mode, 0444,
524 regulator_suspend_mem_mode_show, NULL);
414c70cb
LG		 525
526static ssize_t regulator_suspend_disk_mode_show(struct device *dev,
527 struct device_attribute *attr, char *buf)
528{
a5766f11 529 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb 530
4fca9545
DB		 531 return regulator_print_opmode(buf,
532 rdev->constraints->state_disk.mode);
414c70cb 533}
7ad68e2f
DB		 534static DEVICE_ATTR(suspend_disk_mode, 0444,
535 regulator_suspend_disk_mode_show, NULL);
414c70cb
LG		 536
537static ssize_t regulator_suspend_standby_mode_show(struct device *dev,
538 struct device_attribute *attr, char *buf)
539{
a5766f11 540 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb 541
4fca9545
DB		 542 return regulator_print_opmode(buf,
543 rdev->constraints->state_standby.mode);
414c70cb 544}
7ad68e2f
DB		 545static DEVICE_ATTR(suspend_standby_mode, 0444,
546 regulator_suspend_standby_mode_show, NULL);
414c70cb
LG		 547
548static ssize_t regulator_suspend_mem_state_show(struct device *dev,
549 struct device_attribute *attr, char *buf)
550{
a5766f11 551 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb 552
4fca9545
DB		 553 return regulator_print_state(buf,
554 rdev->constraints->state_mem.enabled);
414c70cb 555}
7ad68e2f
DB		 556static DEVICE_ATTR(suspend_mem_state, 0444,
557 regulator_suspend_mem_state_show, NULL);
414c70cb
LG		 558
559static ssize_t regulator_suspend_disk_state_show(struct device *dev,
560 struct device_attribute *attr, char *buf)
561{
a5766f11 562 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb 563
4fca9545
DB		 564 return regulator_print_state(buf,
565 rdev->constraints->state_disk.enabled);
414c70cb 566}
7ad68e2f
DB		 567static DEVICE_ATTR(suspend_disk_state, 0444,
568 regulator_suspend_disk_state_show, NULL);
414c70cb
LG		 569
570static ssize_t regulator_suspend_standby_state_show(struct device *dev,
571 struct device_attribute *attr, char *buf)
572{
a5766f11 573 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb 574
4fca9545
DB		 575 return regulator_print_state(buf,
576 rdev->constraints->state_standby.enabled);
414c70cb 577}
7ad68e2f
DB		 578static DEVICE_ATTR(suspend_standby_state, 0444,
579 regulator_suspend_standby_state_show, NULL);
580
bc558a60 581
7ad68e2f
DB		 582/*
583 * These are the only attributes are present for all regulators.
584 * Other attributes are a function of regulator functionality.
585 */
414c70cb 586static struct device_attribute regulator_dev_attrs[] = {
bc558a60 587 __ATTR(name, 0444, regulator_name_show, NULL),
414c70cb
LG		 588 __ATTR(num_users, 0444, regulator_num_users_show, NULL),
589 __ATTR(type, 0444, regulator_type_show, NULL),
414c70cb
LG		 590 __ATTR_NULL,
591};
592
593static void regulator_dev_release(struct device *dev)
594{
a5766f11 595 struct regulator_dev *rdev = dev_get_drvdata(dev);
414c70cb
LG		 596 kfree(rdev);
597}
598
599static struct class regulator_class = {
600 .name = "regulator",
601 .dev_release = regulator_dev_release,
602 .dev_attrs = regulator_dev_attrs,
603};
604
605/* Calculate the new optimum regulator operating mode based on the new total
606 * consumer load. All locks held by caller */
607static void drms_uA_update(struct regulator_dev *rdev)
608{
609 struct regulator *sibling;
610 int current_uA = 0, output_uV, input_uV, err;
611 unsigned int mode;
612
613 err = regulator_check_drms(rdev);
614 if (err < 0 || !rdev->desc->ops->get_optimum_mode ||
476c2d83
MB		 615 (!rdev->desc->ops->get_voltage &&
616 !rdev->desc->ops->get_voltage_sel) ||
617 !rdev->desc->ops->set_mode)
036de8ef 618 return;
414c70cb
LG		 619
620 /* get output voltage */
1bf5a1f8 621 output_uV = _regulator_get_voltage(rdev);
414c70cb
LG		 622 if (output_uV <= 0)
623 return;
624
625 /* get input voltage */
1bf5a1f8
MB		 626 input_uV = 0;
627 if (rdev->supply)
628 input_uV = _regulator_get_voltage(rdev);
629 if (input_uV <= 0)
414c70cb
LG		 630 input_uV = rdev->constraints->input_uV;
631 if (input_uV <= 0)
632 return;
633
634 /* calc total requested load */
635 list_for_each_entry(sibling, &rdev->consumer_list, list)
fa2984d4 636 current_uA += sibling->uA_load;
414c70cb
LG		 637
638 /* now get the optimum mode for our new total regulator load */
639 mode = rdev->desc->ops->get_optimum_mode(rdev, input_uV,
640 output_uV, current_uA);
641
642 /* check the new mode is allowed */
2c608234 643 err = regulator_mode_constrain(rdev, &mode);
414c70cb
LG		 644 if (err == 0)
645 rdev->desc->ops->set_mode(rdev, mode);
646}
647
648static int suspend_set_state(struct regulator_dev *rdev,
649 struct regulator_state *rstate)
650{
651 int ret = 0;
638f85c5
MB		 652 bool can_set_state;
653
654 can_set_state = rdev->desc->ops->set_suspend_enable &&
655 rdev->desc->ops->set_suspend_disable;
656
657 /* If we have no suspend mode configration don't set anything;
658 * only warn if the driver actually makes the suspend mode
659 * configurable.
660 */
661 if (!rstate->enabled && !rstate->disabled) {
662 if (can_set_state)
5da84fd9 663 rdev_warn(rdev, "No configuration\n");
638f85c5
MB		 664 return 0;
665 }
666
667 if (rstate->enabled && rstate->disabled) {
5da84fd9 668 rdev_err(rdev, "invalid configuration\n");
638f85c5
MB		 669 return -EINVAL;
670 }
414c70cb 671
638f85c5 672 if (!can_set_state) {
5da84fd9 673 rdev_err(rdev, "no way to set suspend state\n");
414c70cb 674 return -EINVAL;
a5766f11 675 }
414c70cb
LG		 676
677 if (rstate->enabled)
678 ret = rdev->desc->ops->set_suspend_enable(rdev);
679 else
680 ret = rdev->desc->ops->set_suspend_disable(rdev);
681 if (ret < 0) {
5da84fd9 682 rdev_err(rdev, "failed to enabled/disable\n");
414c70cb
LG		 683 return ret;
684 }
685
686 if (rdev->desc->ops->set_suspend_voltage && rstate->uV > 0) {
687 ret = rdev->desc->ops->set_suspend_voltage(rdev, rstate->uV);
688 if (ret < 0) {
5da84fd9 689 rdev_err(rdev, "failed to set voltage\n");
414c70cb
LG		 690 return ret;
691 }
692 }
693
694 if (rdev->desc->ops->set_suspend_mode && rstate->mode > 0) {
695 ret = rdev->desc->ops->set_suspend_mode(rdev, rstate->mode);
696 if (ret < 0) {
5da84fd9 697 rdev_err(rdev, "failed to set mode\n");
414c70cb
LG		 698 return ret;
699 }
700 }
701 return ret;
702}
703
704/* locks held by caller */
705static int suspend_prepare(struct regulator_dev *rdev, suspend_state_t state)
706{
707 if (!rdev->constraints)
708 return -EINVAL;
709
710 switch (state) {
711 case PM_SUSPEND_STANDBY:
712 return suspend_set_state(rdev,
713 &rdev->constraints->state_standby);
714 case PM_SUSPEND_MEM:
715 return suspend_set_state(rdev,
716 &rdev->constraints->state_mem);
717 case PM_SUSPEND_MAX:
718 return suspend_set_state(rdev,
719 &rdev->constraints->state_disk);
720 default:
721 return -EINVAL;
722 }
723}
724
725static void print_constraints(struct regulator_dev *rdev)
726{
727 struct regulation_constraints *constraints = rdev->constraints;
973e9a27 728 char buf[80] = "";
8f031b48
MB		 729 int count = 0;
730 int ret;
414c70cb 731
8f031b48 732 if (constraints->min_uV && constraints->max_uV) {
414c70cb 733 if (constraints->min_uV == constraints->max_uV)
8f031b48
MB		 734 count += sprintf(buf + count, "%d mV ",
735 constraints->min_uV / 1000);
414c70cb 736 else
8f031b48
MB		 737 count += sprintf(buf + count, "%d <--> %d mV ",
738 constraints->min_uV / 1000,
739 constraints->max_uV / 1000);
740 }
741
742 if (!constraints->min_uV ||
743 constraints->min_uV != constraints->max_uV) {
744 ret = _regulator_get_voltage(rdev);
745 if (ret > 0)
746 count += sprintf(buf + count, "at %d mV ", ret / 1000);
747 }
748
bf5892a8
MB		 749 if (constraints->uV_offset)
750 count += sprintf(buf, "%dmV offset ",
751 constraints->uV_offset / 1000);
752
8f031b48 753 if (constraints->min_uA && constraints->max_uA) {
414c70cb 754 if (constraints->min_uA == constraints->max_uA)
8f031b48
MB		 755 count += sprintf(buf + count, "%d mA ",
756 constraints->min_uA / 1000);
414c70cb 757 else
8f031b48
MB		 758 count += sprintf(buf + count, "%d <--> %d mA ",
759 constraints->min_uA / 1000,
760 constraints->max_uA / 1000);
761 }
762
763 if (!constraints->min_uA ||
764 constraints->min_uA != constraints->max_uA) {
765 ret = _regulator_get_current_limit(rdev);
766 if (ret > 0)
e4a6376b 767 count += sprintf(buf + count, "at %d mA ", ret / 1000);
414c70cb 768 }
8f031b48 769
414c70cb
LG		 770 if (constraints->valid_modes_mask & REGULATOR_MODE_FAST)
771 count += sprintf(buf + count, "fast ");
772 if (constraints->valid_modes_mask & REGULATOR_MODE_NORMAL)
773 count += sprintf(buf + count, "normal ");
774 if (constraints->valid_modes_mask & REGULATOR_MODE_IDLE)
775 count += sprintf(buf + count, "idle ");
776 if (constraints->valid_modes_mask & REGULATOR_MODE_STANDBY)
777 count += sprintf(buf + count, "standby");
778
13ce29f8 779 rdev_info(rdev, "%s\n", buf);
414c70cb
LG		 780}
781
e79055d6 782static int machine_constraints_voltage(struct regulator_dev *rdev,
1083c393 783 struct regulation_constraints *constraints)
a5766f11 784{
e5fda26c 785 struct regulator_ops *ops = rdev->desc->ops;
af5866c9
MB		 786 int ret;
787
788 /* do we need to apply the constraint voltage */
789 if (rdev->constraints->apply_uV &&
75790251
MB		 790 rdev->constraints->min_uV == rdev->constraints->max_uV) {
791 ret = _regulator_do_set_voltage(rdev,
792 rdev->constraints->min_uV,
793 rdev->constraints->max_uV);
794 if (ret < 0) {
795 rdev_err(rdev, "failed to apply %duV constraint\n",
796 rdev->constraints->min_uV);
75790251
MB		 797 return ret;
798 }
af5866c9 799 }
e06f5b4f 800
4367cfdc
DB		 801 /* constrain machine-level voltage specs to fit
802 * the actual range supported by this regulator.
803 */
804 if (ops->list_voltage && rdev->desc->n_voltages) {
805 int count = rdev->desc->n_voltages;
806 int i;
807 int min_uV = INT_MAX;
808 int max_uV = INT_MIN;
809 int cmin = constraints->min_uV;
810 int cmax = constraints->max_uV;
811
3e590918
MB		 812 /* it's safe to autoconfigure fixed-voltage supplies
813 and the constraints are used by list_voltage. */
4367cfdc 814 if (count == 1 && !cmin) {
3e590918 815 cmin = 1;
4367cfdc 816 cmax = INT_MAX;
3e590918
MB		 817 constraints->min_uV = cmin;
818 constraints->max_uV = cmax;
4367cfdc
DB		 819 }
820
3e2b9abd
MB		 821 /* voltage constraints are optional */
822 if ((cmin == 0) && (cmax == 0))
e79055d6 823 return 0;
3e2b9abd 824
4367cfdc 825 /* else require explicit machine-level constraints */
3e2b9abd 826 if (cmin <= 0 || cmax <= 0 || cmax < cmin) {
5da84fd9 827 rdev_err(rdev, "invalid voltage constraints\n");
e79055d6 828 return -EINVAL;
4367cfdc
DB		 829 }
830
831 /* initial: [cmin..cmax] valid, [min_uV..max_uV] not */
832 for (i = 0; i < count; i++) {
833 int value;
834
835 value = ops->list_voltage(rdev, i);
836 if (value <= 0)
837 continue;
838
839 /* maybe adjust [min_uV..max_uV] */
840 if (value >= cmin && value < min_uV)
841 min_uV = value;
842 if (value <= cmax && value > max_uV)
843 max_uV = value;
844 }
845
846 /* final: [min_uV..max_uV] valid iff constraints valid */
847 if (max_uV < min_uV) {
5da84fd9 848 rdev_err(rdev, "unsupportable voltage constraints\n");
e79055d6 849 return -EINVAL;
4367cfdc
DB		 850 }
851
852 /* use regulator's subset of machine constraints */
853 if (constraints->min_uV < min_uV) {
5da84fd9
JP		 854 rdev_dbg(rdev, "override min_uV, %d -> %d\n",
855 constraints->min_uV, min_uV);
4367cfdc
DB		 856 constraints->min_uV = min_uV;
857 }
858 if (constraints->max_uV > max_uV) {
5da84fd9
JP		 859 rdev_dbg(rdev, "override max_uV, %d -> %d\n",
860 constraints->max_uV, max_uV);
4367cfdc
DB		 861 constraints->max_uV = max_uV;
862 }
863 }
864
e79055d6
MB		 865 return 0;
866}
867
868/**
869 * set_machine_constraints - sets regulator constraints
870 * @rdev: regulator source
871 * @constraints: constraints to apply
872 *
873 * Allows platform initialisation code to define and constrain
874 * regulator circuits e.g. valid voltage/current ranges, etc. NOTE:
875 * Constraints *must* be set by platform code in order for some
876 * regulator operations to proceed i.e. set_voltage, set_current_limit,
877 * set_mode.
878 */
879static int set_machine_constraints(struct regulator_dev *rdev,
f8c12fe3 880 const struct regulation_constraints *constraints)
e79055d6
MB		 881{
882 int ret = 0;
e79055d6
MB		 883 struct regulator_ops *ops = rdev->desc->ops;
884
f8c12fe3
MB		 885 rdev->constraints = kmemdup(constraints, sizeof(*constraints),
886 GFP_KERNEL);
887 if (!rdev->constraints)
888 return -ENOMEM;
af5866c9 889
f8c12fe3 890 ret = machine_constraints_voltage(rdev, rdev->constraints);
e79055d6
MB		 891 if (ret != 0)
892 goto out;
893
a5766f11 894 /* do we need to setup our suspend state */
e06f5b4f 895 if (constraints->initial_state) {
f8c12fe3 896 ret = suspend_prepare(rdev, rdev->constraints->initial_state);
e06f5b4f 897 if (ret < 0) {
5da84fd9 898 rdev_err(rdev, "failed to set suspend state\n");
e06f5b4f
MB		 899 goto out;
900 }
901 }
a5766f11 902
a308466c
MB		 903 if (constraints->initial_mode) {
904 if (!ops->set_mode) {
5da84fd9 905 rdev_err(rdev, "no set_mode operation\n");
a308466c
MB		 906 ret = -EINVAL;
907 goto out;
908 }
909
f8c12fe3 910 ret = ops->set_mode(rdev, rdev->constraints->initial_mode);
a308466c 911 if (ret < 0) {
5da84fd9 912 rdev_err(rdev, "failed to set initial mode: %d\n", ret);
a308466c
MB		 913 goto out;
914 }
915 }
916
cacf90f2
MB		 917 /* If the constraints say the regulator should be on at this point
918 * and we have control then make sure it is enabled.
919 */
f8c12fe3
MB		 920 if ((rdev->constraints->always_on || rdev->constraints->boot_on) &&
921 ops->enable) {
e5fda26c
MB		 922 ret = ops->enable(rdev);
923 if (ret < 0) {
5da84fd9 924 rdev_err(rdev, "failed to enable\n");
e5fda26c
MB		 925 goto out;
926 }
927 }
928
a5766f11 929 print_constraints(rdev);
1a6958e7 930 return 0;
a5766f11 931out:
1a6958e7
AL		 932 kfree(rdev->constraints);
933 rdev->constraints = NULL;
a5766f11
LG		 934 return ret;
935}
936
937/**
938 * set_supply - set regulator supply regulator
69279fb9
MB		 939 * @rdev: regulator name
940 * @supply_rdev: supply regulator name
a5766f11
LG		 941 *
942 * Called by platform initialisation code to set the supply regulator for this
943 * regulator. This ensures that a regulators supply will also be enabled by the
944 * core if it's child is enabled.
945 */
946static int set_supply(struct regulator_dev *rdev,
3801b86a 947 struct regulator_dev *supply_rdev)
a5766f11
LG		 948{
949 int err;
950
3801b86a
MB		 951 rdev_info(rdev, "supplied by %s\n", rdev_get_name(supply_rdev));
952
953 rdev->supply = create_regulator(supply_rdev, &rdev->dev, "SUPPLY");
954 if (IS_ERR(rdev->supply)) {
955 err = PTR_ERR(rdev->supply);
956 rdev->supply = NULL;
957 return err;
a5766f11 958 }
3801b86a
MB		 959
960 return 0;
a5766f11
LG		 961}
962
963/**
06c63f93 964 * set_consumer_device_supply - Bind a regulator to a symbolic supply
69279fb9
MB		 965 * @rdev: regulator source
966 * @consumer_dev: device the supply applies to
40f9244f 967 * @consumer_dev_name: dev_name() string for device supply applies to
69279fb9 968 * @supply: symbolic name for supply
a5766f11
LG		 969 *
970 * Allows platform initialisation code to map physical regulator
971 * sources to symbolic names for supplies for use by devices. Devices
972 * should use these symbolic names to request regulators, avoiding the
973 * need to provide board-specific regulator names as platform data.
40f9244f
MB		 974 *
975 * Only one of consumer_dev and consumer_dev_name may be specified.
a5766f11
LG		 976 */
977static int set_consumer_device_supply(struct regulator_dev *rdev,
40f9244f
MB		 978 struct device *consumer_dev, const char *consumer_dev_name,
979 const char *supply)
a5766f11
LG		 980{
981 struct regulator_map *node;
9ed2099e 982 int has_dev;
a5766f11 983
40f9244f
MB		 984 if (consumer_dev && consumer_dev_name)
985 return -EINVAL;
986
987 if (!consumer_dev_name && consumer_dev)
988 consumer_dev_name = dev_name(consumer_dev);
989
a5766f11
LG		 990 if (supply == NULL)
991 return -EINVAL;
992
9ed2099e
MB		 993 if (consumer_dev_name != NULL)
994 has_dev = 1;
995 else
996 has_dev = 0;
997
6001e13c 998 list_for_each_entry(node, &regulator_map_list, list) {
23b5cc2a
JN		 999 if (node->dev_name && consumer_dev_name) {
1000 if (strcmp(node->dev_name, consumer_dev_name) != 0)
1001 continue;
1002 } else if (node->dev_name || consumer_dev_name) {
6001e13c 1003 continue;
23b5cc2a
JN		 1004 }
1005
6001e13c
DB		 1006 if (strcmp(node->supply, supply) != 0)
1007 continue;
1008
1009 dev_dbg(consumer_dev, "%s/%s is '%s' supply; fail %s/%s\n",
5da84fd9
JP		 1010 dev_name(&node->regulator->dev),
1011 node->regulator->desc->name,
1012 supply,
1013 dev_name(&rdev->dev), rdev_get_name(rdev));
6001e13c
DB		 1014 return -EBUSY;
1015 }
1016
9ed2099e 1017 node = kzalloc(sizeof(struct regulator_map), GFP_KERNEL);
a5766f11
LG		 1018 if (node == NULL)
1019 return -ENOMEM;
1020
1021 node->regulator = rdev;
a5766f11
LG		 1022 node->supply = supply;
1023
9ed2099e
MB		 1024 if (has_dev) {
1025 node->dev_name = kstrdup(consumer_dev_name, GFP_KERNEL);
1026 if (node->dev_name == NULL) {
1027 kfree(node);
1028 return -ENOMEM;
1029 }
40f9244f
MB		 1030 }
1031
a5766f11
LG		 1032 list_add(&node->list, &regulator_map_list);
1033 return 0;
1034}
1035
0f1d747b
MR		 1036static void unset_regulator_supplies(struct regulator_dev *rdev)
1037{
1038 struct regulator_map *node, *n;
1039
1040 list_for_each_entry_safe(node, n, &regulator_map_list, list) {
1041 if (rdev == node->regulator) {
1042 list_del(&node->list);
40f9244f 1043 kfree(node->dev_name);
0f1d747b 1044 kfree(node);
0f1d747b
MR		 1045 }
1046 }
1047}
1048
f5726ae3 1049#define REG_STR_SIZE 64
414c70cb
LG		 1050
1051static struct regulator *create_regulator(struct regulator_dev *rdev,
1052 struct device *dev,
1053 const char *supply_name)
1054{
1055 struct regulator *regulator;
1056 char buf[REG_STR_SIZE];
1057 int err, size;
1058
1059 regulator = kzalloc(sizeof(*regulator), GFP_KERNEL);
1060 if (regulator == NULL)
1061 return NULL;
1062
1063 mutex_lock(&rdev->mutex);
1064 regulator->rdev = rdev;
1065 list_add(&regulator->list, &rdev->consumer_list);
1066
1067 if (dev) {
1068 /* create a 'requested_microamps_name' sysfs entry */
e0eaedef
MB		 1069 size = scnprintf(buf, REG_STR_SIZE,
1070 "microamps_requested_%s-%s",
1071 dev_name(dev), supply_name);
414c70cb
LG		 1072 if (size >= REG_STR_SIZE)
1073 goto overflow_err;
1074
1075 regulator->dev = dev;
4f26a2ab 1076 sysfs_attr_init(&regulator->dev_attr.attr);
414c70cb
LG		 1077 regulator->dev_attr.attr.name = kstrdup(buf, GFP_KERNEL);
1078 if (regulator->dev_attr.attr.name == NULL)
1079 goto attr_name_err;
1080
414c70cb
LG		 1081 regulator->dev_attr.attr.mode = 0444;
1082 regulator->dev_attr.show = device_requested_uA_show;
1083 err = device_create_file(dev, &regulator->dev_attr);
1084 if (err < 0) {
5da84fd9 1085 rdev_warn(rdev, "could not add regulator_dev requested microamps sysfs entry\n");
414c70cb
LG		 1086 goto attr_name_err;
1087 }
1088
1089 /* also add a link to the device sysfs entry */
1090 size = scnprintf(buf, REG_STR_SIZE, "%s-%s",
1091 dev->kobj.name, supply_name);
1092 if (size >= REG_STR_SIZE)
1093 goto attr_err;
1094
1095 regulator->supply_name = kstrdup(buf, GFP_KERNEL);
1096 if (regulator->supply_name == NULL)
1097 goto attr_err;
1098
1099 err = sysfs_create_link(&rdev->dev.kobj, &dev->kobj,
1100 buf);
1101 if (err) {
5da84fd9
JP		 1102 rdev_warn(rdev, "could not add device link %s err %d\n",
1103 dev->kobj.name, err);
414c70cb
LG		 1104 goto link_name_err;
1105 }
5de70519
MB		 1106 } else {
1107 regulator->supply_name = kstrdup(supply_name, GFP_KERNEL);
1108 if (regulator->supply_name == NULL)
1109 goto attr_err;
1110 }
1111
1112#ifdef CONFIG_DEBUG_FS
1113 regulator->debugfs = debugfs_create_dir(regulator->supply_name,
1114 rdev->debugfs);
1115 if (IS_ERR_OR_NULL(regulator->debugfs)) {
1116 rdev_warn(rdev, "Failed to create debugfs directory\n");
1117 regulator->debugfs = NULL;
1118 } else {
1119 debugfs_create_u32("uA_load", 0444, regulator->debugfs,
1120 &regulator->uA_load);
1121 debugfs_create_u32("min_uV", 0444, regulator->debugfs,
1122 &regulator->min_uV);
1123 debugfs_create_u32("max_uV", 0444, regulator->debugfs,
1124 &regulator->max_uV);
414c70cb 1125 }
5de70519
MB		 1126#endif
1127
414c70cb
LG		 1128 mutex_unlock(&rdev->mutex);
1129 return regulator;
1130link_name_err:
1131 kfree(regulator->supply_name);
1132attr_err:
1133 device_remove_file(regulator->dev, &regulator->dev_attr);
1134attr_name_err:
1135 kfree(regulator->dev_attr.attr.name);
1136overflow_err:
1137 list_del(&regulator->list);
1138 kfree(regulator);
1139 mutex_unlock(&rdev->mutex);
1140 return NULL;
1141}
1142
31aae2be
MB		 1143static int _regulator_get_enable_time(struct regulator_dev *rdev)
1144{
1145 if (!rdev->desc->ops->enable_time)
1146 return 0;
1147 return rdev->desc->ops->enable_time(rdev);
1148}
1149
5ffbd136
MB		 1150/* Internal regulator request function */
1151static struct regulator *_regulator_get(struct device *dev, const char *id,
1152 int exclusive)
414c70cb
LG		 1153{
1154 struct regulator_dev *rdev;
1155 struct regulator_map *map;
1156 struct regulator *regulator = ERR_PTR(-ENODEV);
40f9244f 1157 const char *devname = NULL;
5ffbd136 1158 int ret;
414c70cb
LG		 1159
1160 if (id == NULL) {
5da84fd9 1161 pr_err("get() with no identifier\n");
414c70cb
LG		 1162 return regulator;
1163 }
1164
40f9244f
MB		 1165 if (dev)
1166 devname = dev_name(dev);
1167
414c70cb
LG		 1168 mutex_lock(&regulator_list_mutex);
1169
1170 list_for_each_entry(map, &regulator_map_list, list) {
40f9244f
MB		 1171 /* If the mapping has a device set up it must match */
1172 if (map->dev_name &&
1173 (!devname || strcmp(map->dev_name, devname)))
1174 continue;
1175
1176 if (strcmp(map->supply, id) == 0) {
a5766f11 1177 rdev = map->regulator;
414c70cb 1178 goto found;
a5766f11 1179 }
414c70cb 1180 }
34abbd68 1181
688fe99a
MB		 1182 if (board_wants_dummy_regulator) {
1183 rdev = dummy_regulator_rdev;
1184 goto found;
1185 }
1186
34abbd68
MB		 1187#ifdef CONFIG_REGULATOR_DUMMY
1188 if (!devname)
1189 devname = "deviceless";
1190
1191 /* If the board didn't flag that it was fully constrained then
1192 * substitute in a dummy regulator so consumers can continue.
1193 */
1194 if (!has_full_constraints) {
5da84fd9
JP		 1195 pr_warn("%s supply %s not found, using dummy regulator\n",
1196 devname, id);
34abbd68
MB		 1197 rdev = dummy_regulator_rdev;
1198 goto found;
1199 }
1200#endif
1201
414c70cb
LG		 1202 mutex_unlock(&regulator_list_mutex);
1203 return regulator;
1204
1205found:
5ffbd136
MB		 1206 if (rdev->exclusive) {
1207 regulator = ERR_PTR(-EPERM);
1208 goto out;
1209 }
1210
1211 if (exclusive && rdev->open_count) {
1212 regulator = ERR_PTR(-EBUSY);
1213 goto out;
1214 }
1215
a5766f11
LG		 1216 if (!try_module_get(rdev->owner))
1217 goto out;
1218
414c70cb
LG		 1219 regulator = create_regulator(rdev, dev, id);
1220 if (regulator == NULL) {
1221 regulator = ERR_PTR(-ENOMEM);
1222 module_put(rdev->owner);
1223 }
1224
5ffbd136
MB		 1225 rdev->open_count++;
1226 if (exclusive) {
1227 rdev->exclusive = 1;
1228
1229 ret = _regulator_is_enabled(rdev);
1230 if (ret > 0)
1231 rdev->use_count = 1;
1232 else
1233 rdev->use_count = 0;
1234 }
1235
a5766f11 1236out:
414c70cb 1237 mutex_unlock(&regulator_list_mutex);
5ffbd136 1238
414c70cb
LG		 1239 return regulator;
1240}
5ffbd136
MB		 1241
1242/**
1243 * regulator_get - lookup and obtain a reference to a regulator.
1244 * @dev: device for regulator "consumer"
1245 * @id: Supply name or regulator ID.
1246 *
1247 * Returns a struct regulator corresponding to the regulator producer,
1248 * or IS_ERR() condition containing errno.
1249 *
1250 * Use of supply names configured via regulator_set_device_supply() is
1251 * strongly encouraged. It is recommended that the supply name used
1252 * should match the name used for the supply and/or the relevant
1253 * device pins in the datasheet.
1254 */
1255struct regulator *regulator_get(struct device *dev, const char *id)
1256{
1257 return _regulator_get(dev, id, 0);
1258}
414c70cb
LG		 1259EXPORT_SYMBOL_GPL(regulator_get);
1260
5ffbd136
MB		 1261/**
1262 * regulator_get_exclusive - obtain exclusive access to a regulator.
1263 * @dev: device for regulator "consumer"
1264 * @id: Supply name or regulator ID.
1265 *
1266 * Returns a struct regulator corresponding to the regulator producer,
1267 * or IS_ERR() condition containing errno. Other consumers will be
1268 * unable to obtain this reference is held and the use count for the
1269 * regulator will be initialised to reflect the current state of the
1270 * regulator.
1271 *
1272 * This is intended for use by consumers which cannot tolerate shared
1273 * use of the regulator such as those which need to force the
1274 * regulator off for correct operation of the hardware they are
1275 * controlling.
1276 *
1277 * Use of supply names configured via regulator_set_device_supply() is
1278 * strongly encouraged. It is recommended that the supply name used
1279 * should match the name used for the supply and/or the relevant
1280 * device pins in the datasheet.
1281 */
1282struct regulator *regulator_get_exclusive(struct device *dev, const char *id)
1283{
1284 return _regulator_get(dev, id, 1);
1285}
1286EXPORT_SYMBOL_GPL(regulator_get_exclusive);
1287
414c70cb
LG		 1288/**
1289 * regulator_put - "free" the regulator source
1290 * @regulator: regulator source
1291 *
1292 * Note: drivers must ensure that all regulator_enable calls made on this
1293 * regulator source are balanced by regulator_disable calls prior to calling
1294 * this function.
1295 */
1296void regulator_put(struct regulator *regulator)
1297{
1298 struct regulator_dev *rdev;
1299
1300 if (regulator == NULL || IS_ERR(regulator))
1301 return;
1302
414c70cb
LG		 1303 mutex_lock(&regulator_list_mutex);
1304 rdev = regulator->rdev;
1305
5de70519
MB		 1306#ifdef CONFIG_DEBUG_FS
1307 debugfs_remove_recursive(regulator->debugfs);
1308#endif
1309
414c70cb
LG		 1310 /* remove any sysfs entries */
1311 if (regulator->dev) {
1312 sysfs_remove_link(&rdev->dev.kobj, regulator->supply_name);
414c70cb
LG		 1313 device_remove_file(regulator->dev, &regulator->dev_attr);
1314 kfree(regulator->dev_attr.attr.name);
1315 }
5de70519 1316 kfree(regulator->supply_name);
414c70cb
LG		 1317 list_del(&regulator->list);
1318 kfree(regulator);
1319
5ffbd136
MB		 1320 rdev->open_count--;
1321 rdev->exclusive = 0;
1322
414c70cb
LG		 1323 module_put(rdev->owner);
1324 mutex_unlock(&regulator_list_mutex);
1325}
1326EXPORT_SYMBOL_GPL(regulator_put);
1327
9a2372fa
MB		 1328static int _regulator_can_change_status(struct regulator_dev *rdev)
1329{
1330 if (!rdev->constraints)
1331 return 0;
1332
1333 if (rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_STATUS)
1334 return 1;
1335 else
1336 return 0;
1337}
1338
414c70cb
LG		 1339/* locks held by regulator_enable() */
1340static int _regulator_enable(struct regulator_dev *rdev)
1341{
31aae2be 1342 int ret, delay;
414c70cb 1343
414c70cb 1344 /* check voltage and requested load before enabling */
9a2372fa
MB		 1345 if (rdev->constraints &&
1346 (rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_DRMS))
1347 drms_uA_update(rdev);
414c70cb 1348
9a2372fa
MB		 1349 if (rdev->use_count == 0) {
1350 /* The regulator may on if it's not switchable or left on */
1351 ret = _regulator_is_enabled(rdev);
1352 if (ret == -EINVAL || ret == 0) {
1353 if (!_regulator_can_change_status(rdev))
1354 return -EPERM;
1355
31aae2be 1356 if (!rdev->desc->ops->enable)
9a2372fa 1357 return -EINVAL;
31aae2be
MB		 1358
1359 /* Query before enabling in case configuration
25985edc 1360 * dependent. */
31aae2be
MB		 1361 ret = _regulator_get_enable_time(rdev);
1362 if (ret >= 0) {
1363 delay = ret;
1364 } else {
5da84fd9 1365 rdev_warn(rdev, "enable_time() failed: %d\n",
1d7372e1 1366 ret);
31aae2be 1367 delay = 0;
9a2372fa 1368 }
31aae2be 1369
02fa3ec0
MB		 1370 trace_regulator_enable(rdev_get_name(rdev));
1371
31aae2be
MB		 1372 /* Allow the regulator to ramp; it would be useful
1373 * to extend this for bulk operations so that the
1374 * regulators can ramp together. */
1375 ret = rdev->desc->ops->enable(rdev);
1376 if (ret < 0)
1377 return ret;
1378
02fa3ec0
MB		 1379 trace_regulator_enable_delay(rdev_get_name(rdev));
1380
e36c1df8 1381 if (delay >= 1000) {
31aae2be 1382 mdelay(delay / 1000);
e36c1df8
AL		 1383 udelay(delay % 1000);
1384 } else if (delay) {
31aae2be 1385 udelay(delay);
e36c1df8 1386 }
31aae2be 1387
02fa3ec0
MB		 1388 trace_regulator_enable_complete(rdev_get_name(rdev));
1389
a7433cff 1390 } else if (ret < 0) {
5da84fd9 1391 rdev_err(rdev, "is_enabled() failed: %d\n", ret);
414c70cb
LG		 1392 return ret;
1393 }
a7433cff 1394 /* Fallthrough on positive return values - already enabled */
414c70cb
LG		 1395 }
1396
9a2372fa
MB		 1397 rdev->use_count++;
1398
1399 return 0;
414c70cb
LG		 1400}
1401
1402/**
1403 * regulator_enable - enable regulator output
1404 * @regulator: regulator source
1405 *
cf7bbcdf
MB		 1406 * Request that the regulator be enabled with the regulator output at
1407 * the predefined voltage or current value. Calls to regulator_enable()
1408 * must be balanced with calls to regulator_disable().
1409 *
414c70cb 1410 * NOTE: the output value can be set by other drivers, boot loader or may be
cf7bbcdf 1411 * hardwired in the regulator.
414c70cb
LG		 1412 */
1413int regulator_enable(struct regulator *regulator)
1414{
412aec61
DB		 1415 struct regulator_dev *rdev = regulator->rdev;
1416 int ret = 0;
414c70cb 1417
3801b86a
MB		 1418 if (rdev->supply) {
1419 ret = regulator_enable(rdev->supply);
1420 if (ret != 0)
1421 return ret;
1422 }
1423
412aec61 1424 mutex_lock(&rdev->mutex);
cd94b505 1425 ret = _regulator_enable(rdev);
412aec61 1426 mutex_unlock(&rdev->mutex);
3801b86a
MB		 1427
1428 if (ret != 0)
1429 regulator_disable(rdev->supply);
1430
414c70cb
LG		 1431 return ret;
1432}
1433EXPORT_SYMBOL_GPL(regulator_enable);
1434
1435/* locks held by regulator_disable() */
3801b86a 1436static int _regulator_disable(struct regulator_dev *rdev)
414c70cb
LG		 1437{
1438 int ret = 0;
1439
cd94b505 1440 if (WARN(rdev->use_count <= 0,
43e7ee33 1441 "unbalanced disables for %s\n", rdev_get_name(rdev)))
cd94b505
DB		 1442 return -EIO;
1443
414c70cb 1444 /* are we the last user and permitted to disable ? */
60ef66fc
MB		 1445 if (rdev->use_count == 1 &&
1446 (rdev->constraints && !rdev->constraints->always_on)) {
414c70cb
LG		 1447
1448 /* we are last user */
9a2372fa
MB		 1449 if (_regulator_can_change_status(rdev) &&
1450 rdev->desc->ops->disable) {
02fa3ec0
MB		 1451 trace_regulator_disable(rdev_get_name(rdev));
1452
414c70cb
LG		 1453 ret = rdev->desc->ops->disable(rdev);
1454 if (ret < 0) {
5da84fd9 1455 rdev_err(rdev, "failed to disable\n");
414c70cb
LG		 1456 return ret;
1457 }
84b68263 1458
02fa3ec0
MB		 1459 trace_regulator_disable_complete(rdev_get_name(rdev));
1460
84b68263
MB		 1461 _notifier_call_chain(rdev, REGULATOR_EVENT_DISABLE,
1462 NULL);
414c70cb
LG		 1463 }
1464
414c70cb
LG		 1465 rdev->use_count = 0;
1466 } else if (rdev->use_count > 1) {
1467
1468 if (rdev->constraints &&
1469 (rdev->constraints->valid_ops_mask &
1470 REGULATOR_CHANGE_DRMS))
1471 drms_uA_update(rdev);
1472
1473 rdev->use_count--;
1474 }
3801b86a 1475
414c70cb
LG		 1476 return ret;
1477}
1478
1479/**
1480 * regulator_disable - disable regulator output
1481 * @regulator: regulator source
1482 *
cf7bbcdf
MB		 1483 * Disable the regulator output voltage or current. Calls to
1484 * regulator_enable() must be balanced with calls to
1485 * regulator_disable().
69279fb9 1486 *
414c70cb 1487 * NOTE: this will only disable the regulator output if no other consumer
cf7bbcdf
MB		 1488 * devices have it enabled, the regulator device supports disabling and
1489 * machine constraints permit this operation.
414c70cb
LG		 1490 */
1491int regulator_disable(struct regulator *regulator)
1492{
412aec61
DB		 1493 struct regulator_dev *rdev = regulator->rdev;
1494 int ret = 0;
414c70cb 1495
412aec61 1496 mutex_lock(&rdev->mutex);
3801b86a 1497 ret = _regulator_disable(rdev);
412aec61 1498 mutex_unlock(&rdev->mutex);
8cbf811d 1499
3801b86a
MB		 1500 if (ret == 0 && rdev->supply)
1501 regulator_disable(rdev->supply);
8cbf811d 1502
414c70cb
LG		 1503 return ret;
1504}
1505EXPORT_SYMBOL_GPL(regulator_disable);
1506
1507/* locks held by regulator_force_disable() */
3801b86a 1508static int _regulator_force_disable(struct regulator_dev *rdev)
414c70cb
LG		 1509{
1510 int ret = 0;
1511
1512 /* force disable */
1513 if (rdev->desc->ops->disable) {
1514 /* ah well, who wants to live forever... */
1515 ret = rdev->desc->ops->disable(rdev);
1516 if (ret < 0) {
5da84fd9 1517 rdev_err(rdev, "failed to force disable\n");
414c70cb
LG		 1518 return ret;
1519 }
1520 /* notify other consumers that power has been forced off */
84b68263
MB		 1521 _notifier_call_chain(rdev, REGULATOR_EVENT_FORCE_DISABLE |
1522 REGULATOR_EVENT_DISABLE, NULL);
414c70cb
LG		 1523 }
1524
414c70cb
LG		 1525 return ret;
1526}
1527
1528/**
1529 * regulator_force_disable - force disable regulator output
1530 * @regulator: regulator source
1531 *
1532 * Forcibly disable the regulator output voltage or current.
1533 * NOTE: this *will* disable the regulator output even if other consumer
1534 * devices have it enabled. This should be used for situations when device
1535 * damage will likely occur if the regulator is not disabled (e.g. over temp).
1536 */
1537int regulator_force_disable(struct regulator *regulator)
1538{
82d15839 1539 struct regulator_dev *rdev = regulator->rdev;
414c70cb
LG		 1540 int ret;
1541
82d15839 1542 mutex_lock(&rdev->mutex);
414c70cb 1543 regulator->uA_load = 0;
3801b86a 1544 ret = _regulator_force_disable(regulator->rdev);
82d15839 1545 mutex_unlock(&rdev->mutex);
8cbf811d 1546
3801b86a
MB		 1547 if (rdev->supply)
1548 while (rdev->open_count--)
1549 regulator_disable(rdev->supply);
8cbf811d 1550
414c70cb
LG		 1551 return ret;
1552}
1553EXPORT_SYMBOL_GPL(regulator_force_disable);
1554
da07ecd9
MB		 1555static void regulator_disable_work(struct work_struct *work)
1556{
1557 struct regulator_dev *rdev = container_of(work, struct regulator_dev,
1558 disable_work.work);
1559 int count, i, ret;
1560
1561 mutex_lock(&rdev->mutex);
1562
1563 BUG_ON(!rdev->deferred_disables);
1564
1565 count = rdev->deferred_disables;
1566 rdev->deferred_disables = 0;
1567
1568 for (i = 0; i < count; i++) {
1569 ret = _regulator_disable(rdev);
1570 if (ret != 0)
1571 rdev_err(rdev, "Deferred disable failed: %d\n", ret);
1572 }
1573
1574 mutex_unlock(&rdev->mutex);
1575
1576 if (rdev->supply) {
1577 for (i = 0; i < count; i++) {
1578 ret = regulator_disable(rdev->supply);
1579 if (ret != 0) {
1580 rdev_err(rdev,
1581 "Supply disable failed: %d\n", ret);
1582 }
1583 }
1584 }
1585}
1586
1587/**
1588 * regulator_disable_deferred - disable regulator output with delay
1589 * @regulator: regulator source
1590 * @ms: miliseconds until the regulator is disabled
1591 *
1592 * Execute regulator_disable() on the regulator after a delay. This
1593 * is intended for use with devices that require some time to quiesce.
1594 *
1595 * NOTE: this will only disable the regulator output if no other consumer
1596 * devices have it enabled, the regulator device supports disabling and
1597 * machine constraints permit this operation.
1598 */
1599int regulator_disable_deferred(struct regulator *regulator, int ms)
1600{
1601 struct regulator_dev *rdev = regulator->rdev;
1602
1603 mutex_lock(&rdev->mutex);
1604 rdev->deferred_disables++;
1605 mutex_unlock(&rdev->mutex);
1606
1607 return schedule_delayed_work(&rdev->disable_work,
1608 msecs_to_jiffies(ms));
1609}
1610EXPORT_SYMBOL_GPL(regulator_disable_deferred);
1611
414c70cb
LG		 1612static int _regulator_is_enabled(struct regulator_dev *rdev)
1613{
9a7f6a4c 1614 /* If we don't know then assume that the regulator is always on */
9332546f 1615 if (!rdev->desc->ops->is_enabled)
9a7f6a4c 1616 return 1;
414c70cb 1617
9332546f 1618 return rdev->desc->ops->is_enabled(rdev);
414c70cb
LG		 1619}
1620
1621/**
1622 * regulator_is_enabled - is the regulator output enabled
1623 * @regulator: regulator source
1624 *
412aec61
DB		 1625 * Returns positive if the regulator driver backing the source/client
1626 * has requested that the device be enabled, zero if it hasn't, else a
1627 * negative errno code.
1628 *
1629 * Note that the device backing this regulator handle can have multiple
1630 * users, so it might be enabled even if regulator_enable() was never
1631 * called for this particular source.
414c70cb
LG		 1632 */
1633int regulator_is_enabled(struct regulator *regulator)
1634{
9332546f
MB		 1635 int ret;
1636
1637 mutex_lock(&regulator->rdev->mutex);
1638 ret = _regulator_is_enabled(regulator->rdev);
1639 mutex_unlock(&regulator->rdev->mutex);
1640
1641 return ret;
414c70cb
LG		 1642}
1643EXPORT_SYMBOL_GPL(regulator_is_enabled);
1644
4367cfdc
DB		 1645/**
1646 * regulator_count_voltages - count regulator_list_voltage() selectors
1647 * @regulator: regulator source
1648 *
1649 * Returns number of selectors, or negative errno. Selectors are
1650 * numbered starting at zero, and typically correspond to bitfields
1651 * in hardware registers.
1652 */
1653int regulator_count_voltages(struct regulator *regulator)
1654{
1655 struct regulator_dev *rdev = regulator->rdev;
1656
1657 return rdev->desc->n_voltages ? : -EINVAL;
1658}
1659EXPORT_SYMBOL_GPL(regulator_count_voltages);
1660
1661/**
1662 * regulator_list_voltage - enumerate supported voltages
1663 * @regulator: regulator source
1664 * @selector: identify voltage to list
1665 * Context: can sleep
1666 *
1667 * Returns a voltage that can be passed to @regulator_set_voltage(),
88393161 1668 * zero if this selector code can't be used on this system, or a
4367cfdc
DB		 1669 * negative errno.
1670 */
1671int regulator_list_voltage(struct regulator *regulator, unsigned selector)
1672{
1673 struct regulator_dev *rdev = regulator->rdev;
1674 struct regulator_ops *ops = rdev->desc->ops;
1675 int ret;
1676
1677 if (!ops->list_voltage || selector >= rdev->desc->n_voltages)
1678 return -EINVAL;
1679
1680 mutex_lock(&rdev->mutex);
1681 ret = ops->list_voltage(rdev, selector);
1682 mutex_unlock(&rdev->mutex);
1683
1684 if (ret > 0) {
1685 if (ret < rdev->constraints->min_uV)
1686 ret = 0;
1687 else if (ret > rdev->constraints->max_uV)
1688 ret = 0;
1689 }
1690
1691 return ret;
1692}
1693EXPORT_SYMBOL_GPL(regulator_list_voltage);
1694
a7a1ad90
MB		 1695/**
1696 * regulator_is_supported_voltage - check if a voltage range can be supported
1697 *
1698 * @regulator: Regulator to check.
1699 * @min_uV: Minimum required voltage in uV.
1700 * @max_uV: Maximum required voltage in uV.
1701 *
1702 * Returns a boolean or a negative error code.
1703 */
1704int regulator_is_supported_voltage(struct regulator *regulator,
1705 int min_uV, int max_uV)
1706{
1707 int i, voltages, ret;
1708
1709 ret = regulator_count_voltages(regulator);
1710 if (ret < 0)
1711 return ret;
1712 voltages = ret;
1713
1714 for (i = 0; i < voltages; i++) {
1715 ret = regulator_list_voltage(regulator, i);
1716
1717 if (ret >= min_uV && ret <= max_uV)
1718 return 1;
1719 }
1720
1721 return 0;
1722}
1723
75790251
MB		 1724static int _regulator_do_set_voltage(struct regulator_dev *rdev,
1725 int min_uV, int max_uV)
1726{
1727 int ret;
77af1b26 1728 int delay = 0;
75790251
MB		 1729 unsigned int selector;
1730
1731 trace_regulator_set_voltage(rdev_get_name(rdev), min_uV, max_uV);
1732
bf5892a8
MB		 1733 min_uV += rdev->constraints->uV_offset;
1734 max_uV += rdev->constraints->uV_offset;
1735
75790251
MB		 1736 if (rdev->desc->ops->set_voltage) {
1737 ret = rdev->desc->ops->set_voltage(rdev, min_uV, max_uV,
1738 &selector);
1739
1740 if (rdev->desc->ops->list_voltage)
1741 selector = rdev->desc->ops->list_voltage(rdev,
1742 selector);
1743 else
1744 selector = -1;
e8eef82b
MB		 1745 } else if (rdev->desc->ops->set_voltage_sel) {
1746 int best_val = INT_MAX;
1747 int i;
1748
1749 selector = 0;
1750
1751 /* Find the smallest voltage that falls within the specified
1752 * range.
1753 */
1754 for (i = 0; i < rdev->desc->n_voltages; i++) {
1755 ret = rdev->desc->ops->list_voltage(rdev, i);
1756 if (ret < 0)
1757 continue;
1758
1759 if (ret < best_val && ret >= min_uV && ret <= max_uV) {
1760 best_val = ret;
1761 selector = i;
1762 }
1763 }
1764
77af1b26
LW		 1765 /*
1766 * If we can't obtain the old selector there is not enough
1767 * info to call set_voltage_time_sel().
1768 */
1769 if (rdev->desc->ops->set_voltage_time_sel &&
1770 rdev->desc->ops->get_voltage_sel) {
1771 unsigned int old_selector = 0;
1772
1773 ret = rdev->desc->ops->get_voltage_sel(rdev);
1774 if (ret < 0)
1775 return ret;
1776 old_selector = ret;
1777 delay = rdev->desc->ops->set_voltage_time_sel(rdev,
1778 old_selector, selector);
1779 }
1780
e8eef82b
MB		 1781 if (best_val != INT_MAX) {
1782 ret = rdev->desc->ops->set_voltage_sel(rdev, selector);
1783 selector = best_val;
1784 } else {
1785 ret = -EINVAL;
1786 }
75790251
MB		 1787 } else {
1788 ret = -EINVAL;
1789 }
1790
77af1b26
LW		 1791 /* Insert any necessary delays */
1792 if (delay >= 1000) {
1793 mdelay(delay / 1000);
1794 udelay(delay % 1000);
1795 } else if (delay) {
1796 udelay(delay);
1797 }
1798
ded06a52
MB		 1799 if (ret == 0)
1800 _notifier_call_chain(rdev, REGULATOR_EVENT_VOLTAGE_CHANGE,
1801 NULL);
1802
75790251
MB		 1803 trace_regulator_set_voltage_complete(rdev_get_name(rdev), selector);
1804
1805 return ret;
1806}
1807
414c70cb
LG		 1808/**
1809 * regulator_set_voltage - set regulator output voltage
1810 * @regulator: regulator source
1811 * @min_uV: Minimum required voltage in uV
1812 * @max_uV: Maximum acceptable voltage in uV
1813 *
1814 * Sets a voltage regulator to the desired output voltage. This can be set
1815 * during any regulator state. IOW, regulator can be disabled or enabled.
1816 *
1817 * If the regulator is enabled then the voltage will change to the new value
1818 * immediately otherwise if the regulator is disabled the regulator will
1819 * output at the new voltage when enabled.
1820 *
1821 * NOTE: If the regulator is shared between several devices then the lowest
1822 * request voltage that meets the system constraints will be used.
69279fb9 1823 * Regulator system constraints must be set for this regulator before
414c70cb
LG		 1824 * calling this function otherwise this call will fail.
1825 */
1826int regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV)
1827{
1828 struct regulator_dev *rdev = regulator->rdev;
95a3c23a 1829 int ret = 0;
414c70cb
LG		 1830
1831 mutex_lock(&rdev->mutex);
1832
95a3c23a
MB		 1833 /* If we're setting the same range as last time the change
1834 * should be a noop (some cpufreq implementations use the same
1835 * voltage for multiple frequencies, for example).
1836 */
1837 if (regulator->min_uV == min_uV && regulator->max_uV == max_uV)
1838 goto out;
1839
414c70cb 1840 /* sanity check */
e8eef82b
MB		 1841 if (!rdev->desc->ops->set_voltage &&
1842 !rdev->desc->ops->set_voltage_sel) {
414c70cb
LG		 1843 ret = -EINVAL;
1844 goto out;
1845 }
1846
1847 /* constraints check */
1848 ret = regulator_check_voltage(rdev, &min_uV, &max_uV);
1849 if (ret < 0)
1850 goto out;
1851 regulator->min_uV = min_uV;
1852 regulator->max_uV = max_uV;
3a93f2a9 1853
05fda3b1
TP		 1854 ret = regulator_check_consumers(rdev, &min_uV, &max_uV);
1855 if (ret < 0)
1856 goto out;
1857
75790251 1858 ret = _regulator_do_set_voltage(rdev, min_uV, max_uV);
02fa3ec0 1859
414c70cb
LG		 1860out:
1861 mutex_unlock(&rdev->mutex);
1862 return ret;
1863}
1864EXPORT_SYMBOL_GPL(regulator_set_voltage);
1865
88cd222b
LW		 1866/**
1867 * regulator_set_voltage_time - get raise/fall time
1868 * @regulator: regulator source
1869 * @old_uV: starting voltage in microvolts
1870 * @new_uV: target voltage in microvolts
1871 *
1872 * Provided with the starting and ending voltage, this function attempts to
1873 * calculate the time in microseconds required to rise or fall to this new
1874 * voltage.
1875 */
1876int regulator_set_voltage_time(struct regulator *regulator,
1877 int old_uV, int new_uV)
1878{
1879 struct regulator_dev *rdev = regulator->rdev;
1880 struct regulator_ops *ops = rdev->desc->ops;
1881 int old_sel = -1;
1882 int new_sel = -1;
1883 int voltage;
1884 int i;
1885
1886 /* Currently requires operations to do this */
1887 if (!ops->list_voltage || !ops->set_voltage_time_sel
1888 || !rdev->desc->n_voltages)
1889 return -EINVAL;
1890
1891 for (i = 0; i < rdev->desc->n_voltages; i++) {
1892 /* We only look for exact voltage matches here */
1893 voltage = regulator_list_voltage(regulator, i);
1894 if (voltage < 0)
1895 return -EINVAL;
1896 if (voltage == 0)
1897 continue;
1898 if (voltage == old_uV)
1899 old_sel = i;
1900 if (voltage == new_uV)
1901 new_sel = i;
1902 }
1903
1904 if (old_sel < 0 || new_sel < 0)
1905 return -EINVAL;
1906
1907 return ops->set_voltage_time_sel(rdev, old_sel, new_sel);
1908}
1909EXPORT_SYMBOL_GPL(regulator_set_voltage_time);
1910
606a2562
MB		 1911/**
1912 * regulator_sync_voltage - re-apply last regulator output voltage
1913 * @regulator: regulator source
1914 *
1915 * Re-apply the last configured voltage. This is intended to be used
1916 * where some external control source the consumer is cooperating with
1917 * has caused the configured voltage to change.
1918 */
1919int regulator_sync_voltage(struct regulator *regulator)
1920{
1921 struct regulator_dev *rdev = regulator->rdev;
1922 int ret, min_uV, max_uV;
1923
1924 mutex_lock(&rdev->mutex);
1925
1926 if (!rdev->desc->ops->set_voltage &&
1927 !rdev->desc->ops->set_voltage_sel) {
1928 ret = -EINVAL;
1929 goto out;
1930 }
1931
1932 /* This is only going to work if we've had a voltage configured. */
1933 if (!regulator->min_uV && !regulator->max_uV) {
1934 ret = -EINVAL;
1935 goto out;
1936 }
1937
1938 min_uV = regulator->min_uV;
1939 max_uV = regulator->max_uV;
1940
1941 /* This should be a paranoia check... */
1942 ret = regulator_check_voltage(rdev, &min_uV, &max_uV);
1943 if (ret < 0)
1944 goto out;
1945
1946 ret = regulator_check_consumers(rdev, &min_uV, &max_uV);
1947 if (ret < 0)
1948 goto out;
1949
1950 ret = _regulator_do_set_voltage(rdev, min_uV, max_uV);
1951
1952out:
1953 mutex_unlock(&rdev->mutex);
1954 return ret;
1955}
1956EXPORT_SYMBOL_GPL(regulator_sync_voltage);
1957
414c70cb
LG		 1958static int _regulator_get_voltage(struct regulator_dev *rdev)
1959{
bf5892a8 1960 int sel, ret;
476c2d83
MB		 1961
1962 if (rdev->desc->ops->get_voltage_sel) {
1963 sel = rdev->desc->ops->get_voltage_sel(rdev);
1964 if (sel < 0)
1965 return sel;
bf5892a8 1966 ret = rdev->desc->ops->list_voltage(rdev, sel);
cb220d16 1967 } else if (rdev->desc->ops->get_voltage) {
bf5892a8 1968 ret = rdev->desc->ops->get_voltage(rdev);
cb220d16 1969 } else {
414c70cb 1970 return -EINVAL;
cb220d16 1971 }
bf5892a8 1972
cb220d16
AL		 1973 if (ret < 0)
1974 return ret;
bf5892a8 1975 return ret - rdev->constraints->uV_offset;
414c70cb
LG		 1976}
1977
1978/**
1979 * regulator_get_voltage - get regulator output voltage
1980 * @regulator: regulator source
1981 *
1982 * This returns the current regulator voltage in uV.
1983 *
1984 * NOTE: If the regulator is disabled it will return the voltage value. This
1985 * function should not be used to determine regulator state.
1986 */
1987int regulator_get_voltage(struct regulator *regulator)
1988{
1989 int ret;
1990
1991 mutex_lock(&regulator->rdev->mutex);
1992
1993 ret = _regulator_get_voltage(regulator->rdev);
1994
1995 mutex_unlock(&regulator->rdev->mutex);
1996
1997 return ret;
1998}
1999EXPORT_SYMBOL_GPL(regulator_get_voltage);
2000
2001/**
2002 * regulator_set_current_limit - set regulator output current limit
2003 * @regulator: regulator source
2004 * @min_uA: Minimuum supported current in uA
2005 * @max_uA: Maximum supported current in uA
2006 *
2007 * Sets current sink to the desired output current. This can be set during
2008 * any regulator state. IOW, regulator can be disabled or enabled.
2009 *
2010 * If the regulator is enabled then the current will change to the new value
2011 * immediately otherwise if the regulator is disabled the regulator will
2012 * output at the new current when enabled.
2013 *
2014 * NOTE: Regulator system constraints must be set for this regulator before
2015 * calling this function otherwise this call will fail.
2016 */
2017int regulator_set_current_limit(struct regulator *regulator,
2018 int min_uA, int max_uA)
2019{
2020 struct regulator_dev *rdev = regulator->rdev;
2021 int ret;
2022
2023 mutex_lock(&rdev->mutex);
2024
2025 /* sanity check */
2026 if (!rdev->desc->ops->set_current_limit) {
2027 ret = -EINVAL;
2028 goto out;
2029 }
2030
2031 /* constraints check */
2032 ret = regulator_check_current_limit(rdev, &min_uA, &max_uA);
2033 if (ret < 0)
2034 goto out;
2035
2036 ret = rdev->desc->ops->set_current_limit(rdev, min_uA, max_uA);
2037out:
2038 mutex_unlock(&rdev->mutex);
2039 return ret;
2040}
2041EXPORT_SYMBOL_GPL(regulator_set_current_limit);
2042
2043static int _regulator_get_current_limit(struct regulator_dev *rdev)
2044{
2045 int ret;
2046
2047 mutex_lock(&rdev->mutex);
2048
2049 /* sanity check */
2050 if (!rdev->desc->ops->get_current_limit) {
2051 ret = -EINVAL;
2052 goto out;
2053 }
2054
2055 ret = rdev->desc->ops->get_current_limit(rdev);
2056out:
2057 mutex_unlock(&rdev->mutex);
2058 return ret;
2059}
2060
2061/**
2062 * regulator_get_current_limit - get regulator output current
2063 * @regulator: regulator source
2064 *
2065 * This returns the current supplied by the specified current sink in uA.
2066 *
2067 * NOTE: If the regulator is disabled it will return the current value. This
2068 * function should not be used to determine regulator state.
2069 */
2070int regulator_get_current_limit(struct regulator *regulator)
2071{
2072 return _regulator_get_current_limit(regulator->rdev);
2073}
2074EXPORT_SYMBOL_GPL(regulator_get_current_limit);
2075
2076/**
2077 * regulator_set_mode - set regulator operating mode
2078 * @regulator: regulator source
2079 * @mode: operating mode - one of the REGULATOR_MODE constants
2080 *
2081 * Set regulator operating mode to increase regulator efficiency or improve
2082 * regulation performance.
2083 *
2084 * NOTE: Regulator system constraints must be set for this regulator before
2085 * calling this function otherwise this call will fail.
2086 */
2087int regulator_set_mode(struct regulator *regulator, unsigned int mode)
2088{
2089 struct regulator_dev *rdev = regulator->rdev;
2090 int ret;
500b4ac9 2091 int regulator_curr_mode;
414c70cb
LG		 2092
2093 mutex_lock(&rdev->mutex);
2094
2095 /* sanity check */
2096 if (!rdev->desc->ops->set_mode) {
2097 ret = -EINVAL;
2098 goto out;
2099 }
2100
500b4ac9
SI		 2101 /* return if the same mode is requested */
2102 if (rdev->desc->ops->get_mode) {
2103 regulator_curr_mode = rdev->desc->ops->get_mode(rdev);
2104 if (regulator_curr_mode == mode) {
2105 ret = 0;
2106 goto out;
2107 }
2108 }
2109
414c70cb 2110 /* constraints check */
22c51b47 2111 ret = regulator_mode_constrain(rdev, &mode);
414c70cb
LG		 2112 if (ret < 0)
2113 goto out;
2114
2115 ret = rdev->desc->ops->set_mode(rdev, mode);
2116out:
2117 mutex_unlock(&rdev->mutex);
2118 return ret;
2119}
2120EXPORT_SYMBOL_GPL(regulator_set_mode);
2121
2122static unsigned int _regulator_get_mode(struct regulator_dev *rdev)
2123{
2124 int ret;
2125
2126 mutex_lock(&rdev->mutex);
2127
2128 /* sanity check */
2129 if (!rdev->desc->ops->get_mode) {
2130 ret = -EINVAL;
2131 goto out;
2132 }
2133
2134 ret = rdev->desc->ops->get_mode(rdev);
2135out:
2136 mutex_unlock(&rdev->mutex);
2137 return ret;
2138}
2139
2140/**
2141 * regulator_get_mode - get regulator operating mode
2142 * @regulator: regulator source
2143 *
2144 * Get the current regulator operating mode.
2145 */
2146unsigned int regulator_get_mode(struct regulator *regulator)
2147{
2148 return _regulator_get_mode(regulator->rdev);
2149}
2150EXPORT_SYMBOL_GPL(regulator_get_mode);
2151
2152/**
2153 * regulator_set_optimum_mode - set regulator optimum operating mode
2154 * @regulator: regulator source
2155 * @uA_load: load current
2156 *
2157 * Notifies the regulator core of a new device load. This is then used by
2158 * DRMS (if enabled by constraints) to set the most efficient regulator
2159 * operating mode for the new regulator loading.
2160 *
2161 * Consumer devices notify their supply regulator of the maximum power
2162 * they will require (can be taken from device datasheet in the power
2163 * consumption tables) when they change operational status and hence power
2164 * state. Examples of operational state changes that can affect power
2165 * consumption are :-
2166 *
2167 * o Device is opened / closed.
2168 * o Device I/O is about to begin or has just finished.
2169 * o Device is idling in between work.
2170 *
2171 * This information is also exported via sysfs to userspace.
2172 *
2173 * DRMS will sum the total requested load on the regulator and change
2174 * to the most efficient operating mode if platform constraints allow.
2175 *
2176 * Returns the new regulator mode or error.
2177 */
2178int regulator_set_optimum_mode(struct regulator *regulator, int uA_load)
2179{
2180 struct regulator_dev *rdev = regulator->rdev;
2181 struct regulator *consumer;
2182 int ret, output_uV, input_uV, total_uA_load = 0;
2183 unsigned int mode;
2184
2185 mutex_lock(&rdev->mutex);
2186
a4b41483
MB		 2187 /*
2188 * first check to see if we can set modes at all, otherwise just
2189 * tell the consumer everything is OK.
2190 */
414c70cb
LG		 2191 regulator->uA_load = uA_load;
2192 ret = regulator_check_drms(rdev);
a4b41483
MB		 2193 if (ret < 0) {
2194 ret = 0;
414c70cb 2195 goto out;
a4b41483 2196 }
414c70cb 2197
414c70cb
LG		 2198 if (!rdev->desc->ops->get_optimum_mode)
2199 goto out;
2200
a4b41483
MB		 2201 /*
2202 * we can actually do this so any errors are indicators of
2203 * potential real failure.
2204 */
2205 ret = -EINVAL;
2206
414c70cb 2207 /* get output voltage */
1bf5a1f8 2208 output_uV = _regulator_get_voltage(rdev);
414c70cb 2209 if (output_uV <= 0) {
5da84fd9 2210 rdev_err(rdev, "invalid output voltage found\n");
414c70cb
LG		 2211 goto out;
2212 }
2213
2214 /* get input voltage */
1bf5a1f8
MB		 2215 input_uV = 0;
2216 if (rdev->supply)
3801b86a 2217 input_uV = regulator_get_voltage(rdev->supply);
1bf5a1f8 2218 if (input_uV <= 0)
414c70cb
LG		 2219 input_uV = rdev->constraints->input_uV;
2220 if (input_uV <= 0) {
5da84fd9 2221 rdev_err(rdev, "invalid input voltage found\n");
414c70cb
LG		 2222 goto out;
2223 }
2224
2225 /* calc total requested load for this regulator */
2226 list_for_each_entry(consumer, &rdev->consumer_list, list)
fa2984d4 2227 total_uA_load += consumer->uA_load;
414c70cb
LG		 2228
2229 mode = rdev->desc->ops->get_optimum_mode(rdev,
2230 input_uV, output_uV,
2231 total_uA_load);
2c608234 2232 ret = regulator_mode_constrain(rdev, &mode);
e573520b 2233 if (ret < 0) {
5da84fd9
JP		 2234 rdev_err(rdev, "failed to get optimum mode @ %d uA %d -> %d uV\n",
2235 total_uA_load, input_uV, output_uV);
414c70cb
LG		 2236 goto out;
2237 }
2238
2239 ret = rdev->desc->ops->set_mode(rdev, mode);
e573520b 2240 if (ret < 0) {
5da84fd9 2241 rdev_err(rdev, "failed to set optimum mode %x\n", mode);
414c70cb
LG		 2242 goto out;
2243 }
2244 ret = mode;
2245out:
2246 mutex_unlock(&rdev->mutex);
2247 return ret;
2248}
2249EXPORT_SYMBOL_GPL(regulator_set_optimum_mode);
2250
2251/**
2252 * regulator_register_notifier - register regulator event notifier
2253 * @regulator: regulator source
69279fb9 2254 * @nb: notifier block
414c70cb
LG		 2255 *
2256 * Register notifier block to receive regulator events.
2257 */
2258int regulator_register_notifier(struct regulator *regulator,
2259 struct notifier_block *nb)
2260{
2261 return blocking_notifier_chain_register(&regulator->rdev->notifier,
2262 nb);
2263}
2264EXPORT_SYMBOL_GPL(regulator_register_notifier);
2265
2266/**
2267 * regulator_unregister_notifier - unregister regulator event notifier
2268 * @regulator: regulator source
69279fb9 2269 * @nb: notifier block
414c70cb
LG		 2270 *
2271 * Unregister regulator event notifier block.
2272 */
2273int regulator_unregister_notifier(struct regulator *regulator,
2274 struct notifier_block *nb)
2275{
2276 return blocking_notifier_chain_unregister(&regulator->rdev->notifier,
2277 nb);
2278}
2279EXPORT_SYMBOL_GPL(regulator_unregister_notifier);
2280
b136fb44
JC		 2281/* notify regulator consumers and downstream regulator consumers.
2282 * Note mutex must be held by caller.
2283 */
414c70cb
LG		 2284static void _notifier_call_chain(struct regulator_dev *rdev,
2285 unsigned long event, void *data)
2286{
414c70cb 2287 /* call rdev chain first */
414c70cb 2288 blocking_notifier_call_chain(&rdev->notifier, event, NULL);
414c70cb
LG		 2289}
2290
2291/**
2292 * regulator_bulk_get - get multiple regulator consumers
2293 *
2294 * @dev: Device to supply
2295 * @num_consumers: Number of consumers to register
2296 * @consumers: Configuration of consumers; clients are stored here.
2297 *
2298 * @return 0 on success, an errno on failure.
2299 *
2300 * This helper function allows drivers to get several regulator
2301 * consumers in one operation. If any of the regulators cannot be
2302 * acquired then any regulators that were allocated will be freed
2303 * before returning to the caller.
2304 */
2305int regulator_bulk_get(struct device *dev, int num_consumers,
2306 struct regulator_bulk_data *consumers)
2307{
2308 int i;
2309 int ret;
2310
2311 for (i = 0; i < num_consumers; i++)
2312 consumers[i].consumer = NULL;
2313
2314 for (i = 0; i < num_consumers; i++) {
2315 consumers[i].consumer = regulator_get(dev,
2316 consumers[i].supply);
2317 if (IS_ERR(consumers[i].consumer)) {
414c70cb 2318 ret = PTR_ERR(consumers[i].consumer);
5b307627
MB		 2319 dev_err(dev, "Failed to get supply '%s': %d\n",
2320 consumers[i].supply, ret);
414c70cb
LG		 2321 consumers[i].consumer = NULL;
2322 goto err;
2323 }
2324 }
2325
2326 return 0;
2327
2328err:
2329 for (i = 0; i < num_consumers && consumers[i].consumer; i++)
2330 regulator_put(consumers[i].consumer);
2331
2332 return ret;
2333}
2334EXPORT_SYMBOL_GPL(regulator_bulk_get);
2335
f21e0e81
MB		 2336static void regulator_bulk_enable_async(void *data, async_cookie_t cookie)
2337{
2338 struct regulator_bulk_data *bulk = data;
2339
2340 bulk->ret = regulator_enable(bulk->consumer);
2341}
2342
414c70cb
LG		 2343/**
2344 * regulator_bulk_enable - enable multiple regulator consumers
2345 *
2346 * @num_consumers: Number of consumers
2347 * @consumers: Consumer data; clients are stored here.
2348 * @return 0 on success, an errno on failure
2349 *
2350 * This convenience API allows consumers to enable multiple regulator
2351 * clients in a single API call. If any consumers cannot be enabled
2352 * then any others that were enabled will be disabled again prior to
2353 * return.
2354 */
2355int regulator_bulk_enable(int num_consumers,
2356 struct regulator_bulk_data *consumers)
2357{
f21e0e81 2358 LIST_HEAD(async_domain);
414c70cb 2359 int i;
f21e0e81 2360 int ret = 0;
414c70cb 2361
f21e0e81
MB		 2362 for (i = 0; i < num_consumers; i++)
2363 async_schedule_domain(regulator_bulk_enable_async,
2364 &consumers[i], &async_domain);
2365
2366 async_synchronize_full_domain(&async_domain);
2367
2368 /* If any consumer failed we need to unwind any that succeeded */
414c70cb 2369 for (i = 0; i < num_consumers; i++) {
f21e0e81
MB		 2370 if (consumers[i].ret != 0) {
2371 ret = consumers[i].ret;
414c70cb 2372 goto err;
f21e0e81 2373 }
414c70cb
LG		 2374 }
2375
2376 return 0;
2377
2378err:
f21e0e81
MB		 2379 for (i = 0; i < num_consumers; i++)
2380 if (consumers[i].ret == 0)
2381 regulator_disable(consumers[i].consumer);
2382 else
2383 pr_err("Failed to enable %s: %d\n",
2384 consumers[i].supply, consumers[i].ret);
414c70cb
LG		 2385
2386 return ret;
2387}
2388EXPORT_SYMBOL_GPL(regulator_bulk_enable);
2389
2390/**
2391 * regulator_bulk_disable - disable multiple regulator consumers
2392 *
2393 * @num_consumers: Number of consumers
2394 * @consumers: Consumer data; clients are stored here.
2395 * @return 0 on success, an errno on failure
2396 *
2397 * This convenience API allows consumers to disable multiple regulator
2398 * clients in a single API call. If any consumers cannot be enabled
2399 * then any others that were disabled will be disabled again prior to
2400 * return.
2401 */
2402int regulator_bulk_disable(int num_consumers,
2403 struct regulator_bulk_data *consumers)
2404{
2405 int i;
2406 int ret;
2407
2408 for (i = 0; i < num_consumers; i++) {
2409 ret = regulator_disable(consumers[i].consumer);
2410 if (ret != 0)
2411 goto err;
2412 }
2413
2414 return 0;
2415
2416err:
5da84fd9 2417 pr_err("Failed to disable %s: %d\n", consumers[i].supply, ret);
eb143ac1 2418 for (--i; i >= 0; --i)
414c70cb
LG		 2419 regulator_enable(consumers[i].consumer);
2420
2421 return ret;
2422}
2423EXPORT_SYMBOL_GPL(regulator_bulk_disable);
2424
2425/**
2426 * regulator_bulk_free - free multiple regulator consumers
2427 *
2428 * @num_consumers: Number of consumers
2429 * @consumers: Consumer data; clients are stored here.
2430 *
2431 * This convenience API allows consumers to free multiple regulator
2432 * clients in a single API call.
2433 */
2434void regulator_bulk_free(int num_consumers,
2435 struct regulator_bulk_data *consumers)
2436{
2437 int i;
2438
2439 for (i = 0; i < num_consumers; i++) {
2440 regulator_put(consumers[i].consumer);
2441 consumers[i].consumer = NULL;
2442 }
2443}
2444EXPORT_SYMBOL_GPL(regulator_bulk_free);
2445
2446/**
2447 * regulator_notifier_call_chain - call regulator event notifier
69279fb9 2448 * @rdev: regulator source
414c70cb 2449 * @event: notifier block
69279fb9 2450 * @data: callback-specific data.
414c70cb
LG		 2451 *
2452 * Called by regulator drivers to notify clients a regulator event has
2453 * occurred. We also notify regulator clients downstream.
b136fb44 2454 * Note lock must be held by caller.
414c70cb
LG		 2455 */
2456int regulator_notifier_call_chain(struct regulator_dev *rdev,
2457 unsigned long event, void *data)
2458{
2459 _notifier_call_chain(rdev, event, data);
2460 return NOTIFY_DONE;
2461
2462}
2463EXPORT_SYMBOL_GPL(regulator_notifier_call_chain);
2464
be721979
MB		 2465/**
2466 * regulator_mode_to_status - convert a regulator mode into a status
2467 *
2468 * @mode: Mode to convert
2469 *
2470 * Convert a regulator mode into a status.
2471 */
2472int regulator_mode_to_status(unsigned int mode)
2473{
2474 switch (mode) {
2475 case REGULATOR_MODE_FAST:
2476 return REGULATOR_STATUS_FAST;
2477 case REGULATOR_MODE_NORMAL:
2478 return REGULATOR_STATUS_NORMAL;
2479 case REGULATOR_MODE_IDLE:
2480 return REGULATOR_STATUS_IDLE;
2481 case REGULATOR_STATUS_STANDBY:
2482 return REGULATOR_STATUS_STANDBY;
2483 default:
2484 return 0;
2485 }
2486}
2487EXPORT_SYMBOL_GPL(regulator_mode_to_status);
2488
7ad68e2f
DB		 2489/*
2490 * To avoid cluttering sysfs (and memory) with useless state, only
2491 * create attributes that can be meaningfully displayed.
2492 */
2493static int add_regulator_attributes(struct regulator_dev *rdev)
2494{
2495 struct device *dev = &rdev->dev;
2496 struct regulator_ops *ops = rdev->desc->ops;
2497 int status = 0;
2498
2499 /* some attributes need specific methods to be displayed */
476c2d83 2500 if (ops->get_voltage || ops->get_voltage_sel) {
7ad68e2f
DB		 2501 status = device_create_file(dev, &dev_attr_microvolts);
2502 if (status < 0)
2503 return status;
2504 }
2505 if (ops->get_current_limit) {
2506 status = device_create_file(dev, &dev_attr_microamps);
2507 if (status < 0)
2508 return status;
2509 }
2510 if (ops->get_mode) {
2511 status = device_create_file(dev, &dev_attr_opmode);
2512 if (status < 0)
2513 return status;
2514 }
2515 if (ops->is_enabled) {
2516 status = device_create_file(dev, &dev_attr_state);
2517 if (status < 0)
2518 return status;
2519 }
853116a1
DB		 2520 if (ops->get_status) {
2521 status = device_create_file(dev, &dev_attr_status);
2522 if (status < 0)
2523 return status;
2524 }
7ad68e2f
DB		 2525
2526 /* some attributes are type-specific */
2527 if (rdev->desc->type == REGULATOR_CURRENT) {
2528 status = device_create_file(dev, &dev_attr_requested_microamps);
2529 if (status < 0)
2530 return status;
2531 }
2532
2533 /* all the other attributes exist to support constraints;
2534 * don't show them if there are no constraints, or if the
2535 * relevant supporting methods are missing.
2536 */
2537 if (!rdev->constraints)
2538 return status;
2539
2540 /* constraints need specific supporting methods */
e8eef82b 2541 if (ops->set_voltage || ops->set_voltage_sel) {
7ad68e2f
DB		 2542 status = device_create_file(dev, &dev_attr_min_microvolts);
2543 if (status < 0)
2544 return status;
2545 status = device_create_file(dev, &dev_attr_max_microvolts);
2546 if (status < 0)
2547 return status;
2548 }
2549 if (ops->set_current_limit) {
2550 status = device_create_file(dev, &dev_attr_min_microamps);
2551 if (status < 0)
2552 return status;
2553 status = device_create_file(dev, &dev_attr_max_microamps);
2554 if (status < 0)
2555 return status;
2556 }
2557
2558 /* suspend mode constraints need multiple supporting methods */
2559 if (!(ops->set_suspend_enable && ops->set_suspend_disable))
2560 return status;
2561
2562 status = device_create_file(dev, &dev_attr_suspend_standby_state);
2563 if (status < 0)
2564 return status;
2565 status = device_create_file(dev, &dev_attr_suspend_mem_state);
2566 if (status < 0)
2567 return status;
2568 status = device_create_file(dev, &dev_attr_suspend_disk_state);
2569 if (status < 0)
2570 return status;
2571
2572 if (ops->set_suspend_voltage) {
2573 status = device_create_file(dev,
2574 &dev_attr_suspend_standby_microvolts);
2575 if (status < 0)
2576 return status;
2577 status = device_create_file(dev,
2578 &dev_attr_suspend_mem_microvolts);
2579 if (status < 0)
2580 return status;
2581 status = device_create_file(dev,
2582 &dev_attr_suspend_disk_microvolts);
2583 if (status < 0)
2584 return status;
2585 }
2586
2587 if (ops->set_suspend_mode) {
2588 status = device_create_file(dev,
2589 &dev_attr_suspend_standby_mode);
2590 if (status < 0)
2591 return status;
2592 status = device_create_file(dev,
2593 &dev_attr_suspend_mem_mode);
2594 if (status < 0)
2595 return status;
2596 status = device_create_file(dev,
2597 &dev_attr_suspend_disk_mode);
2598 if (status < 0)
2599 return status;
2600 }
2601
2602 return status;
2603}
2604
1130e5b3
MB		 2605static void rdev_init_debugfs(struct regulator_dev *rdev)
2606{
2607#ifdef CONFIG_DEBUG_FS
2608 rdev->debugfs = debugfs_create_dir(rdev_get_name(rdev), debugfs_root);
2609 if (IS_ERR(rdev->debugfs) || !rdev->debugfs) {
2610 rdev_warn(rdev, "Failed to create debugfs directory\n");
2611 rdev->debugfs = NULL;
2612 return;
2613 }
2614
2615 debugfs_create_u32("use_count", 0444, rdev->debugfs,
2616 &rdev->use_count);
2617 debugfs_create_u32("open_count", 0444, rdev->debugfs,
2618 &rdev->open_count);
2619#endif
2620}
2621
414c70cb
LG		 2622/**
2623 * regulator_register - register regulator
69279fb9
MB		 2624 * @regulator_desc: regulator to register
2625 * @dev: struct device for the regulator
0527100f 2626 * @init_data: platform provided init data, passed through by driver
69279fb9 2627 * @driver_data: private regulator data
414c70cb
LG		 2628 *
2629 * Called by regulator drivers to register a regulator.
2630 * Returns 0 on success.
2631 */
2632struct regulator_dev *regulator_register(struct regulator_desc *regulator_desc,
f8c12fe3 2633 struct device *dev, const struct regulator_init_data *init_data,
0527100f 2634 void *driver_data)
414c70cb
LG		 2635{
2636 static atomic_t regulator_no = ATOMIC_INIT(0);
2637 struct regulator_dev *rdev;
a5766f11 2638 int ret, i;
414c70cb
LG		 2639
2640 if (regulator_desc == NULL)
2641 return ERR_PTR(-EINVAL);
2642
2643 if (regulator_desc->name == NULL || regulator_desc->ops == NULL)
2644 return ERR_PTR(-EINVAL);
2645
cd78dfc6
DL		 2646 if (regulator_desc->type != REGULATOR_VOLTAGE &&
2647 regulator_desc->type != REGULATOR_CURRENT)
414c70cb
LG		 2648 return ERR_PTR(-EINVAL);
2649
46fabe1e
MB		 2650 if (!init_data)
2651 return ERR_PTR(-EINVAL);
2652
476c2d83
MB		 2653 /* Only one of each should be implemented */
2654 WARN_ON(regulator_desc->ops->get_voltage &&
2655 regulator_desc->ops->get_voltage_sel);
e8eef82b
MB		 2656 WARN_ON(regulator_desc->ops->set_voltage &&
2657 regulator_desc->ops->set_voltage_sel);
476c2d83
MB		 2658
2659 /* If we're using selectors we must implement list_voltage. */
2660 if (regulator_desc->ops->get_voltage_sel &&
2661 !regulator_desc->ops->list_voltage) {
2662 return ERR_PTR(-EINVAL);
2663 }
e8eef82b
MB		 2664 if (regulator_desc->ops->set_voltage_sel &&
2665 !regulator_desc->ops->list_voltage) {
2666 return ERR_PTR(-EINVAL);
2667 }
476c2d83 2668
414c70cb
LG		 2669 rdev = kzalloc(sizeof(struct regulator_dev), GFP_KERNEL);
2670 if (rdev == NULL)
2671 return ERR_PTR(-ENOMEM);
2672
2673 mutex_lock(&regulator_list_mutex);
2674
2675 mutex_init(&rdev->mutex);
a5766f11 2676 rdev->reg_data = driver_data;
414c70cb
LG		 2677 rdev->owner = regulator_desc->owner;
2678 rdev->desc = regulator_desc;
2679 INIT_LIST_HEAD(&rdev->consumer_list);
414c70cb 2680 INIT_LIST_HEAD(&rdev->list);
414c70cb 2681 BLOCKING_INIT_NOTIFIER_HEAD(&rdev->notifier);
da07ecd9 2682 INIT_DELAYED_WORK(&rdev->disable_work, regulator_disable_work);
414c70cb 2683
a5766f11
LG		 2684 /* preform any regulator specific init */
2685 if (init_data->regulator_init) {
2686 ret = init_data->regulator_init(rdev->reg_data);
4fca9545
DB		 2687 if (ret < 0)
2688 goto clean;
a5766f11
LG		 2689 }
2690
a5766f11 2691 /* register with sysfs */
414c70cb 2692 rdev->dev.class = &regulator_class;
a5766f11 2693 rdev->dev.parent = dev;
812460a9
KS		 2694 dev_set_name(&rdev->dev, "regulator.%d",
2695 atomic_inc_return(&regulator_no) - 1);
a5766f11 2696 ret = device_register(&rdev->dev);
ad7725cb
VK		 2697 if (ret != 0) {
2698 put_device(&rdev->dev);
4fca9545 2699 goto clean;
ad7725cb 2700 }
a5766f11
LG		 2701
2702 dev_set_drvdata(&rdev->dev, rdev);
2703
74f544c1
MR		 2704 /* set regulator constraints */
2705 ret = set_machine_constraints(rdev, &init_data->constraints);
2706 if (ret < 0)
2707 goto scrub;
2708
7ad68e2f
DB		 2709 /* add attributes supported by this regulator */
2710 ret = add_regulator_attributes(rdev);
2711 if (ret < 0)
2712 goto scrub;
2713
0178f3e2
MB		 2714 if (init_data->supply_regulator) {
2715 struct regulator_dev *r;
2716 int found = 0;
2717
2718 list_for_each_entry(r, &regulator_list, list) {
2719 if (strcmp(rdev_get_name(r),
2720 init_data->supply_regulator) == 0) {
2721 found = 1;
2722 break;
2723 }
2724 }
2725
2726 if (!found) {
2727 dev_err(dev, "Failed to find supply %s\n",
2728 init_data->supply_regulator);
7727da22 2729 ret = -ENODEV;
0178f3e2
MB		 2730 goto scrub;
2731 }
2732
2733 ret = set_supply(rdev, r);
2734 if (ret < 0)
2735 goto scrub;
2736 }
2737
a5766f11
LG		 2738 /* add consumers devices */
2739 for (i = 0; i < init_data->num_consumer_supplies; i++) {
2740 ret = set_consumer_device_supply(rdev,
2741 init_data->consumer_supplies[i].dev,
40f9244f 2742 init_data->consumer_supplies[i].dev_name,
a5766f11 2743 init_data->consumer_supplies[i].supply);
23c2f041
MB		 2744 if (ret < 0) {
2745 dev_err(dev, "Failed to set supply %s\n",
2746 init_data->consumer_supplies[i].supply);
d4033b54 2747 goto unset_supplies;
23c2f041 2748 }
414c70cb 2749 }
a5766f11
LG		 2750
2751 list_add(&rdev->list, &regulator_list);
1130e5b3
MB		 2752
2753 rdev_init_debugfs(rdev);
a5766f11 2754out:
414c70cb
LG		 2755 mutex_unlock(&regulator_list_mutex);
2756 return rdev;
4fca9545 2757
d4033b54
JN		 2758unset_supplies:
2759 unset_regulator_supplies(rdev);
2760
4fca9545 2761scrub:
1a6958e7 2762 kfree(rdev->constraints);
4fca9545 2763 device_unregister(&rdev->dev);
53032daf
PW		 2764 /* device core frees rdev */
2765 rdev = ERR_PTR(ret);
2766 goto out;
2767
4fca9545
DB		 2768clean:
2769 kfree(rdev);
2770 rdev = ERR_PTR(ret);
2771 goto out;
414c70cb
LG		 2772}
2773EXPORT_SYMBOL_GPL(regulator_register);
2774
2775/**
2776 * regulator_unregister - unregister regulator
69279fb9 2777 * @rdev: regulator to unregister
414c70cb
LG		 2778 *
2779 * Called by regulator drivers to unregister a regulator.
2780 */
2781void regulator_unregister(struct regulator_dev *rdev)
2782{
2783 if (rdev == NULL)
2784 return;
2785
2786 mutex_lock(&regulator_list_mutex);
1130e5b3
MB		 2787#ifdef CONFIG_DEBUG_FS
2788 debugfs_remove_recursive(rdev->debugfs);
2789#endif
da07ecd9 2790 flush_work_sync(&rdev->disable_work.work);
6bf87d17 2791 WARN_ON(rdev->open_count);
0f1d747b 2792 unset_regulator_supplies(rdev);
414c70cb
LG		 2793 list_del(&rdev->list);
2794 if (rdev->supply)
3801b86a 2795 regulator_put(rdev->supply);
414c70cb 2796 device_unregister(&rdev->dev);
f8c12fe3 2797 kfree(rdev->constraints);
414c70cb
LG		 2798 mutex_unlock(&regulator_list_mutex);
2799}
2800EXPORT_SYMBOL_GPL(regulator_unregister);
2801
414c70cb 2802/**
cf7bbcdf 2803 * regulator_suspend_prepare - prepare regulators for system wide suspend
414c70cb
LG		 2804 * @state: system suspend state
2805 *
2806 * Configure each regulator with it's suspend operating parameters for state.
2807 * This will usually be called by machine suspend code prior to supending.
2808 */
2809int regulator_suspend_prepare(suspend_state_t state)
2810{
2811 struct regulator_dev *rdev;
2812 int ret = 0;
2813
2814 /* ON is handled by regulator active state */
2815 if (state == PM_SUSPEND_ON)
2816 return -EINVAL;
2817
2818 mutex_lock(&regulator_list_mutex);
2819 list_for_each_entry(rdev, &regulator_list, list) {
2820
2821 mutex_lock(&rdev->mutex);
2822 ret = suspend_prepare(rdev, state);
2823 mutex_unlock(&rdev->mutex);
2824
2825 if (ret < 0) {
5da84fd9 2826 rdev_err(rdev, "failed to prepare\n");
414c70cb
LG		 2827 goto out;
2828 }
2829 }
2830out:
2831 mutex_unlock(&regulator_list_mutex);
2832 return ret;
2833}
2834EXPORT_SYMBOL_GPL(regulator_suspend_prepare);
2835
7a32b589
MH		 2836/**
2837 * regulator_suspend_finish - resume regulators from system wide suspend
2838 *
2839 * Turn on regulators that might be turned off by regulator_suspend_prepare
2840 * and that should be turned on according to the regulators properties.
2841 */
2842int regulator_suspend_finish(void)
2843{
2844 struct regulator_dev *rdev;
2845 int ret = 0, error;
2846
2847 mutex_lock(&regulator_list_mutex);
2848 list_for_each_entry(rdev, &regulator_list, list) {
2849 struct regulator_ops *ops = rdev->desc->ops;
2850
2851 mutex_lock(&rdev->mutex);
2852 if ((rdev->use_count > 0 || rdev->constraints->always_on) &&
2853 ops->enable) {
2854 error = ops->enable(rdev);
2855 if (error)
2856 ret = error;
2857 } else {
2858 if (!has_full_constraints)
2859 goto unlock;
2860 if (!ops->disable)
2861 goto unlock;
2862 if (ops->is_enabled && !ops->is_enabled(rdev))
2863 goto unlock;
2864
2865 error = ops->disable(rdev);
2866 if (error)
2867 ret = error;
2868 }
2869unlock:
2870 mutex_unlock(&rdev->mutex);
2871 }
2872 mutex_unlock(&regulator_list_mutex);
2873 return ret;
2874}
2875EXPORT_SYMBOL_GPL(regulator_suspend_finish);
2876
ca725561
MB		 2877/**
2878 * regulator_has_full_constraints - the system has fully specified constraints
2879 *
2880 * Calling this function will cause the regulator API to disable all
2881 * regulators which have a zero use count and don't have an always_on
2882 * constraint in a late_initcall.
2883 *
2884 * The intention is that this will become the default behaviour in a
2885 * future kernel release so users are encouraged to use this facility
2886 * now.
2887 */
2888void regulator_has_full_constraints(void)
2889{
2890 has_full_constraints = 1;
2891}
2892EXPORT_SYMBOL_GPL(regulator_has_full_constraints);
2893
688fe99a
MB		 2894/**
2895 * regulator_use_dummy_regulator - Provide a dummy regulator when none is found
2896 *
2897 * Calling this function will cause the regulator API to provide a
2898 * dummy regulator to consumers if no physical regulator is found,
2899 * allowing most consumers to proceed as though a regulator were
2900 * configured. This allows systems such as those with software
2901 * controllable regulators for the CPU core only to be brought up more
2902 * readily.
2903 */
2904void regulator_use_dummy_regulator(void)
2905{
2906 board_wants_dummy_regulator = true;
2907}
2908EXPORT_SYMBOL_GPL(regulator_use_dummy_regulator);
2909
414c70cb
LG		 2910/**
2911 * rdev_get_drvdata - get rdev regulator driver data
69279fb9 2912 * @rdev: regulator
414c70cb
LG		 2913 *
2914 * Get rdev regulator driver private data. This call can be used in the
2915 * regulator driver context.
2916 */
2917void *rdev_get_drvdata(struct regulator_dev *rdev)
2918{
2919 return rdev->reg_data;
2920}
2921EXPORT_SYMBOL_GPL(rdev_get_drvdata);
2922
2923/**
2924 * regulator_get_drvdata - get regulator driver data
2925 * @regulator: regulator
2926 *
2927 * Get regulator driver private data. This call can be used in the consumer
2928 * driver context when non API regulator specific functions need to be called.
2929 */
2930void *regulator_get_drvdata(struct regulator *regulator)
2931{
2932 return regulator->rdev->reg_data;
2933}
2934EXPORT_SYMBOL_GPL(regulator_get_drvdata);
2935
2936/**
2937 * regulator_set_drvdata - set regulator driver data
2938 * @regulator: regulator
2939 * @data: data
2940 */
2941void regulator_set_drvdata(struct regulator *regulator, void *data)
2942{
2943 regulator->rdev->reg_data = data;
2944}
2945EXPORT_SYMBOL_GPL(regulator_set_drvdata);
2946
2947/**
2948 * regulator_get_id - get regulator ID
69279fb9 2949 * @rdev: regulator
414c70cb
LG		 2950 */
2951int rdev_get_id(struct regulator_dev *rdev)
2952{
2953 return rdev->desc->id;
2954}
2955EXPORT_SYMBOL_GPL(rdev_get_id);
2956
a5766f11
LG		 2957struct device *rdev_get_dev(struct regulator_dev *rdev)
2958{
2959 return &rdev->dev;
2960}
2961EXPORT_SYMBOL_GPL(rdev_get_dev);
2962
2963void *regulator_get_init_drvdata(struct regulator_init_data *reg_init_data)
2964{
2965 return reg_init_data->driver_data;
2966}
2967EXPORT_SYMBOL_GPL(regulator_get_init_drvdata);
2968
414c70cb
LG		 2969static int __init regulator_init(void)
2970{
34abbd68
MB		 2971 int ret;
2972
34abbd68
MB		 2973 ret = class_register(&regulator_class);
2974
1130e5b3
MB		 2975#ifdef CONFIG_DEBUG_FS
2976 debugfs_root = debugfs_create_dir("regulator", NULL);
2977 if (IS_ERR(debugfs_root) || !debugfs_root) {
2978 pr_warn("regulator: Failed to create debugfs directory\n");
2979 debugfs_root = NULL;
2980 }
2981#endif
2982
34abbd68
MB		 2983 regulator_dummy_init();
2984
2985 return ret;
414c70cb
LG		 2986}
2987
2988/* init early to allow our consumers to complete system booting */
2989core_initcall(regulator_init);
ca725561
MB		 2990
2991static int __init regulator_init_complete(void)
2992{
2993 struct regulator_dev *rdev;
2994 struct regulator_ops *ops;
2995 struct regulation_constraints *c;
2996 int enabled, ret;
ca725561
MB		 2997
2998 mutex_lock(&regulator_list_mutex);
2999
3000 /* If we have a full configuration then disable any regulators
3001 * which are not in use or always_on. This will become the
3002 * default behaviour in the future.
3003 */
3004 list_for_each_entry(rdev, &regulator_list, list) {
3005 ops = rdev->desc->ops;
3006 c = rdev->constraints;
3007
f25e0b4f 3008 if (!ops->disable || (c && c->always_on))
ca725561
MB		 3009 continue;
3010
3011 mutex_lock(&rdev->mutex);
3012
3013 if (rdev->use_count)
3014 goto unlock;
3015
3016 /* If we can't read the status assume it's on. */
3017 if (ops->is_enabled)
3018 enabled = ops->is_enabled(rdev);
3019 else
3020 enabled = 1;
3021
3022 if (!enabled)
3023 goto unlock;
3024
3025 if (has_full_constraints) {
3026 /* We log since this may kill the system if it
3027 * goes wrong. */
5da84fd9 3028 rdev_info(rdev, "disabling\n");
ca725561
MB		 3029 ret = ops->disable(rdev);
3030 if (ret != 0) {
5da84fd9 3031 rdev_err(rdev, "couldn't disable: %d\n", ret);
ca725561
MB		 3032 }
3033 } else {
3034 /* The intention is that in future we will
3035 * assume that full constraints are provided
3036 * so warn even if we aren't going to do
3037 * anything here.
3038 */
5da84fd9 3039 rdev_warn(rdev, "incomplete constraints, leaving on\n");
ca725561
MB		 3040 }
3041
3042unlock:
3043 mutex_unlock(&rdev->mutex);
3044 }
3045
3046 mutex_unlock(&regulator_list_mutex);
3047
3048 return 0;
3049}
3050late_initcall(regulator_init_complete);
Linux kernel - Deliverables
This page took 0.385614 seconds and 5 git commands to generate.