2 * core.c -- Voltage/Current Regulator framework.
4 * Copyright 2007, 2008 Wolfson Microelectronics PLC.
5 * Copyright 2008 SlimLogic Ltd.
7 * Author: Liam Girdwood <lrg@slimlogic.co.uk>
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.
16 #define pr_fmt(fmt) "%s: " fmt, __func__
18 #include <linux/kernel.h>
19 #include <linux/init.h>
20 #include <linux/device.h>
21 #include <linux/slab.h>
22 #include <linux/err.h>
23 #include <linux/mutex.h>
24 #include <linux/suspend.h>
25 #include <linux/delay.h>
26 #include <linux/regulator/consumer.h>
27 #include <linux/regulator/driver.h>
28 #include <linux/regulator/machine.h>
30 #define CREATE_TRACE_POINTS
31 #include <trace/events/regulator.h>
35 #define rdev_err(rdev, fmt, ...) \
36 pr_err("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
37 #define rdev_warn(rdev, fmt, ...) \
38 pr_warn("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
39 #define rdev_info(rdev, fmt, ...) \
40 pr_info("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
41 #define rdev_dbg(rdev, fmt, ...) \
42 pr_debug("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
44 static DEFINE_MUTEX(regulator_list_mutex
);
45 static LIST_HEAD(regulator_list
);
46 static LIST_HEAD(regulator_map_list
);
47 static int has_full_constraints
;
48 static bool board_wants_dummy_regulator
;
51 * struct regulator_map
53 * Used to provide symbolic supply names to devices.
55 struct regulator_map
{
56 struct list_head list
;
57 const char *dev_name
; /* The dev_name() for the consumer */
59 struct regulator_dev
*regulator
;
65 * One for each consumer device.
69 struct list_head list
;
74 struct device_attribute dev_attr
;
75 struct regulator_dev
*rdev
;
78 static int _regulator_is_enabled(struct regulator_dev
*rdev
);
79 static int _regulator_disable(struct regulator_dev
*rdev
,
80 struct regulator_dev
**supply_rdev_ptr
);
81 static int _regulator_get_voltage(struct regulator_dev
*rdev
);
82 static int _regulator_get_current_limit(struct regulator_dev
*rdev
);
83 static unsigned int _regulator_get_mode(struct regulator_dev
*rdev
);
84 static void _notifier_call_chain(struct regulator_dev
*rdev
,
85 unsigned long event
, void *data
);
87 static const char *rdev_get_name(struct regulator_dev
*rdev
)
89 if (rdev
->constraints
&& rdev
->constraints
->name
)
90 return rdev
->constraints
->name
;
91 else if (rdev
->desc
->name
)
92 return rdev
->desc
->name
;
97 /* gets the regulator for a given consumer device */
98 static struct regulator
*get_device_regulator(struct device
*dev
)
100 struct regulator
*regulator
= NULL
;
101 struct regulator_dev
*rdev
;
103 mutex_lock(®ulator_list_mutex
);
104 list_for_each_entry(rdev
, ®ulator_list
, list
) {
105 mutex_lock(&rdev
->mutex
);
106 list_for_each_entry(regulator
, &rdev
->consumer_list
, list
) {
107 if (regulator
->dev
== dev
) {
108 mutex_unlock(&rdev
->mutex
);
109 mutex_unlock(®ulator_list_mutex
);
113 mutex_unlock(&rdev
->mutex
);
115 mutex_unlock(®ulator_list_mutex
);
119 /* Platform voltage constraint check */
120 static int regulator_check_voltage(struct regulator_dev
*rdev
,
121 int *min_uV
, int *max_uV
)
123 BUG_ON(*min_uV
> *max_uV
);
125 if (!rdev
->constraints
) {
126 rdev_err(rdev
, "no constraints\n");
129 if (!(rdev
->constraints
->valid_ops_mask
& REGULATOR_CHANGE_VOLTAGE
)) {
130 rdev_err(rdev
, "operation not allowed\n");
134 if (*max_uV
> rdev
->constraints
->max_uV
)
135 *max_uV
= rdev
->constraints
->max_uV
;
136 if (*min_uV
< rdev
->constraints
->min_uV
)
137 *min_uV
= rdev
->constraints
->min_uV
;
139 if (*min_uV
> *max_uV
)
145 /* Make sure we select a voltage that suits the needs of all
146 * regulator consumers
148 static int regulator_check_consumers(struct regulator_dev
*rdev
,
149 int *min_uV
, int *max_uV
)
151 struct regulator
*regulator
;
153 list_for_each_entry(regulator
, &rdev
->consumer_list
, list
) {
154 if (*max_uV
> regulator
->max_uV
)
155 *max_uV
= regulator
->max_uV
;
156 if (*min_uV
< regulator
->min_uV
)
157 *min_uV
= regulator
->min_uV
;
160 if (*min_uV
> *max_uV
)
166 /* current constraint check */
167 static int regulator_check_current_limit(struct regulator_dev
*rdev
,
168 int *min_uA
, int *max_uA
)
170 BUG_ON(*min_uA
> *max_uA
);
172 if (!rdev
->constraints
) {
173 rdev_err(rdev
, "no constraints\n");
176 if (!(rdev
->constraints
->valid_ops_mask
& REGULATOR_CHANGE_CURRENT
)) {
177 rdev_err(rdev
, "operation not allowed\n");
181 if (*max_uA
> rdev
->constraints
->max_uA
)
182 *max_uA
= rdev
->constraints
->max_uA
;
183 if (*min_uA
< rdev
->constraints
->min_uA
)
184 *min_uA
= rdev
->constraints
->min_uA
;
186 if (*min_uA
> *max_uA
)
192 /* operating mode constraint check */
193 static int regulator_check_mode(struct regulator_dev
*rdev
, int mode
)
196 case REGULATOR_MODE_FAST
:
197 case REGULATOR_MODE_NORMAL
:
198 case REGULATOR_MODE_IDLE
:
199 case REGULATOR_MODE_STANDBY
:
205 if (!rdev
->constraints
) {
206 rdev_err(rdev
, "no constraints\n");
209 if (!(rdev
->constraints
->valid_ops_mask
& REGULATOR_CHANGE_MODE
)) {
210 rdev_err(rdev
, "operation not allowed\n");
213 if (!(rdev
->constraints
->valid_modes_mask
& mode
)) {
214 rdev_err(rdev
, "invalid mode %x\n", mode
);
220 /* dynamic regulator mode switching constraint check */
221 static int regulator_check_drms(struct regulator_dev
*rdev
)
223 if (!rdev
->constraints
) {
224 rdev_err(rdev
, "no constraints\n");
227 if (!(rdev
->constraints
->valid_ops_mask
& REGULATOR_CHANGE_DRMS
)) {
228 rdev_err(rdev
, "operation not allowed\n");
234 static ssize_t
device_requested_uA_show(struct device
*dev
,
235 struct device_attribute
*attr
, char *buf
)
237 struct regulator
*regulator
;
239 regulator
= get_device_regulator(dev
);
240 if (regulator
== NULL
)
243 return sprintf(buf
, "%d\n", regulator
->uA_load
);
246 static ssize_t
regulator_uV_show(struct device
*dev
,
247 struct device_attribute
*attr
, char *buf
)
249 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
252 mutex_lock(&rdev
->mutex
);
253 ret
= sprintf(buf
, "%d\n", _regulator_get_voltage(rdev
));
254 mutex_unlock(&rdev
->mutex
);
258 static DEVICE_ATTR(microvolts
, 0444, regulator_uV_show
, NULL
);
260 static ssize_t
regulator_uA_show(struct device
*dev
,
261 struct device_attribute
*attr
, char *buf
)
263 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
265 return sprintf(buf
, "%d\n", _regulator_get_current_limit(rdev
));
267 static DEVICE_ATTR(microamps
, 0444, regulator_uA_show
, NULL
);
269 static ssize_t
regulator_name_show(struct device
*dev
,
270 struct device_attribute
*attr
, char *buf
)
272 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
274 return sprintf(buf
, "%s\n", rdev_get_name(rdev
));
277 static ssize_t
regulator_print_opmode(char *buf
, int mode
)
280 case REGULATOR_MODE_FAST
:
281 return sprintf(buf
, "fast\n");
282 case REGULATOR_MODE_NORMAL
:
283 return sprintf(buf
, "normal\n");
284 case REGULATOR_MODE_IDLE
:
285 return sprintf(buf
, "idle\n");
286 case REGULATOR_MODE_STANDBY
:
287 return sprintf(buf
, "standby\n");
289 return sprintf(buf
, "unknown\n");
292 static ssize_t
regulator_opmode_show(struct device
*dev
,
293 struct device_attribute
*attr
, char *buf
)
295 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
297 return regulator_print_opmode(buf
, _regulator_get_mode(rdev
));
299 static DEVICE_ATTR(opmode
, 0444, regulator_opmode_show
, NULL
);
301 static ssize_t
regulator_print_state(char *buf
, int state
)
304 return sprintf(buf
, "enabled\n");
306 return sprintf(buf
, "disabled\n");
308 return sprintf(buf
, "unknown\n");
311 static ssize_t
regulator_state_show(struct device
*dev
,
312 struct device_attribute
*attr
, char *buf
)
314 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
317 mutex_lock(&rdev
->mutex
);
318 ret
= regulator_print_state(buf
, _regulator_is_enabled(rdev
));
319 mutex_unlock(&rdev
->mutex
);
323 static DEVICE_ATTR(state
, 0444, regulator_state_show
, NULL
);
325 static ssize_t
regulator_status_show(struct device
*dev
,
326 struct device_attribute
*attr
, char *buf
)
328 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
332 status
= rdev
->desc
->ops
->get_status(rdev
);
337 case REGULATOR_STATUS_OFF
:
340 case REGULATOR_STATUS_ON
:
343 case REGULATOR_STATUS_ERROR
:
346 case REGULATOR_STATUS_FAST
:
349 case REGULATOR_STATUS_NORMAL
:
352 case REGULATOR_STATUS_IDLE
:
355 case REGULATOR_STATUS_STANDBY
:
362 return sprintf(buf
, "%s\n", label
);
364 static DEVICE_ATTR(status
, 0444, regulator_status_show
, NULL
);
366 static ssize_t
regulator_min_uA_show(struct device
*dev
,
367 struct device_attribute
*attr
, char *buf
)
369 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
371 if (!rdev
->constraints
)
372 return sprintf(buf
, "constraint not defined\n");
374 return sprintf(buf
, "%d\n", rdev
->constraints
->min_uA
);
376 static DEVICE_ATTR(min_microamps
, 0444, regulator_min_uA_show
, NULL
);
378 static ssize_t
regulator_max_uA_show(struct device
*dev
,
379 struct device_attribute
*attr
, char *buf
)
381 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
383 if (!rdev
->constraints
)
384 return sprintf(buf
, "constraint not defined\n");
386 return sprintf(buf
, "%d\n", rdev
->constraints
->max_uA
);
388 static DEVICE_ATTR(max_microamps
, 0444, regulator_max_uA_show
, NULL
);
390 static ssize_t
regulator_min_uV_show(struct device
*dev
,
391 struct device_attribute
*attr
, char *buf
)
393 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
395 if (!rdev
->constraints
)
396 return sprintf(buf
, "constraint not defined\n");
398 return sprintf(buf
, "%d\n", rdev
->constraints
->min_uV
);
400 static DEVICE_ATTR(min_microvolts
, 0444, regulator_min_uV_show
, NULL
);
402 static ssize_t
regulator_max_uV_show(struct device
*dev
,
403 struct device_attribute
*attr
, char *buf
)
405 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
407 if (!rdev
->constraints
)
408 return sprintf(buf
, "constraint not defined\n");
410 return sprintf(buf
, "%d\n", rdev
->constraints
->max_uV
);
412 static DEVICE_ATTR(max_microvolts
, 0444, regulator_max_uV_show
, NULL
);
414 static ssize_t
regulator_total_uA_show(struct device
*dev
,
415 struct device_attribute
*attr
, char *buf
)
417 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
418 struct regulator
*regulator
;
421 mutex_lock(&rdev
->mutex
);
422 list_for_each_entry(regulator
, &rdev
->consumer_list
, list
)
423 uA
+= regulator
->uA_load
;
424 mutex_unlock(&rdev
->mutex
);
425 return sprintf(buf
, "%d\n", uA
);
427 static DEVICE_ATTR(requested_microamps
, 0444, regulator_total_uA_show
, NULL
);
429 static ssize_t
regulator_num_users_show(struct device
*dev
,
430 struct device_attribute
*attr
, char *buf
)
432 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
433 return sprintf(buf
, "%d\n", rdev
->use_count
);
436 static ssize_t
regulator_type_show(struct device
*dev
,
437 struct device_attribute
*attr
, char *buf
)
439 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
441 switch (rdev
->desc
->type
) {
442 case REGULATOR_VOLTAGE
:
443 return sprintf(buf
, "voltage\n");
444 case REGULATOR_CURRENT
:
445 return sprintf(buf
, "current\n");
447 return sprintf(buf
, "unknown\n");
450 static ssize_t
regulator_suspend_mem_uV_show(struct device
*dev
,
451 struct device_attribute
*attr
, char *buf
)
453 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
455 return sprintf(buf
, "%d\n", rdev
->constraints
->state_mem
.uV
);
457 static DEVICE_ATTR(suspend_mem_microvolts
, 0444,
458 regulator_suspend_mem_uV_show
, NULL
);
460 static ssize_t
regulator_suspend_disk_uV_show(struct device
*dev
,
461 struct device_attribute
*attr
, char *buf
)
463 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
465 return sprintf(buf
, "%d\n", rdev
->constraints
->state_disk
.uV
);
467 static DEVICE_ATTR(suspend_disk_microvolts
, 0444,
468 regulator_suspend_disk_uV_show
, NULL
);
470 static ssize_t
regulator_suspend_standby_uV_show(struct device
*dev
,
471 struct device_attribute
*attr
, char *buf
)
473 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
475 return sprintf(buf
, "%d\n", rdev
->constraints
->state_standby
.uV
);
477 static DEVICE_ATTR(suspend_standby_microvolts
, 0444,
478 regulator_suspend_standby_uV_show
, NULL
);
480 static ssize_t
regulator_suspend_mem_mode_show(struct device
*dev
,
481 struct device_attribute
*attr
, char *buf
)
483 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
485 return regulator_print_opmode(buf
,
486 rdev
->constraints
->state_mem
.mode
);
488 static DEVICE_ATTR(suspend_mem_mode
, 0444,
489 regulator_suspend_mem_mode_show
, NULL
);
491 static ssize_t
regulator_suspend_disk_mode_show(struct device
*dev
,
492 struct device_attribute
*attr
, char *buf
)
494 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
496 return regulator_print_opmode(buf
,
497 rdev
->constraints
->state_disk
.mode
);
499 static DEVICE_ATTR(suspend_disk_mode
, 0444,
500 regulator_suspend_disk_mode_show
, NULL
);
502 static ssize_t
regulator_suspend_standby_mode_show(struct device
*dev
,
503 struct device_attribute
*attr
, char *buf
)
505 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
507 return regulator_print_opmode(buf
,
508 rdev
->constraints
->state_standby
.mode
);
510 static DEVICE_ATTR(suspend_standby_mode
, 0444,
511 regulator_suspend_standby_mode_show
, NULL
);
513 static ssize_t
regulator_suspend_mem_state_show(struct device
*dev
,
514 struct device_attribute
*attr
, char *buf
)
516 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
518 return regulator_print_state(buf
,
519 rdev
->constraints
->state_mem
.enabled
);
521 static DEVICE_ATTR(suspend_mem_state
, 0444,
522 regulator_suspend_mem_state_show
, NULL
);
524 static ssize_t
regulator_suspend_disk_state_show(struct device
*dev
,
525 struct device_attribute
*attr
, char *buf
)
527 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
529 return regulator_print_state(buf
,
530 rdev
->constraints
->state_disk
.enabled
);
532 static DEVICE_ATTR(suspend_disk_state
, 0444,
533 regulator_suspend_disk_state_show
, NULL
);
535 static ssize_t
regulator_suspend_standby_state_show(struct device
*dev
,
536 struct device_attribute
*attr
, char *buf
)
538 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
540 return regulator_print_state(buf
,
541 rdev
->constraints
->state_standby
.enabled
);
543 static DEVICE_ATTR(suspend_standby_state
, 0444,
544 regulator_suspend_standby_state_show
, NULL
);
548 * These are the only attributes are present for all regulators.
549 * Other attributes are a function of regulator functionality.
551 static struct device_attribute regulator_dev_attrs
[] = {
552 __ATTR(name
, 0444, regulator_name_show
, NULL
),
553 __ATTR(num_users
, 0444, regulator_num_users_show
, NULL
),
554 __ATTR(type
, 0444, regulator_type_show
, NULL
),
558 static void regulator_dev_release(struct device
*dev
)
560 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
564 static struct class regulator_class
= {
566 .dev_release
= regulator_dev_release
,
567 .dev_attrs
= regulator_dev_attrs
,
570 /* Calculate the new optimum regulator operating mode based on the new total
571 * consumer load. All locks held by caller */
572 static void drms_uA_update(struct regulator_dev
*rdev
)
574 struct regulator
*sibling
;
575 int current_uA
= 0, output_uV
, input_uV
, err
;
578 err
= regulator_check_drms(rdev
);
579 if (err
< 0 || !rdev
->desc
->ops
->get_optimum_mode
||
580 (!rdev
->desc
->ops
->get_voltage
&&
581 !rdev
->desc
->ops
->get_voltage_sel
) ||
582 !rdev
->desc
->ops
->set_mode
)
585 /* get output voltage */
586 output_uV
= _regulator_get_voltage(rdev
);
590 /* get input voltage */
593 input_uV
= _regulator_get_voltage(rdev
);
595 input_uV
= rdev
->constraints
->input_uV
;
599 /* calc total requested load */
600 list_for_each_entry(sibling
, &rdev
->consumer_list
, list
)
601 current_uA
+= sibling
->uA_load
;
603 /* now get the optimum mode for our new total regulator load */
604 mode
= rdev
->desc
->ops
->get_optimum_mode(rdev
, input_uV
,
605 output_uV
, current_uA
);
607 /* check the new mode is allowed */
608 err
= regulator_check_mode(rdev
, mode
);
610 rdev
->desc
->ops
->set_mode(rdev
, mode
);
613 static int suspend_set_state(struct regulator_dev
*rdev
,
614 struct regulator_state
*rstate
)
619 can_set_state
= rdev
->desc
->ops
->set_suspend_enable
&&
620 rdev
->desc
->ops
->set_suspend_disable
;
622 /* If we have no suspend mode configration don't set anything;
623 * only warn if the driver actually makes the suspend mode
626 if (!rstate
->enabled
&& !rstate
->disabled
) {
628 rdev_warn(rdev
, "No configuration\n");
632 if (rstate
->enabled
&& rstate
->disabled
) {
633 rdev_err(rdev
, "invalid configuration\n");
637 if (!can_set_state
) {
638 rdev_err(rdev
, "no way to set suspend state\n");
643 ret
= rdev
->desc
->ops
->set_suspend_enable(rdev
);
645 ret
= rdev
->desc
->ops
->set_suspend_disable(rdev
);
647 rdev_err(rdev
, "failed to enabled/disable\n");
651 if (rdev
->desc
->ops
->set_suspend_voltage
&& rstate
->uV
> 0) {
652 ret
= rdev
->desc
->ops
->set_suspend_voltage(rdev
, rstate
->uV
);
654 rdev_err(rdev
, "failed to set voltage\n");
659 if (rdev
->desc
->ops
->set_suspend_mode
&& rstate
->mode
> 0) {
660 ret
= rdev
->desc
->ops
->set_suspend_mode(rdev
, rstate
->mode
);
662 rdev_err(rdev
, "failed to set mode\n");
669 /* locks held by caller */
670 static int suspend_prepare(struct regulator_dev
*rdev
, suspend_state_t state
)
672 if (!rdev
->constraints
)
676 case PM_SUSPEND_STANDBY
:
677 return suspend_set_state(rdev
,
678 &rdev
->constraints
->state_standby
);
680 return suspend_set_state(rdev
,
681 &rdev
->constraints
->state_mem
);
683 return suspend_set_state(rdev
,
684 &rdev
->constraints
->state_disk
);
690 static void print_constraints(struct regulator_dev
*rdev
)
692 struct regulation_constraints
*constraints
= rdev
->constraints
;
697 if (constraints
->min_uV
&& constraints
->max_uV
) {
698 if (constraints
->min_uV
== constraints
->max_uV
)
699 count
+= sprintf(buf
+ count
, "%d mV ",
700 constraints
->min_uV
/ 1000);
702 count
+= sprintf(buf
+ count
, "%d <--> %d mV ",
703 constraints
->min_uV
/ 1000,
704 constraints
->max_uV
/ 1000);
707 if (!constraints
->min_uV
||
708 constraints
->min_uV
!= constraints
->max_uV
) {
709 ret
= _regulator_get_voltage(rdev
);
711 count
+= sprintf(buf
+ count
, "at %d mV ", ret
/ 1000);
714 if (constraints
->min_uA
&& constraints
->max_uA
) {
715 if (constraints
->min_uA
== constraints
->max_uA
)
716 count
+= sprintf(buf
+ count
, "%d mA ",
717 constraints
->min_uA
/ 1000);
719 count
+= sprintf(buf
+ count
, "%d <--> %d mA ",
720 constraints
->min_uA
/ 1000,
721 constraints
->max_uA
/ 1000);
724 if (!constraints
->min_uA
||
725 constraints
->min_uA
!= constraints
->max_uA
) {
726 ret
= _regulator_get_current_limit(rdev
);
728 count
+= sprintf(buf
+ count
, "at %d mA ", ret
/ 1000);
731 if (constraints
->valid_modes_mask
& REGULATOR_MODE_FAST
)
732 count
+= sprintf(buf
+ count
, "fast ");
733 if (constraints
->valid_modes_mask
& REGULATOR_MODE_NORMAL
)
734 count
+= sprintf(buf
+ count
, "normal ");
735 if (constraints
->valid_modes_mask
& REGULATOR_MODE_IDLE
)
736 count
+= sprintf(buf
+ count
, "idle ");
737 if (constraints
->valid_modes_mask
& REGULATOR_MODE_STANDBY
)
738 count
+= sprintf(buf
+ count
, "standby");
740 rdev_info(rdev
, "regulator: %s\n", buf
);
743 static int machine_constraints_voltage(struct regulator_dev
*rdev
,
744 struct regulation_constraints
*constraints
)
746 struct regulator_ops
*ops
= rdev
->desc
->ops
;
750 /* do we need to apply the constraint voltage */
751 if (rdev
->constraints
->apply_uV
&&
752 rdev
->constraints
->min_uV
== rdev
->constraints
->max_uV
&&
754 ret
= ops
->set_voltage(rdev
,
755 rdev
->constraints
->min_uV
,
756 rdev
->constraints
->max_uV
,
759 rdev_err(rdev
, "failed to apply %duV constraint\n",
760 rdev
->constraints
->min_uV
);
761 rdev
->constraints
= NULL
;
766 /* constrain machine-level voltage specs to fit
767 * the actual range supported by this regulator.
769 if (ops
->list_voltage
&& rdev
->desc
->n_voltages
) {
770 int count
= rdev
->desc
->n_voltages
;
772 int min_uV
= INT_MAX
;
773 int max_uV
= INT_MIN
;
774 int cmin
= constraints
->min_uV
;
775 int cmax
= constraints
->max_uV
;
777 /* it's safe to autoconfigure fixed-voltage supplies
778 and the constraints are used by list_voltage. */
779 if (count
== 1 && !cmin
) {
782 constraints
->min_uV
= cmin
;
783 constraints
->max_uV
= cmax
;
786 /* voltage constraints are optional */
787 if ((cmin
== 0) && (cmax
== 0))
790 /* else require explicit machine-level constraints */
791 if (cmin
<= 0 || cmax
<= 0 || cmax
< cmin
) {
792 rdev_err(rdev
, "invalid voltage constraints\n");
796 /* initial: [cmin..cmax] valid, [min_uV..max_uV] not */
797 for (i
= 0; i
< count
; i
++) {
800 value
= ops
->list_voltage(rdev
, i
);
804 /* maybe adjust [min_uV..max_uV] */
805 if (value
>= cmin
&& value
< min_uV
)
807 if (value
<= cmax
&& value
> max_uV
)
811 /* final: [min_uV..max_uV] valid iff constraints valid */
812 if (max_uV
< min_uV
) {
813 rdev_err(rdev
, "unsupportable voltage constraints\n");
817 /* use regulator's subset of machine constraints */
818 if (constraints
->min_uV
< min_uV
) {
819 rdev_dbg(rdev
, "override min_uV, %d -> %d\n",
820 constraints
->min_uV
, min_uV
);
821 constraints
->min_uV
= min_uV
;
823 if (constraints
->max_uV
> max_uV
) {
824 rdev_dbg(rdev
, "override max_uV, %d -> %d\n",
825 constraints
->max_uV
, max_uV
);
826 constraints
->max_uV
= max_uV
;
834 * set_machine_constraints - sets regulator constraints
835 * @rdev: regulator source
836 * @constraints: constraints to apply
838 * Allows platform initialisation code to define and constrain
839 * regulator circuits e.g. valid voltage/current ranges, etc. NOTE:
840 * Constraints *must* be set by platform code in order for some
841 * regulator operations to proceed i.e. set_voltage, set_current_limit,
844 static int set_machine_constraints(struct regulator_dev
*rdev
,
845 const struct regulation_constraints
*constraints
)
848 struct regulator_ops
*ops
= rdev
->desc
->ops
;
850 rdev
->constraints
= kmemdup(constraints
, sizeof(*constraints
),
852 if (!rdev
->constraints
)
855 ret
= machine_constraints_voltage(rdev
, rdev
->constraints
);
859 /* do we need to setup our suspend state */
860 if (constraints
->initial_state
) {
861 ret
= suspend_prepare(rdev
, rdev
->constraints
->initial_state
);
863 rdev_err(rdev
, "failed to set suspend state\n");
864 rdev
->constraints
= NULL
;
869 if (constraints
->initial_mode
) {
870 if (!ops
->set_mode
) {
871 rdev_err(rdev
, "no set_mode operation\n");
876 ret
= ops
->set_mode(rdev
, rdev
->constraints
->initial_mode
);
878 rdev_err(rdev
, "failed to set initial mode: %d\n", ret
);
883 /* If the constraints say the regulator should be on at this point
884 * and we have control then make sure it is enabled.
886 if ((rdev
->constraints
->always_on
|| rdev
->constraints
->boot_on
) &&
888 ret
= ops
->enable(rdev
);
890 rdev_err(rdev
, "failed to enable\n");
891 rdev
->constraints
= NULL
;
896 print_constraints(rdev
);
902 * set_supply - set regulator supply regulator
903 * @rdev: regulator name
904 * @supply_rdev: supply regulator name
906 * Called by platform initialisation code to set the supply regulator for this
907 * regulator. This ensures that a regulators supply will also be enabled by the
908 * core if it's child is enabled.
910 static int set_supply(struct regulator_dev
*rdev
,
911 struct regulator_dev
*supply_rdev
)
915 err
= sysfs_create_link(&rdev
->dev
.kobj
, &supply_rdev
->dev
.kobj
,
918 rdev_err(rdev
, "could not add device link %s err %d\n",
919 supply_rdev
->dev
.kobj
.name
, err
);
922 rdev
->supply
= supply_rdev
;
923 list_add(&rdev
->slist
, &supply_rdev
->supply_list
);
929 * set_consumer_device_supply - Bind a regulator to a symbolic supply
930 * @rdev: regulator source
931 * @consumer_dev: device the supply applies to
932 * @consumer_dev_name: dev_name() string for device supply applies to
933 * @supply: symbolic name for supply
935 * Allows platform initialisation code to map physical regulator
936 * sources to symbolic names for supplies for use by devices. Devices
937 * should use these symbolic names to request regulators, avoiding the
938 * need to provide board-specific regulator names as platform data.
940 * Only one of consumer_dev and consumer_dev_name may be specified.
942 static int set_consumer_device_supply(struct regulator_dev
*rdev
,
943 struct device
*consumer_dev
, const char *consumer_dev_name
,
946 struct regulator_map
*node
;
949 if (consumer_dev
&& consumer_dev_name
)
952 if (!consumer_dev_name
&& consumer_dev
)
953 consumer_dev_name
= dev_name(consumer_dev
);
958 if (consumer_dev_name
!= NULL
)
963 list_for_each_entry(node
, ®ulator_map_list
, list
) {
964 if (node
->dev_name
&& consumer_dev_name
) {
965 if (strcmp(node
->dev_name
, consumer_dev_name
) != 0)
967 } else if (node
->dev_name
|| consumer_dev_name
) {
971 if (strcmp(node
->supply
, supply
) != 0)
974 dev_dbg(consumer_dev
, "%s/%s is '%s' supply; fail %s/%s\n",
975 dev_name(&node
->regulator
->dev
),
976 node
->regulator
->desc
->name
,
978 dev_name(&rdev
->dev
), rdev_get_name(rdev
));
982 node
= kzalloc(sizeof(struct regulator_map
), GFP_KERNEL
);
986 node
->regulator
= rdev
;
987 node
->supply
= supply
;
990 node
->dev_name
= kstrdup(consumer_dev_name
, GFP_KERNEL
);
991 if (node
->dev_name
== NULL
) {
997 list_add(&node
->list
, ®ulator_map_list
);
1001 static void unset_regulator_supplies(struct regulator_dev
*rdev
)
1003 struct regulator_map
*node
, *n
;
1005 list_for_each_entry_safe(node
, n
, ®ulator_map_list
, list
) {
1006 if (rdev
== node
->regulator
) {
1007 list_del(&node
->list
);
1008 kfree(node
->dev_name
);
1014 #define REG_STR_SIZE 32
1016 static struct regulator
*create_regulator(struct regulator_dev
*rdev
,
1018 const char *supply_name
)
1020 struct regulator
*regulator
;
1021 char buf
[REG_STR_SIZE
];
1024 regulator
= kzalloc(sizeof(*regulator
), GFP_KERNEL
);
1025 if (regulator
== NULL
)
1028 mutex_lock(&rdev
->mutex
);
1029 regulator
->rdev
= rdev
;
1030 list_add(®ulator
->list
, &rdev
->consumer_list
);
1033 /* create a 'requested_microamps_name' sysfs entry */
1034 size
= scnprintf(buf
, REG_STR_SIZE
, "microamps_requested_%s",
1036 if (size
>= REG_STR_SIZE
)
1039 regulator
->dev
= dev
;
1040 sysfs_attr_init(®ulator
->dev_attr
.attr
);
1041 regulator
->dev_attr
.attr
.name
= kstrdup(buf
, GFP_KERNEL
);
1042 if (regulator
->dev_attr
.attr
.name
== NULL
)
1045 regulator
->dev_attr
.attr
.mode
= 0444;
1046 regulator
->dev_attr
.show
= device_requested_uA_show
;
1047 err
= device_create_file(dev
, ®ulator
->dev_attr
);
1049 rdev_warn(rdev
, "could not add regulator_dev requested microamps sysfs entry\n");
1053 /* also add a link to the device sysfs entry */
1054 size
= scnprintf(buf
, REG_STR_SIZE
, "%s-%s",
1055 dev
->kobj
.name
, supply_name
);
1056 if (size
>= REG_STR_SIZE
)
1059 regulator
->supply_name
= kstrdup(buf
, GFP_KERNEL
);
1060 if (regulator
->supply_name
== NULL
)
1063 err
= sysfs_create_link(&rdev
->dev
.kobj
, &dev
->kobj
,
1066 rdev_warn(rdev
, "could not add device link %s err %d\n",
1067 dev
->kobj
.name
, err
);
1071 mutex_unlock(&rdev
->mutex
);
1074 kfree(regulator
->supply_name
);
1076 device_remove_file(regulator
->dev
, ®ulator
->dev_attr
);
1078 kfree(regulator
->dev_attr
.attr
.name
);
1080 list_del(®ulator
->list
);
1082 mutex_unlock(&rdev
->mutex
);
1086 static int _regulator_get_enable_time(struct regulator_dev
*rdev
)
1088 if (!rdev
->desc
->ops
->enable_time
)
1090 return rdev
->desc
->ops
->enable_time(rdev
);
1093 /* Internal regulator request function */
1094 static struct regulator
*_regulator_get(struct device
*dev
, const char *id
,
1097 struct regulator_dev
*rdev
;
1098 struct regulator_map
*map
;
1099 struct regulator
*regulator
= ERR_PTR(-ENODEV
);
1100 const char *devname
= NULL
;
1104 pr_err("get() with no identifier\n");
1109 devname
= dev_name(dev
);
1111 mutex_lock(®ulator_list_mutex
);
1113 list_for_each_entry(map
, ®ulator_map_list
, list
) {
1114 /* If the mapping has a device set up it must match */
1115 if (map
->dev_name
&&
1116 (!devname
|| strcmp(map
->dev_name
, devname
)))
1119 if (strcmp(map
->supply
, id
) == 0) {
1120 rdev
= map
->regulator
;
1125 if (board_wants_dummy_regulator
) {
1126 rdev
= dummy_regulator_rdev
;
1130 #ifdef CONFIG_REGULATOR_DUMMY
1132 devname
= "deviceless";
1134 /* If the board didn't flag that it was fully constrained then
1135 * substitute in a dummy regulator so consumers can continue.
1137 if (!has_full_constraints
) {
1138 pr_warn("%s supply %s not found, using dummy regulator\n",
1140 rdev
= dummy_regulator_rdev
;
1145 mutex_unlock(®ulator_list_mutex
);
1149 if (rdev
->exclusive
) {
1150 regulator
= ERR_PTR(-EPERM
);
1154 if (exclusive
&& rdev
->open_count
) {
1155 regulator
= ERR_PTR(-EBUSY
);
1159 if (!try_module_get(rdev
->owner
))
1162 regulator
= create_regulator(rdev
, dev
, id
);
1163 if (regulator
== NULL
) {
1164 regulator
= ERR_PTR(-ENOMEM
);
1165 module_put(rdev
->owner
);
1170 rdev
->exclusive
= 1;
1172 ret
= _regulator_is_enabled(rdev
);
1174 rdev
->use_count
= 1;
1176 rdev
->use_count
= 0;
1180 mutex_unlock(®ulator_list_mutex
);
1186 * regulator_get - lookup and obtain a reference to a regulator.
1187 * @dev: device for regulator "consumer"
1188 * @id: Supply name or regulator ID.
1190 * Returns a struct regulator corresponding to the regulator producer,
1191 * or IS_ERR() condition containing errno.
1193 * Use of supply names configured via regulator_set_device_supply() is
1194 * strongly encouraged. It is recommended that the supply name used
1195 * should match the name used for the supply and/or the relevant
1196 * device pins in the datasheet.
1198 struct regulator
*regulator_get(struct device
*dev
, const char *id
)
1200 return _regulator_get(dev
, id
, 0);
1202 EXPORT_SYMBOL_GPL(regulator_get
);
1205 * regulator_get_exclusive - obtain exclusive access to a regulator.
1206 * @dev: device for regulator "consumer"
1207 * @id: Supply name or regulator ID.
1209 * Returns a struct regulator corresponding to the regulator producer,
1210 * or IS_ERR() condition containing errno. Other consumers will be
1211 * unable to obtain this reference is held and the use count for the
1212 * regulator will be initialised to reflect the current state of the
1215 * This is intended for use by consumers which cannot tolerate shared
1216 * use of the regulator such as those which need to force the
1217 * regulator off for correct operation of the hardware they are
1220 * Use of supply names configured via regulator_set_device_supply() is
1221 * strongly encouraged. It is recommended that the supply name used
1222 * should match the name used for the supply and/or the relevant
1223 * device pins in the datasheet.
1225 struct regulator
*regulator_get_exclusive(struct device
*dev
, const char *id
)
1227 return _regulator_get(dev
, id
, 1);
1229 EXPORT_SYMBOL_GPL(regulator_get_exclusive
);
1232 * regulator_put - "free" the regulator source
1233 * @regulator: regulator source
1235 * Note: drivers must ensure that all regulator_enable calls made on this
1236 * regulator source are balanced by regulator_disable calls prior to calling
1239 void regulator_put(struct regulator
*regulator
)
1241 struct regulator_dev
*rdev
;
1243 if (regulator
== NULL
|| IS_ERR(regulator
))
1246 mutex_lock(®ulator_list_mutex
);
1247 rdev
= regulator
->rdev
;
1249 /* remove any sysfs entries */
1250 if (regulator
->dev
) {
1251 sysfs_remove_link(&rdev
->dev
.kobj
, regulator
->supply_name
);
1252 kfree(regulator
->supply_name
);
1253 device_remove_file(regulator
->dev
, ®ulator
->dev_attr
);
1254 kfree(regulator
->dev_attr
.attr
.name
);
1256 list_del(®ulator
->list
);
1260 rdev
->exclusive
= 0;
1262 module_put(rdev
->owner
);
1263 mutex_unlock(®ulator_list_mutex
);
1265 EXPORT_SYMBOL_GPL(regulator_put
);
1267 static int _regulator_can_change_status(struct regulator_dev
*rdev
)
1269 if (!rdev
->constraints
)
1272 if (rdev
->constraints
->valid_ops_mask
& REGULATOR_CHANGE_STATUS
)
1278 /* locks held by regulator_enable() */
1279 static int _regulator_enable(struct regulator_dev
*rdev
)
1283 if (rdev
->use_count
== 0) {
1284 /* do we need to enable the supply regulator first */
1286 mutex_lock(&rdev
->supply
->mutex
);
1287 ret
= _regulator_enable(rdev
->supply
);
1288 mutex_unlock(&rdev
->supply
->mutex
);
1290 rdev_err(rdev
, "failed to enable: %d\n", ret
);
1296 /* check voltage and requested load before enabling */
1297 if (rdev
->constraints
&&
1298 (rdev
->constraints
->valid_ops_mask
& REGULATOR_CHANGE_DRMS
))
1299 drms_uA_update(rdev
);
1301 if (rdev
->use_count
== 0) {
1302 /* The regulator may on if it's not switchable or left on */
1303 ret
= _regulator_is_enabled(rdev
);
1304 if (ret
== -EINVAL
|| ret
== 0) {
1305 if (!_regulator_can_change_status(rdev
))
1308 if (!rdev
->desc
->ops
->enable
)
1311 /* Query before enabling in case configuration
1313 ret
= _regulator_get_enable_time(rdev
);
1317 rdev_warn(rdev
, "enable_time() failed: %d\n",
1322 trace_regulator_enable(rdev_get_name(rdev
));
1324 /* Allow the regulator to ramp; it would be useful
1325 * to extend this for bulk operations so that the
1326 * regulators can ramp together. */
1327 ret
= rdev
->desc
->ops
->enable(rdev
);
1331 trace_regulator_enable_delay(rdev_get_name(rdev
));
1333 if (delay
>= 1000) {
1334 mdelay(delay
/ 1000);
1335 udelay(delay
% 1000);
1340 trace_regulator_enable_complete(rdev_get_name(rdev
));
1342 } else if (ret
< 0) {
1343 rdev_err(rdev
, "is_enabled() failed: %d\n", ret
);
1346 /* Fallthrough on positive return values - already enabled */
1355 * regulator_enable - enable regulator output
1356 * @regulator: regulator source
1358 * Request that the regulator be enabled with the regulator output at
1359 * the predefined voltage or current value. Calls to regulator_enable()
1360 * must be balanced with calls to regulator_disable().
1362 * NOTE: the output value can be set by other drivers, boot loader or may be
1363 * hardwired in the regulator.
1365 int regulator_enable(struct regulator
*regulator
)
1367 struct regulator_dev
*rdev
= regulator
->rdev
;
1370 mutex_lock(&rdev
->mutex
);
1371 ret
= _regulator_enable(rdev
);
1372 mutex_unlock(&rdev
->mutex
);
1375 EXPORT_SYMBOL_GPL(regulator_enable
);
1377 /* locks held by regulator_disable() */
1378 static int _regulator_disable(struct regulator_dev
*rdev
,
1379 struct regulator_dev
**supply_rdev_ptr
)
1382 *supply_rdev_ptr
= NULL
;
1384 if (WARN(rdev
->use_count
<= 0,
1385 "unbalanced disables for %s\n", rdev_get_name(rdev
)))
1388 /* are we the last user and permitted to disable ? */
1389 if (rdev
->use_count
== 1 &&
1390 (rdev
->constraints
&& !rdev
->constraints
->always_on
)) {
1392 /* we are last user */
1393 if (_regulator_can_change_status(rdev
) &&
1394 rdev
->desc
->ops
->disable
) {
1395 trace_regulator_disable(rdev_get_name(rdev
));
1397 ret
= rdev
->desc
->ops
->disable(rdev
);
1399 rdev_err(rdev
, "failed to disable\n");
1403 trace_regulator_disable_complete(rdev_get_name(rdev
));
1405 _notifier_call_chain(rdev
, REGULATOR_EVENT_DISABLE
,
1409 /* decrease our supplies ref count and disable if required */
1410 *supply_rdev_ptr
= rdev
->supply
;
1412 rdev
->use_count
= 0;
1413 } else if (rdev
->use_count
> 1) {
1415 if (rdev
->constraints
&&
1416 (rdev
->constraints
->valid_ops_mask
&
1417 REGULATOR_CHANGE_DRMS
))
1418 drms_uA_update(rdev
);
1426 * regulator_disable - disable regulator output
1427 * @regulator: regulator source
1429 * Disable the regulator output voltage or current. Calls to
1430 * regulator_enable() must be balanced with calls to
1431 * regulator_disable().
1433 * NOTE: this will only disable the regulator output if no other consumer
1434 * devices have it enabled, the regulator device supports disabling and
1435 * machine constraints permit this operation.
1437 int regulator_disable(struct regulator
*regulator
)
1439 struct regulator_dev
*rdev
= regulator
->rdev
;
1440 struct regulator_dev
*supply_rdev
= NULL
;
1443 mutex_lock(&rdev
->mutex
);
1444 ret
= _regulator_disable(rdev
, &supply_rdev
);
1445 mutex_unlock(&rdev
->mutex
);
1447 /* decrease our supplies ref count and disable if required */
1448 while (supply_rdev
!= NULL
) {
1451 mutex_lock(&rdev
->mutex
);
1452 _regulator_disable(rdev
, &supply_rdev
);
1453 mutex_unlock(&rdev
->mutex
);
1458 EXPORT_SYMBOL_GPL(regulator_disable
);
1460 /* locks held by regulator_force_disable() */
1461 static int _regulator_force_disable(struct regulator_dev
*rdev
,
1462 struct regulator_dev
**supply_rdev_ptr
)
1467 if (rdev
->desc
->ops
->disable
) {
1468 /* ah well, who wants to live forever... */
1469 ret
= rdev
->desc
->ops
->disable(rdev
);
1471 rdev_err(rdev
, "failed to force disable\n");
1474 /* notify other consumers that power has been forced off */
1475 _notifier_call_chain(rdev
, REGULATOR_EVENT_FORCE_DISABLE
|
1476 REGULATOR_EVENT_DISABLE
, NULL
);
1479 /* decrease our supplies ref count and disable if required */
1480 *supply_rdev_ptr
= rdev
->supply
;
1482 rdev
->use_count
= 0;
1487 * regulator_force_disable - force disable regulator output
1488 * @regulator: regulator source
1490 * Forcibly disable the regulator output voltage or current.
1491 * NOTE: this *will* disable the regulator output even if other consumer
1492 * devices have it enabled. This should be used for situations when device
1493 * damage will likely occur if the regulator is not disabled (e.g. over temp).
1495 int regulator_force_disable(struct regulator
*regulator
)
1497 struct regulator_dev
*supply_rdev
= NULL
;
1500 mutex_lock(®ulator
->rdev
->mutex
);
1501 regulator
->uA_load
= 0;
1502 ret
= _regulator_force_disable(regulator
->rdev
, &supply_rdev
);
1503 mutex_unlock(®ulator
->rdev
->mutex
);
1506 regulator_disable(get_device_regulator(rdev_get_dev(supply_rdev
)));
1510 EXPORT_SYMBOL_GPL(regulator_force_disable
);
1512 static int _regulator_is_enabled(struct regulator_dev
*rdev
)
1514 /* If we don't know then assume that the regulator is always on */
1515 if (!rdev
->desc
->ops
->is_enabled
)
1518 return rdev
->desc
->ops
->is_enabled(rdev
);
1522 * regulator_is_enabled - is the regulator output enabled
1523 * @regulator: regulator source
1525 * Returns positive if the regulator driver backing the source/client
1526 * has requested that the device be enabled, zero if it hasn't, else a
1527 * negative errno code.
1529 * Note that the device backing this regulator handle can have multiple
1530 * users, so it might be enabled even if regulator_enable() was never
1531 * called for this particular source.
1533 int regulator_is_enabled(struct regulator
*regulator
)
1537 mutex_lock(®ulator
->rdev
->mutex
);
1538 ret
= _regulator_is_enabled(regulator
->rdev
);
1539 mutex_unlock(®ulator
->rdev
->mutex
);
1543 EXPORT_SYMBOL_GPL(regulator_is_enabled
);
1546 * regulator_count_voltages - count regulator_list_voltage() selectors
1547 * @regulator: regulator source
1549 * Returns number of selectors, or negative errno. Selectors are
1550 * numbered starting at zero, and typically correspond to bitfields
1551 * in hardware registers.
1553 int regulator_count_voltages(struct regulator
*regulator
)
1555 struct regulator_dev
*rdev
= regulator
->rdev
;
1557 return rdev
->desc
->n_voltages
? : -EINVAL
;
1559 EXPORT_SYMBOL_GPL(regulator_count_voltages
);
1562 * regulator_list_voltage - enumerate supported voltages
1563 * @regulator: regulator source
1564 * @selector: identify voltage to list
1565 * Context: can sleep
1567 * Returns a voltage that can be passed to @regulator_set_voltage(),
1568 * zero if this selector code can't be used on this system, or a
1571 int regulator_list_voltage(struct regulator
*regulator
, unsigned selector
)
1573 struct regulator_dev
*rdev
= regulator
->rdev
;
1574 struct regulator_ops
*ops
= rdev
->desc
->ops
;
1577 if (!ops
->list_voltage
|| selector
>= rdev
->desc
->n_voltages
)
1580 mutex_lock(&rdev
->mutex
);
1581 ret
= ops
->list_voltage(rdev
, selector
);
1582 mutex_unlock(&rdev
->mutex
);
1585 if (ret
< rdev
->constraints
->min_uV
)
1587 else if (ret
> rdev
->constraints
->max_uV
)
1593 EXPORT_SYMBOL_GPL(regulator_list_voltage
);
1596 * regulator_is_supported_voltage - check if a voltage range can be supported
1598 * @regulator: Regulator to check.
1599 * @min_uV: Minimum required voltage in uV.
1600 * @max_uV: Maximum required voltage in uV.
1602 * Returns a boolean or a negative error code.
1604 int regulator_is_supported_voltage(struct regulator
*regulator
,
1605 int min_uV
, int max_uV
)
1607 int i
, voltages
, ret
;
1609 ret
= regulator_count_voltages(regulator
);
1614 for (i
= 0; i
< voltages
; i
++) {
1615 ret
= regulator_list_voltage(regulator
, i
);
1617 if (ret
>= min_uV
&& ret
<= max_uV
)
1625 * regulator_set_voltage - set regulator output voltage
1626 * @regulator: regulator source
1627 * @min_uV: Minimum required voltage in uV
1628 * @max_uV: Maximum acceptable voltage in uV
1630 * Sets a voltage regulator to the desired output voltage. This can be set
1631 * during any regulator state. IOW, regulator can be disabled or enabled.
1633 * If the regulator is enabled then the voltage will change to the new value
1634 * immediately otherwise if the regulator is disabled the regulator will
1635 * output at the new voltage when enabled.
1637 * NOTE: If the regulator is shared between several devices then the lowest
1638 * request voltage that meets the system constraints will be used.
1639 * Regulator system constraints must be set for this regulator before
1640 * calling this function otherwise this call will fail.
1642 int regulator_set_voltage(struct regulator
*regulator
, int min_uV
, int max_uV
)
1644 struct regulator_dev
*rdev
= regulator
->rdev
;
1648 mutex_lock(&rdev
->mutex
);
1651 if (!rdev
->desc
->ops
->set_voltage
) {
1656 /* constraints check */
1657 ret
= regulator_check_voltage(rdev
, &min_uV
, &max_uV
);
1660 regulator
->min_uV
= min_uV
;
1661 regulator
->max_uV
= max_uV
;
1663 ret
= regulator_check_consumers(rdev
, &min_uV
, &max_uV
);
1667 trace_regulator_set_voltage(rdev_get_name(rdev
), min_uV
, max_uV
);
1669 ret
= rdev
->desc
->ops
->set_voltage(rdev
, min_uV
, max_uV
, &selector
);
1671 if (rdev
->desc
->ops
->list_voltage
)
1672 selector
= rdev
->desc
->ops
->list_voltage(rdev
, selector
);
1676 trace_regulator_set_voltage_complete(rdev_get_name(rdev
), selector
);
1679 _notifier_call_chain(rdev
, REGULATOR_EVENT_VOLTAGE_CHANGE
, NULL
);
1680 mutex_unlock(&rdev
->mutex
);
1683 EXPORT_SYMBOL_GPL(regulator_set_voltage
);
1685 static int _regulator_get_voltage(struct regulator_dev
*rdev
)
1689 if (rdev
->desc
->ops
->get_voltage_sel
) {
1690 sel
= rdev
->desc
->ops
->get_voltage_sel(rdev
);
1693 return rdev
->desc
->ops
->list_voltage(rdev
, sel
);
1695 if (rdev
->desc
->ops
->get_voltage
)
1696 return rdev
->desc
->ops
->get_voltage(rdev
);
1702 * regulator_get_voltage - get regulator output voltage
1703 * @regulator: regulator source
1705 * This returns the current regulator voltage in uV.
1707 * NOTE: If the regulator is disabled it will return the voltage value. This
1708 * function should not be used to determine regulator state.
1710 int regulator_get_voltage(struct regulator
*regulator
)
1714 mutex_lock(®ulator
->rdev
->mutex
);
1716 ret
= _regulator_get_voltage(regulator
->rdev
);
1718 mutex_unlock(®ulator
->rdev
->mutex
);
1722 EXPORT_SYMBOL_GPL(regulator_get_voltage
);
1725 * regulator_set_current_limit - set regulator output current limit
1726 * @regulator: regulator source
1727 * @min_uA: Minimuum supported current in uA
1728 * @max_uA: Maximum supported current in uA
1730 * Sets current sink to the desired output current. This can be set during
1731 * any regulator state. IOW, regulator can be disabled or enabled.
1733 * If the regulator is enabled then the current will change to the new value
1734 * immediately otherwise if the regulator is disabled the regulator will
1735 * output at the new current when enabled.
1737 * NOTE: Regulator system constraints must be set for this regulator before
1738 * calling this function otherwise this call will fail.
1740 int regulator_set_current_limit(struct regulator
*regulator
,
1741 int min_uA
, int max_uA
)
1743 struct regulator_dev
*rdev
= regulator
->rdev
;
1746 mutex_lock(&rdev
->mutex
);
1749 if (!rdev
->desc
->ops
->set_current_limit
) {
1754 /* constraints check */
1755 ret
= regulator_check_current_limit(rdev
, &min_uA
, &max_uA
);
1759 ret
= rdev
->desc
->ops
->set_current_limit(rdev
, min_uA
, max_uA
);
1761 mutex_unlock(&rdev
->mutex
);
1764 EXPORT_SYMBOL_GPL(regulator_set_current_limit
);
1766 static int _regulator_get_current_limit(struct regulator_dev
*rdev
)
1770 mutex_lock(&rdev
->mutex
);
1773 if (!rdev
->desc
->ops
->get_current_limit
) {
1778 ret
= rdev
->desc
->ops
->get_current_limit(rdev
);
1780 mutex_unlock(&rdev
->mutex
);
1785 * regulator_get_current_limit - get regulator output current
1786 * @regulator: regulator source
1788 * This returns the current supplied by the specified current sink in uA.
1790 * NOTE: If the regulator is disabled it will return the current value. This
1791 * function should not be used to determine regulator state.
1793 int regulator_get_current_limit(struct regulator
*regulator
)
1795 return _regulator_get_current_limit(regulator
->rdev
);
1797 EXPORT_SYMBOL_GPL(regulator_get_current_limit
);
1800 * regulator_set_mode - set regulator operating mode
1801 * @regulator: regulator source
1802 * @mode: operating mode - one of the REGULATOR_MODE constants
1804 * Set regulator operating mode to increase regulator efficiency or improve
1805 * regulation performance.
1807 * NOTE: Regulator system constraints must be set for this regulator before
1808 * calling this function otherwise this call will fail.
1810 int regulator_set_mode(struct regulator
*regulator
, unsigned int mode
)
1812 struct regulator_dev
*rdev
= regulator
->rdev
;
1814 int regulator_curr_mode
;
1816 mutex_lock(&rdev
->mutex
);
1819 if (!rdev
->desc
->ops
->set_mode
) {
1824 /* return if the same mode is requested */
1825 if (rdev
->desc
->ops
->get_mode
) {
1826 regulator_curr_mode
= rdev
->desc
->ops
->get_mode(rdev
);
1827 if (regulator_curr_mode
== mode
) {
1833 /* constraints check */
1834 ret
= regulator_check_mode(rdev
, mode
);
1838 ret
= rdev
->desc
->ops
->set_mode(rdev
, mode
);
1840 mutex_unlock(&rdev
->mutex
);
1843 EXPORT_SYMBOL_GPL(regulator_set_mode
);
1845 static unsigned int _regulator_get_mode(struct regulator_dev
*rdev
)
1849 mutex_lock(&rdev
->mutex
);
1852 if (!rdev
->desc
->ops
->get_mode
) {
1857 ret
= rdev
->desc
->ops
->get_mode(rdev
);
1859 mutex_unlock(&rdev
->mutex
);
1864 * regulator_get_mode - get regulator operating mode
1865 * @regulator: regulator source
1867 * Get the current regulator operating mode.
1869 unsigned int regulator_get_mode(struct regulator
*regulator
)
1871 return _regulator_get_mode(regulator
->rdev
);
1873 EXPORT_SYMBOL_GPL(regulator_get_mode
);
1876 * regulator_set_optimum_mode - set regulator optimum operating mode
1877 * @regulator: regulator source
1878 * @uA_load: load current
1880 * Notifies the regulator core of a new device load. This is then used by
1881 * DRMS (if enabled by constraints) to set the most efficient regulator
1882 * operating mode for the new regulator loading.
1884 * Consumer devices notify their supply regulator of the maximum power
1885 * they will require (can be taken from device datasheet in the power
1886 * consumption tables) when they change operational status and hence power
1887 * state. Examples of operational state changes that can affect power
1888 * consumption are :-
1890 * o Device is opened / closed.
1891 * o Device I/O is about to begin or has just finished.
1892 * o Device is idling in between work.
1894 * This information is also exported via sysfs to userspace.
1896 * DRMS will sum the total requested load on the regulator and change
1897 * to the most efficient operating mode if platform constraints allow.
1899 * Returns the new regulator mode or error.
1901 int regulator_set_optimum_mode(struct regulator
*regulator
, int uA_load
)
1903 struct regulator_dev
*rdev
= regulator
->rdev
;
1904 struct regulator
*consumer
;
1905 int ret
, output_uV
, input_uV
, total_uA_load
= 0;
1908 mutex_lock(&rdev
->mutex
);
1910 regulator
->uA_load
= uA_load
;
1911 ret
= regulator_check_drms(rdev
);
1917 if (!rdev
->desc
->ops
->get_optimum_mode
)
1920 /* get output voltage */
1921 output_uV
= _regulator_get_voltage(rdev
);
1922 if (output_uV
<= 0) {
1923 rdev_err(rdev
, "invalid output voltage found\n");
1927 /* get input voltage */
1930 input_uV
= _regulator_get_voltage(rdev
->supply
);
1932 input_uV
= rdev
->constraints
->input_uV
;
1933 if (input_uV
<= 0) {
1934 rdev_err(rdev
, "invalid input voltage found\n");
1938 /* calc total requested load for this regulator */
1939 list_for_each_entry(consumer
, &rdev
->consumer_list
, list
)
1940 total_uA_load
+= consumer
->uA_load
;
1942 mode
= rdev
->desc
->ops
->get_optimum_mode(rdev
,
1943 input_uV
, output_uV
,
1945 ret
= regulator_check_mode(rdev
, mode
);
1947 rdev_err(rdev
, "failed to get optimum mode @ %d uA %d -> %d uV\n",
1948 total_uA_load
, input_uV
, output_uV
);
1952 ret
= rdev
->desc
->ops
->set_mode(rdev
, mode
);
1954 rdev_err(rdev
, "failed to set optimum mode %x\n", mode
);
1959 mutex_unlock(&rdev
->mutex
);
1962 EXPORT_SYMBOL_GPL(regulator_set_optimum_mode
);
1965 * regulator_register_notifier - register regulator event notifier
1966 * @regulator: regulator source
1967 * @nb: notifier block
1969 * Register notifier block to receive regulator events.
1971 int regulator_register_notifier(struct regulator
*regulator
,
1972 struct notifier_block
*nb
)
1974 return blocking_notifier_chain_register(®ulator
->rdev
->notifier
,
1977 EXPORT_SYMBOL_GPL(regulator_register_notifier
);
1980 * regulator_unregister_notifier - unregister regulator event notifier
1981 * @regulator: regulator source
1982 * @nb: notifier block
1984 * Unregister regulator event notifier block.
1986 int regulator_unregister_notifier(struct regulator
*regulator
,
1987 struct notifier_block
*nb
)
1989 return blocking_notifier_chain_unregister(®ulator
->rdev
->notifier
,
1992 EXPORT_SYMBOL_GPL(regulator_unregister_notifier
);
1994 /* notify regulator consumers and downstream regulator consumers.
1995 * Note mutex must be held by caller.
1997 static void _notifier_call_chain(struct regulator_dev
*rdev
,
1998 unsigned long event
, void *data
)
2000 struct regulator_dev
*_rdev
;
2002 /* call rdev chain first */
2003 blocking_notifier_call_chain(&rdev
->notifier
, event
, NULL
);
2005 /* now notify regulator we supply */
2006 list_for_each_entry(_rdev
, &rdev
->supply_list
, slist
) {
2007 mutex_lock(&_rdev
->mutex
);
2008 _notifier_call_chain(_rdev
, event
, data
);
2009 mutex_unlock(&_rdev
->mutex
);
2014 * regulator_bulk_get - get multiple regulator consumers
2016 * @dev: Device to supply
2017 * @num_consumers: Number of consumers to register
2018 * @consumers: Configuration of consumers; clients are stored here.
2020 * @return 0 on success, an errno on failure.
2022 * This helper function allows drivers to get several regulator
2023 * consumers in one operation. If any of the regulators cannot be
2024 * acquired then any regulators that were allocated will be freed
2025 * before returning to the caller.
2027 int regulator_bulk_get(struct device
*dev
, int num_consumers
,
2028 struct regulator_bulk_data
*consumers
)
2033 for (i
= 0; i
< num_consumers
; i
++)
2034 consumers
[i
].consumer
= NULL
;
2036 for (i
= 0; i
< num_consumers
; i
++) {
2037 consumers
[i
].consumer
= regulator_get(dev
,
2038 consumers
[i
].supply
);
2039 if (IS_ERR(consumers
[i
].consumer
)) {
2040 ret
= PTR_ERR(consumers
[i
].consumer
);
2041 dev_err(dev
, "Failed to get supply '%s': %d\n",
2042 consumers
[i
].supply
, ret
);
2043 consumers
[i
].consumer
= NULL
;
2051 for (i
= 0; i
< num_consumers
&& consumers
[i
].consumer
; i
++)
2052 regulator_put(consumers
[i
].consumer
);
2056 EXPORT_SYMBOL_GPL(regulator_bulk_get
);
2059 * regulator_bulk_enable - enable multiple regulator consumers
2061 * @num_consumers: Number of consumers
2062 * @consumers: Consumer data; clients are stored here.
2063 * @return 0 on success, an errno on failure
2065 * This convenience API allows consumers to enable multiple regulator
2066 * clients in a single API call. If any consumers cannot be enabled
2067 * then any others that were enabled will be disabled again prior to
2070 int regulator_bulk_enable(int num_consumers
,
2071 struct regulator_bulk_data
*consumers
)
2076 for (i
= 0; i
< num_consumers
; i
++) {
2077 ret
= regulator_enable(consumers
[i
].consumer
);
2085 pr_err("Failed to enable %s: %d\n", consumers
[i
].supply
, ret
);
2086 for (--i
; i
>= 0; --i
)
2087 regulator_disable(consumers
[i
].consumer
);
2091 EXPORT_SYMBOL_GPL(regulator_bulk_enable
);
2094 * regulator_bulk_disable - disable multiple regulator consumers
2096 * @num_consumers: Number of consumers
2097 * @consumers: Consumer data; clients are stored here.
2098 * @return 0 on success, an errno on failure
2100 * This convenience API allows consumers to disable multiple regulator
2101 * clients in a single API call. If any consumers cannot be enabled
2102 * then any others that were disabled will be disabled again prior to
2105 int regulator_bulk_disable(int num_consumers
,
2106 struct regulator_bulk_data
*consumers
)
2111 for (i
= 0; i
< num_consumers
; i
++) {
2112 ret
= regulator_disable(consumers
[i
].consumer
);
2120 pr_err("Failed to disable %s: %d\n", consumers
[i
].supply
, ret
);
2121 for (--i
; i
>= 0; --i
)
2122 regulator_enable(consumers
[i
].consumer
);
2126 EXPORT_SYMBOL_GPL(regulator_bulk_disable
);
2129 * regulator_bulk_free - free multiple regulator consumers
2131 * @num_consumers: Number of consumers
2132 * @consumers: Consumer data; clients are stored here.
2134 * This convenience API allows consumers to free multiple regulator
2135 * clients in a single API call.
2137 void regulator_bulk_free(int num_consumers
,
2138 struct regulator_bulk_data
*consumers
)
2142 for (i
= 0; i
< num_consumers
; i
++) {
2143 regulator_put(consumers
[i
].consumer
);
2144 consumers
[i
].consumer
= NULL
;
2147 EXPORT_SYMBOL_GPL(regulator_bulk_free
);
2150 * regulator_notifier_call_chain - call regulator event notifier
2151 * @rdev: regulator source
2152 * @event: notifier block
2153 * @data: callback-specific data.
2155 * Called by regulator drivers to notify clients a regulator event has
2156 * occurred. We also notify regulator clients downstream.
2157 * Note lock must be held by caller.
2159 int regulator_notifier_call_chain(struct regulator_dev
*rdev
,
2160 unsigned long event
, void *data
)
2162 _notifier_call_chain(rdev
, event
, data
);
2166 EXPORT_SYMBOL_GPL(regulator_notifier_call_chain
);
2169 * regulator_mode_to_status - convert a regulator mode into a status
2171 * @mode: Mode to convert
2173 * Convert a regulator mode into a status.
2175 int regulator_mode_to_status(unsigned int mode
)
2178 case REGULATOR_MODE_FAST
:
2179 return REGULATOR_STATUS_FAST
;
2180 case REGULATOR_MODE_NORMAL
:
2181 return REGULATOR_STATUS_NORMAL
;
2182 case REGULATOR_MODE_IDLE
:
2183 return REGULATOR_STATUS_IDLE
;
2184 case REGULATOR_STATUS_STANDBY
:
2185 return REGULATOR_STATUS_STANDBY
;
2190 EXPORT_SYMBOL_GPL(regulator_mode_to_status
);
2193 * To avoid cluttering sysfs (and memory) with useless state, only
2194 * create attributes that can be meaningfully displayed.
2196 static int add_regulator_attributes(struct regulator_dev
*rdev
)
2198 struct device
*dev
= &rdev
->dev
;
2199 struct regulator_ops
*ops
= rdev
->desc
->ops
;
2202 /* some attributes need specific methods to be displayed */
2203 if (ops
->get_voltage
|| ops
->get_voltage_sel
) {
2204 status
= device_create_file(dev
, &dev_attr_microvolts
);
2208 if (ops
->get_current_limit
) {
2209 status
= device_create_file(dev
, &dev_attr_microamps
);
2213 if (ops
->get_mode
) {
2214 status
= device_create_file(dev
, &dev_attr_opmode
);
2218 if (ops
->is_enabled
) {
2219 status
= device_create_file(dev
, &dev_attr_state
);
2223 if (ops
->get_status
) {
2224 status
= device_create_file(dev
, &dev_attr_status
);
2229 /* some attributes are type-specific */
2230 if (rdev
->desc
->type
== REGULATOR_CURRENT
) {
2231 status
= device_create_file(dev
, &dev_attr_requested_microamps
);
2236 /* all the other attributes exist to support constraints;
2237 * don't show them if there are no constraints, or if the
2238 * relevant supporting methods are missing.
2240 if (!rdev
->constraints
)
2243 /* constraints need specific supporting methods */
2244 if (ops
->set_voltage
) {
2245 status
= device_create_file(dev
, &dev_attr_min_microvolts
);
2248 status
= device_create_file(dev
, &dev_attr_max_microvolts
);
2252 if (ops
->set_current_limit
) {
2253 status
= device_create_file(dev
, &dev_attr_min_microamps
);
2256 status
= device_create_file(dev
, &dev_attr_max_microamps
);
2261 /* suspend mode constraints need multiple supporting methods */
2262 if (!(ops
->set_suspend_enable
&& ops
->set_suspend_disable
))
2265 status
= device_create_file(dev
, &dev_attr_suspend_standby_state
);
2268 status
= device_create_file(dev
, &dev_attr_suspend_mem_state
);
2271 status
= device_create_file(dev
, &dev_attr_suspend_disk_state
);
2275 if (ops
->set_suspend_voltage
) {
2276 status
= device_create_file(dev
,
2277 &dev_attr_suspend_standby_microvolts
);
2280 status
= device_create_file(dev
,
2281 &dev_attr_suspend_mem_microvolts
);
2284 status
= device_create_file(dev
,
2285 &dev_attr_suspend_disk_microvolts
);
2290 if (ops
->set_suspend_mode
) {
2291 status
= device_create_file(dev
,
2292 &dev_attr_suspend_standby_mode
);
2295 status
= device_create_file(dev
,
2296 &dev_attr_suspend_mem_mode
);
2299 status
= device_create_file(dev
,
2300 &dev_attr_suspend_disk_mode
);
2309 * regulator_register - register regulator
2310 * @regulator_desc: regulator to register
2311 * @dev: struct device for the regulator
2312 * @init_data: platform provided init data, passed through by driver
2313 * @driver_data: private regulator data
2315 * Called by regulator drivers to register a regulator.
2316 * Returns 0 on success.
2318 struct regulator_dev
*regulator_register(struct regulator_desc
*regulator_desc
,
2319 struct device
*dev
, const struct regulator_init_data
*init_data
,
2322 static atomic_t regulator_no
= ATOMIC_INIT(0);
2323 struct regulator_dev
*rdev
;
2326 if (regulator_desc
== NULL
)
2327 return ERR_PTR(-EINVAL
);
2329 if (regulator_desc
->name
== NULL
|| regulator_desc
->ops
== NULL
)
2330 return ERR_PTR(-EINVAL
);
2332 if (regulator_desc
->type
!= REGULATOR_VOLTAGE
&&
2333 regulator_desc
->type
!= REGULATOR_CURRENT
)
2334 return ERR_PTR(-EINVAL
);
2337 return ERR_PTR(-EINVAL
);
2339 /* Only one of each should be implemented */
2340 WARN_ON(regulator_desc
->ops
->get_voltage
&&
2341 regulator_desc
->ops
->get_voltage_sel
);
2343 /* If we're using selectors we must implement list_voltage. */
2344 if (regulator_desc
->ops
->get_voltage_sel
&&
2345 !regulator_desc
->ops
->list_voltage
) {
2346 return ERR_PTR(-EINVAL
);
2349 rdev
= kzalloc(sizeof(struct regulator_dev
), GFP_KERNEL
);
2351 return ERR_PTR(-ENOMEM
);
2353 mutex_lock(®ulator_list_mutex
);
2355 mutex_init(&rdev
->mutex
);
2356 rdev
->reg_data
= driver_data
;
2357 rdev
->owner
= regulator_desc
->owner
;
2358 rdev
->desc
= regulator_desc
;
2359 INIT_LIST_HEAD(&rdev
->consumer_list
);
2360 INIT_LIST_HEAD(&rdev
->supply_list
);
2361 INIT_LIST_HEAD(&rdev
->list
);
2362 INIT_LIST_HEAD(&rdev
->slist
);
2363 BLOCKING_INIT_NOTIFIER_HEAD(&rdev
->notifier
);
2365 /* preform any regulator specific init */
2366 if (init_data
->regulator_init
) {
2367 ret
= init_data
->regulator_init(rdev
->reg_data
);
2372 /* register with sysfs */
2373 rdev
->dev
.class = ®ulator_class
;
2374 rdev
->dev
.parent
= dev
;
2375 dev_set_name(&rdev
->dev
, "regulator.%d",
2376 atomic_inc_return(®ulator_no
) - 1);
2377 ret
= device_register(&rdev
->dev
);
2379 put_device(&rdev
->dev
);
2383 dev_set_drvdata(&rdev
->dev
, rdev
);
2385 /* set regulator constraints */
2386 ret
= set_machine_constraints(rdev
, &init_data
->constraints
);
2390 /* add attributes supported by this regulator */
2391 ret
= add_regulator_attributes(rdev
);
2395 /* set supply regulator if it exists */
2396 if (init_data
->supply_regulator
&& init_data
->supply_regulator_dev
) {
2398 "Supply regulator specified by both name and dev\n");
2403 if (init_data
->supply_regulator
) {
2404 struct regulator_dev
*r
;
2407 list_for_each_entry(r
, ®ulator_list
, list
) {
2408 if (strcmp(rdev_get_name(r
),
2409 init_data
->supply_regulator
) == 0) {
2416 dev_err(dev
, "Failed to find supply %s\n",
2417 init_data
->supply_regulator
);
2422 ret
= set_supply(rdev
, r
);
2427 if (init_data
->supply_regulator_dev
) {
2428 dev_warn(dev
, "Uses supply_regulator_dev instead of regulator_supply\n");
2429 ret
= set_supply(rdev
,
2430 dev_get_drvdata(init_data
->supply_regulator_dev
));
2435 /* add consumers devices */
2436 for (i
= 0; i
< init_data
->num_consumer_supplies
; i
++) {
2437 ret
= set_consumer_device_supply(rdev
,
2438 init_data
->consumer_supplies
[i
].dev
,
2439 init_data
->consumer_supplies
[i
].dev_name
,
2440 init_data
->consumer_supplies
[i
].supply
);
2442 goto unset_supplies
;
2445 list_add(&rdev
->list
, ®ulator_list
);
2447 mutex_unlock(®ulator_list_mutex
);
2451 unset_regulator_supplies(rdev
);
2454 device_unregister(&rdev
->dev
);
2455 /* device core frees rdev */
2456 rdev
= ERR_PTR(ret
);
2461 rdev
= ERR_PTR(ret
);
2464 EXPORT_SYMBOL_GPL(regulator_register
);
2467 * regulator_unregister - unregister regulator
2468 * @rdev: regulator to unregister
2470 * Called by regulator drivers to unregister a regulator.
2472 void regulator_unregister(struct regulator_dev
*rdev
)
2477 mutex_lock(®ulator_list_mutex
);
2478 WARN_ON(rdev
->open_count
);
2479 unset_regulator_supplies(rdev
);
2480 list_del(&rdev
->list
);
2482 sysfs_remove_link(&rdev
->dev
.kobj
, "supply");
2483 device_unregister(&rdev
->dev
);
2484 kfree(rdev
->constraints
);
2485 mutex_unlock(®ulator_list_mutex
);
2487 EXPORT_SYMBOL_GPL(regulator_unregister
);
2490 * regulator_suspend_prepare - prepare regulators for system wide suspend
2491 * @state: system suspend state
2493 * Configure each regulator with it's suspend operating parameters for state.
2494 * This will usually be called by machine suspend code prior to supending.
2496 int regulator_suspend_prepare(suspend_state_t state
)
2498 struct regulator_dev
*rdev
;
2501 /* ON is handled by regulator active state */
2502 if (state
== PM_SUSPEND_ON
)
2505 mutex_lock(®ulator_list_mutex
);
2506 list_for_each_entry(rdev
, ®ulator_list
, list
) {
2508 mutex_lock(&rdev
->mutex
);
2509 ret
= suspend_prepare(rdev
, state
);
2510 mutex_unlock(&rdev
->mutex
);
2513 rdev_err(rdev
, "failed to prepare\n");
2518 mutex_unlock(®ulator_list_mutex
);
2521 EXPORT_SYMBOL_GPL(regulator_suspend_prepare
);
2524 * regulator_has_full_constraints - the system has fully specified constraints
2526 * Calling this function will cause the regulator API to disable all
2527 * regulators which have a zero use count and don't have an always_on
2528 * constraint in a late_initcall.
2530 * The intention is that this will become the default behaviour in a
2531 * future kernel release so users are encouraged to use this facility
2534 void regulator_has_full_constraints(void)
2536 has_full_constraints
= 1;
2538 EXPORT_SYMBOL_GPL(regulator_has_full_constraints
);
2541 * regulator_use_dummy_regulator - Provide a dummy regulator when none is found
2543 * Calling this function will cause the regulator API to provide a
2544 * dummy regulator to consumers if no physical regulator is found,
2545 * allowing most consumers to proceed as though a regulator were
2546 * configured. This allows systems such as those with software
2547 * controllable regulators for the CPU core only to be brought up more
2550 void regulator_use_dummy_regulator(void)
2552 board_wants_dummy_regulator
= true;
2554 EXPORT_SYMBOL_GPL(regulator_use_dummy_regulator
);
2557 * rdev_get_drvdata - get rdev regulator driver data
2560 * Get rdev regulator driver private data. This call can be used in the
2561 * regulator driver context.
2563 void *rdev_get_drvdata(struct regulator_dev
*rdev
)
2565 return rdev
->reg_data
;
2567 EXPORT_SYMBOL_GPL(rdev_get_drvdata
);
2570 * regulator_get_drvdata - get regulator driver data
2571 * @regulator: regulator
2573 * Get regulator driver private data. This call can be used in the consumer
2574 * driver context when non API regulator specific functions need to be called.
2576 void *regulator_get_drvdata(struct regulator
*regulator
)
2578 return regulator
->rdev
->reg_data
;
2580 EXPORT_SYMBOL_GPL(regulator_get_drvdata
);
2583 * regulator_set_drvdata - set regulator driver data
2584 * @regulator: regulator
2587 void regulator_set_drvdata(struct regulator
*regulator
, void *data
)
2589 regulator
->rdev
->reg_data
= data
;
2591 EXPORT_SYMBOL_GPL(regulator_set_drvdata
);
2594 * regulator_get_id - get regulator ID
2597 int rdev_get_id(struct regulator_dev
*rdev
)
2599 return rdev
->desc
->id
;
2601 EXPORT_SYMBOL_GPL(rdev_get_id
);
2603 struct device
*rdev_get_dev(struct regulator_dev
*rdev
)
2607 EXPORT_SYMBOL_GPL(rdev_get_dev
);
2609 void *regulator_get_init_drvdata(struct regulator_init_data
*reg_init_data
)
2611 return reg_init_data
->driver_data
;
2613 EXPORT_SYMBOL_GPL(regulator_get_init_drvdata
);
2615 static int __init
regulator_init(void)
2619 ret
= class_register(®ulator_class
);
2621 regulator_dummy_init();
2626 /* init early to allow our consumers to complete system booting */
2627 core_initcall(regulator_init
);
2629 static int __init
regulator_init_complete(void)
2631 struct regulator_dev
*rdev
;
2632 struct regulator_ops
*ops
;
2633 struct regulation_constraints
*c
;
2636 mutex_lock(®ulator_list_mutex
);
2638 /* If we have a full configuration then disable any regulators
2639 * which are not in use or always_on. This will become the
2640 * default behaviour in the future.
2642 list_for_each_entry(rdev
, ®ulator_list
, list
) {
2643 ops
= rdev
->desc
->ops
;
2644 c
= rdev
->constraints
;
2646 if (!ops
->disable
|| (c
&& c
->always_on
))
2649 mutex_lock(&rdev
->mutex
);
2651 if (rdev
->use_count
)
2654 /* If we can't read the status assume it's on. */
2655 if (ops
->is_enabled
)
2656 enabled
= ops
->is_enabled(rdev
);
2663 if (has_full_constraints
) {
2664 /* We log since this may kill the system if it
2666 rdev_info(rdev
, "disabling\n");
2667 ret
= ops
->disable(rdev
);
2669 rdev_err(rdev
, "couldn't disable: %d\n", ret
);
2672 /* The intention is that in future we will
2673 * assume that full constraints are provided
2674 * so warn even if we aren't going to do
2677 rdev_warn(rdev
, "incomplete constraints, leaving on\n");
2681 mutex_unlock(&rdev
->mutex
);
2684 mutex_unlock(®ulator_list_mutex
);
2688 late_initcall(regulator_init_complete
);