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 #include <linux/kernel.h>
17 #include <linux/init.h>
18 #include <linux/debugfs.h>
19 #include <linux/device.h>
20 #include <linux/slab.h>
21 #include <linux/async.h>
22 #include <linux/err.h>
23 #include <linux/mutex.h>
24 #include <linux/suspend.h>
25 #include <linux/delay.h>
27 #include <linux/regmap.h>
28 #include <linux/regulator/of_regulator.h>
29 #include <linux/regulator/consumer.h>
30 #include <linux/regulator/driver.h>
31 #include <linux/regulator/machine.h>
32 #include <linux/module.h>
34 #define CREATE_TRACE_POINTS
35 #include <trace/events/regulator.h>
39 #define rdev_crit(rdev, fmt, ...) \
40 pr_crit("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
41 #define rdev_err(rdev, fmt, ...) \
42 pr_err("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
43 #define rdev_warn(rdev, fmt, ...) \
44 pr_warn("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
45 #define rdev_info(rdev, fmt, ...) \
46 pr_info("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
47 #define rdev_dbg(rdev, fmt, ...) \
48 pr_debug("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
50 static DEFINE_MUTEX(regulator_list_mutex
);
51 static LIST_HEAD(regulator_list
);
52 static LIST_HEAD(regulator_map_list
);
53 static bool has_full_constraints
;
54 static bool board_wants_dummy_regulator
;
56 static struct dentry
*debugfs_root
;
59 * struct regulator_map
61 * Used to provide symbolic supply names to devices.
63 struct regulator_map
{
64 struct list_head list
;
65 const char *dev_name
; /* The dev_name() for the consumer */
67 struct regulator_dev
*regulator
;
73 * One for each consumer device.
77 struct list_head list
;
78 unsigned int always_on
:1;
83 struct device_attribute dev_attr
;
84 struct regulator_dev
*rdev
;
85 struct dentry
*debugfs
;
88 static int _regulator_is_enabled(struct regulator_dev
*rdev
);
89 static int _regulator_disable(struct regulator_dev
*rdev
);
90 static int _regulator_get_voltage(struct regulator_dev
*rdev
);
91 static int _regulator_get_current_limit(struct regulator_dev
*rdev
);
92 static unsigned int _regulator_get_mode(struct regulator_dev
*rdev
);
93 static void _notifier_call_chain(struct regulator_dev
*rdev
,
94 unsigned long event
, void *data
);
95 static int _regulator_do_set_voltage(struct regulator_dev
*rdev
,
96 int min_uV
, int max_uV
);
97 static struct regulator
*create_regulator(struct regulator_dev
*rdev
,
99 const char *supply_name
);
101 static const char *rdev_get_name(struct regulator_dev
*rdev
)
103 if (rdev
->constraints
&& rdev
->constraints
->name
)
104 return rdev
->constraints
->name
;
105 else if (rdev
->desc
->name
)
106 return rdev
->desc
->name
;
112 * of_get_regulator - get a regulator device node based on supply name
113 * @dev: Device pointer for the consumer (of regulator) device
114 * @supply: regulator supply name
116 * Extract the regulator device node corresponding to the supply name.
117 * retruns the device node corresponding to the regulator if found, else
120 static struct device_node
*of_get_regulator(struct device
*dev
, const char *supply
)
122 struct device_node
*regnode
= NULL
;
123 char prop_name
[32]; /* 32 is max size of property name */
125 dev_dbg(dev
, "Looking up %s-supply from device tree\n", supply
);
127 snprintf(prop_name
, 32, "%s-supply", supply
);
128 regnode
= of_parse_phandle(dev
->of_node
, prop_name
, 0);
131 dev_dbg(dev
, "Looking up %s property in node %s failed",
132 prop_name
, dev
->of_node
->full_name
);
138 static int _regulator_can_change_status(struct regulator_dev
*rdev
)
140 if (!rdev
->constraints
)
143 if (rdev
->constraints
->valid_ops_mask
& REGULATOR_CHANGE_STATUS
)
149 /* Platform voltage constraint check */
150 static int regulator_check_voltage(struct regulator_dev
*rdev
,
151 int *min_uV
, int *max_uV
)
153 BUG_ON(*min_uV
> *max_uV
);
155 if (!rdev
->constraints
) {
156 rdev_err(rdev
, "no constraints\n");
159 if (!(rdev
->constraints
->valid_ops_mask
& REGULATOR_CHANGE_VOLTAGE
)) {
160 rdev_err(rdev
, "operation not allowed\n");
164 if (*max_uV
> rdev
->constraints
->max_uV
)
165 *max_uV
= rdev
->constraints
->max_uV
;
166 if (*min_uV
< rdev
->constraints
->min_uV
)
167 *min_uV
= rdev
->constraints
->min_uV
;
169 if (*min_uV
> *max_uV
) {
170 rdev_err(rdev
, "unsupportable voltage range: %d-%duV\n",
178 /* Make sure we select a voltage that suits the needs of all
179 * regulator consumers
181 static int regulator_check_consumers(struct regulator_dev
*rdev
,
182 int *min_uV
, int *max_uV
)
184 struct regulator
*regulator
;
186 list_for_each_entry(regulator
, &rdev
->consumer_list
, list
) {
188 * Assume consumers that didn't say anything are OK
189 * with anything in the constraint range.
191 if (!regulator
->min_uV
&& !regulator
->max_uV
)
194 if (*max_uV
> regulator
->max_uV
)
195 *max_uV
= regulator
->max_uV
;
196 if (*min_uV
< regulator
->min_uV
)
197 *min_uV
= regulator
->min_uV
;
200 if (*min_uV
> *max_uV
)
206 /* current constraint check */
207 static int regulator_check_current_limit(struct regulator_dev
*rdev
,
208 int *min_uA
, int *max_uA
)
210 BUG_ON(*min_uA
> *max_uA
);
212 if (!rdev
->constraints
) {
213 rdev_err(rdev
, "no constraints\n");
216 if (!(rdev
->constraints
->valid_ops_mask
& REGULATOR_CHANGE_CURRENT
)) {
217 rdev_err(rdev
, "operation not allowed\n");
221 if (*max_uA
> rdev
->constraints
->max_uA
)
222 *max_uA
= rdev
->constraints
->max_uA
;
223 if (*min_uA
< rdev
->constraints
->min_uA
)
224 *min_uA
= rdev
->constraints
->min_uA
;
226 if (*min_uA
> *max_uA
) {
227 rdev_err(rdev
, "unsupportable current range: %d-%duA\n",
235 /* operating mode constraint check */
236 static int regulator_mode_constrain(struct regulator_dev
*rdev
, int *mode
)
239 case REGULATOR_MODE_FAST
:
240 case REGULATOR_MODE_NORMAL
:
241 case REGULATOR_MODE_IDLE
:
242 case REGULATOR_MODE_STANDBY
:
245 rdev_err(rdev
, "invalid mode %x specified\n", *mode
);
249 if (!rdev
->constraints
) {
250 rdev_err(rdev
, "no constraints\n");
253 if (!(rdev
->constraints
->valid_ops_mask
& REGULATOR_CHANGE_MODE
)) {
254 rdev_err(rdev
, "operation not allowed\n");
258 /* The modes are bitmasks, the most power hungry modes having
259 * the lowest values. If the requested mode isn't supported
260 * try higher modes. */
262 if (rdev
->constraints
->valid_modes_mask
& *mode
)
270 /* dynamic regulator mode switching constraint check */
271 static int regulator_check_drms(struct regulator_dev
*rdev
)
273 if (!rdev
->constraints
) {
274 rdev_err(rdev
, "no constraints\n");
277 if (!(rdev
->constraints
->valid_ops_mask
& REGULATOR_CHANGE_DRMS
)) {
278 rdev_err(rdev
, "operation not allowed\n");
284 static ssize_t
regulator_uV_show(struct device
*dev
,
285 struct device_attribute
*attr
, char *buf
)
287 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
290 mutex_lock(&rdev
->mutex
);
291 ret
= sprintf(buf
, "%d\n", _regulator_get_voltage(rdev
));
292 mutex_unlock(&rdev
->mutex
);
296 static DEVICE_ATTR(microvolts
, 0444, regulator_uV_show
, NULL
);
298 static ssize_t
regulator_uA_show(struct device
*dev
,
299 struct device_attribute
*attr
, char *buf
)
301 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
303 return sprintf(buf
, "%d\n", _regulator_get_current_limit(rdev
));
305 static DEVICE_ATTR(microamps
, 0444, regulator_uA_show
, NULL
);
307 static ssize_t
regulator_name_show(struct device
*dev
,
308 struct device_attribute
*attr
, char *buf
)
310 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
312 return sprintf(buf
, "%s\n", rdev_get_name(rdev
));
315 static ssize_t
regulator_print_opmode(char *buf
, int mode
)
318 case REGULATOR_MODE_FAST
:
319 return sprintf(buf
, "fast\n");
320 case REGULATOR_MODE_NORMAL
:
321 return sprintf(buf
, "normal\n");
322 case REGULATOR_MODE_IDLE
:
323 return sprintf(buf
, "idle\n");
324 case REGULATOR_MODE_STANDBY
:
325 return sprintf(buf
, "standby\n");
327 return sprintf(buf
, "unknown\n");
330 static ssize_t
regulator_opmode_show(struct device
*dev
,
331 struct device_attribute
*attr
, char *buf
)
333 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
335 return regulator_print_opmode(buf
, _regulator_get_mode(rdev
));
337 static DEVICE_ATTR(opmode
, 0444, regulator_opmode_show
, NULL
);
339 static ssize_t
regulator_print_state(char *buf
, int state
)
342 return sprintf(buf
, "enabled\n");
344 return sprintf(buf
, "disabled\n");
346 return sprintf(buf
, "unknown\n");
349 static ssize_t
regulator_state_show(struct device
*dev
,
350 struct device_attribute
*attr
, char *buf
)
352 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
355 mutex_lock(&rdev
->mutex
);
356 ret
= regulator_print_state(buf
, _regulator_is_enabled(rdev
));
357 mutex_unlock(&rdev
->mutex
);
361 static DEVICE_ATTR(state
, 0444, regulator_state_show
, NULL
);
363 static ssize_t
regulator_status_show(struct device
*dev
,
364 struct device_attribute
*attr
, char *buf
)
366 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
370 status
= rdev
->desc
->ops
->get_status(rdev
);
375 case REGULATOR_STATUS_OFF
:
378 case REGULATOR_STATUS_ON
:
381 case REGULATOR_STATUS_ERROR
:
384 case REGULATOR_STATUS_FAST
:
387 case REGULATOR_STATUS_NORMAL
:
390 case REGULATOR_STATUS_IDLE
:
393 case REGULATOR_STATUS_STANDBY
:
400 return sprintf(buf
, "%s\n", label
);
402 static DEVICE_ATTR(status
, 0444, regulator_status_show
, NULL
);
404 static ssize_t
regulator_min_uA_show(struct device
*dev
,
405 struct device_attribute
*attr
, char *buf
)
407 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
409 if (!rdev
->constraints
)
410 return sprintf(buf
, "constraint not defined\n");
412 return sprintf(buf
, "%d\n", rdev
->constraints
->min_uA
);
414 static DEVICE_ATTR(min_microamps
, 0444, regulator_min_uA_show
, NULL
);
416 static ssize_t
regulator_max_uA_show(struct device
*dev
,
417 struct device_attribute
*attr
, char *buf
)
419 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
421 if (!rdev
->constraints
)
422 return sprintf(buf
, "constraint not defined\n");
424 return sprintf(buf
, "%d\n", rdev
->constraints
->max_uA
);
426 static DEVICE_ATTR(max_microamps
, 0444, regulator_max_uA_show
, NULL
);
428 static ssize_t
regulator_min_uV_show(struct device
*dev
,
429 struct device_attribute
*attr
, char *buf
)
431 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
433 if (!rdev
->constraints
)
434 return sprintf(buf
, "constraint not defined\n");
436 return sprintf(buf
, "%d\n", rdev
->constraints
->min_uV
);
438 static DEVICE_ATTR(min_microvolts
, 0444, regulator_min_uV_show
, NULL
);
440 static ssize_t
regulator_max_uV_show(struct device
*dev
,
441 struct device_attribute
*attr
, char *buf
)
443 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
445 if (!rdev
->constraints
)
446 return sprintf(buf
, "constraint not defined\n");
448 return sprintf(buf
, "%d\n", rdev
->constraints
->max_uV
);
450 static DEVICE_ATTR(max_microvolts
, 0444, regulator_max_uV_show
, NULL
);
452 static ssize_t
regulator_total_uA_show(struct device
*dev
,
453 struct device_attribute
*attr
, char *buf
)
455 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
456 struct regulator
*regulator
;
459 mutex_lock(&rdev
->mutex
);
460 list_for_each_entry(regulator
, &rdev
->consumer_list
, list
)
461 uA
+= regulator
->uA_load
;
462 mutex_unlock(&rdev
->mutex
);
463 return sprintf(buf
, "%d\n", uA
);
465 static DEVICE_ATTR(requested_microamps
, 0444, regulator_total_uA_show
, NULL
);
467 static ssize_t
regulator_num_users_show(struct device
*dev
,
468 struct device_attribute
*attr
, char *buf
)
470 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
471 return sprintf(buf
, "%d\n", rdev
->use_count
);
474 static ssize_t
regulator_type_show(struct device
*dev
,
475 struct device_attribute
*attr
, char *buf
)
477 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
479 switch (rdev
->desc
->type
) {
480 case REGULATOR_VOLTAGE
:
481 return sprintf(buf
, "voltage\n");
482 case REGULATOR_CURRENT
:
483 return sprintf(buf
, "current\n");
485 return sprintf(buf
, "unknown\n");
488 static ssize_t
regulator_suspend_mem_uV_show(struct device
*dev
,
489 struct device_attribute
*attr
, char *buf
)
491 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
493 return sprintf(buf
, "%d\n", rdev
->constraints
->state_mem
.uV
);
495 static DEVICE_ATTR(suspend_mem_microvolts
, 0444,
496 regulator_suspend_mem_uV_show
, NULL
);
498 static ssize_t
regulator_suspend_disk_uV_show(struct device
*dev
,
499 struct device_attribute
*attr
, char *buf
)
501 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
503 return sprintf(buf
, "%d\n", rdev
->constraints
->state_disk
.uV
);
505 static DEVICE_ATTR(suspend_disk_microvolts
, 0444,
506 regulator_suspend_disk_uV_show
, NULL
);
508 static ssize_t
regulator_suspend_standby_uV_show(struct device
*dev
,
509 struct device_attribute
*attr
, char *buf
)
511 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
513 return sprintf(buf
, "%d\n", rdev
->constraints
->state_standby
.uV
);
515 static DEVICE_ATTR(suspend_standby_microvolts
, 0444,
516 regulator_suspend_standby_uV_show
, NULL
);
518 static ssize_t
regulator_suspend_mem_mode_show(struct device
*dev
,
519 struct device_attribute
*attr
, char *buf
)
521 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
523 return regulator_print_opmode(buf
,
524 rdev
->constraints
->state_mem
.mode
);
526 static DEVICE_ATTR(suspend_mem_mode
, 0444,
527 regulator_suspend_mem_mode_show
, NULL
);
529 static ssize_t
regulator_suspend_disk_mode_show(struct device
*dev
,
530 struct device_attribute
*attr
, char *buf
)
532 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
534 return regulator_print_opmode(buf
,
535 rdev
->constraints
->state_disk
.mode
);
537 static DEVICE_ATTR(suspend_disk_mode
, 0444,
538 regulator_suspend_disk_mode_show
, NULL
);
540 static ssize_t
regulator_suspend_standby_mode_show(struct device
*dev
,
541 struct device_attribute
*attr
, char *buf
)
543 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
545 return regulator_print_opmode(buf
,
546 rdev
->constraints
->state_standby
.mode
);
548 static DEVICE_ATTR(suspend_standby_mode
, 0444,
549 regulator_suspend_standby_mode_show
, NULL
);
551 static ssize_t
regulator_suspend_mem_state_show(struct device
*dev
,
552 struct device_attribute
*attr
, char *buf
)
554 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
556 return regulator_print_state(buf
,
557 rdev
->constraints
->state_mem
.enabled
);
559 static DEVICE_ATTR(suspend_mem_state
, 0444,
560 regulator_suspend_mem_state_show
, NULL
);
562 static ssize_t
regulator_suspend_disk_state_show(struct device
*dev
,
563 struct device_attribute
*attr
, char *buf
)
565 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
567 return regulator_print_state(buf
,
568 rdev
->constraints
->state_disk
.enabled
);
570 static DEVICE_ATTR(suspend_disk_state
, 0444,
571 regulator_suspend_disk_state_show
, NULL
);
573 static ssize_t
regulator_suspend_standby_state_show(struct device
*dev
,
574 struct device_attribute
*attr
, char *buf
)
576 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
578 return regulator_print_state(buf
,
579 rdev
->constraints
->state_standby
.enabled
);
581 static DEVICE_ATTR(suspend_standby_state
, 0444,
582 regulator_suspend_standby_state_show
, NULL
);
586 * These are the only attributes are present for all regulators.
587 * Other attributes are a function of regulator functionality.
589 static struct device_attribute regulator_dev_attrs
[] = {
590 __ATTR(name
, 0444, regulator_name_show
, NULL
),
591 __ATTR(num_users
, 0444, regulator_num_users_show
, NULL
),
592 __ATTR(type
, 0444, regulator_type_show
, NULL
),
596 static void regulator_dev_release(struct device
*dev
)
598 struct regulator_dev
*rdev
= dev_get_drvdata(dev
);
602 static struct class regulator_class
= {
604 .dev_release
= regulator_dev_release
,
605 .dev_attrs
= regulator_dev_attrs
,
608 /* Calculate the new optimum regulator operating mode based on the new total
609 * consumer load. All locks held by caller */
610 static void drms_uA_update(struct regulator_dev
*rdev
)
612 struct regulator
*sibling
;
613 int current_uA
= 0, output_uV
, input_uV
, err
;
616 err
= regulator_check_drms(rdev
);
617 if (err
< 0 || !rdev
->desc
->ops
->get_optimum_mode
||
618 (!rdev
->desc
->ops
->get_voltage
&&
619 !rdev
->desc
->ops
->get_voltage_sel
) ||
620 !rdev
->desc
->ops
->set_mode
)
623 /* get output voltage */
624 output_uV
= _regulator_get_voltage(rdev
);
628 /* get input voltage */
631 input_uV
= regulator_get_voltage(rdev
->supply
);
633 input_uV
= rdev
->constraints
->input_uV
;
637 /* calc total requested load */
638 list_for_each_entry(sibling
, &rdev
->consumer_list
, list
)
639 current_uA
+= sibling
->uA_load
;
641 /* now get the optimum mode for our new total regulator load */
642 mode
= rdev
->desc
->ops
->get_optimum_mode(rdev
, input_uV
,
643 output_uV
, current_uA
);
645 /* check the new mode is allowed */
646 err
= regulator_mode_constrain(rdev
, &mode
);
648 rdev
->desc
->ops
->set_mode(rdev
, mode
);
651 static int suspend_set_state(struct regulator_dev
*rdev
,
652 struct regulator_state
*rstate
)
656 /* If we have no suspend mode configration don't set anything;
657 * only warn if the driver implements set_suspend_voltage or
658 * set_suspend_mode callback.
660 if (!rstate
->enabled
&& !rstate
->disabled
) {
661 if (rdev
->desc
->ops
->set_suspend_voltage
||
662 rdev
->desc
->ops
->set_suspend_mode
)
663 rdev_warn(rdev
, "No configuration\n");
667 if (rstate
->enabled
&& rstate
->disabled
) {
668 rdev_err(rdev
, "invalid configuration\n");
672 if (rstate
->enabled
&& rdev
->desc
->ops
->set_suspend_enable
)
673 ret
= rdev
->desc
->ops
->set_suspend_enable(rdev
);
674 else if (rstate
->disabled
&& rdev
->desc
->ops
->set_suspend_disable
)
675 ret
= rdev
->desc
->ops
->set_suspend_disable(rdev
);
676 else /* OK if set_suspend_enable or set_suspend_disable is NULL */
680 rdev_err(rdev
, "failed to enabled/disable\n");
684 if (rdev
->desc
->ops
->set_suspend_voltage
&& rstate
->uV
> 0) {
685 ret
= rdev
->desc
->ops
->set_suspend_voltage(rdev
, rstate
->uV
);
687 rdev_err(rdev
, "failed to set voltage\n");
692 if (rdev
->desc
->ops
->set_suspend_mode
&& rstate
->mode
> 0) {
693 ret
= rdev
->desc
->ops
->set_suspend_mode(rdev
, rstate
->mode
);
695 rdev_err(rdev
, "failed to set mode\n");
702 /* locks held by caller */
703 static int suspend_prepare(struct regulator_dev
*rdev
, suspend_state_t state
)
705 if (!rdev
->constraints
)
709 case PM_SUSPEND_STANDBY
:
710 return suspend_set_state(rdev
,
711 &rdev
->constraints
->state_standby
);
713 return suspend_set_state(rdev
,
714 &rdev
->constraints
->state_mem
);
716 return suspend_set_state(rdev
,
717 &rdev
->constraints
->state_disk
);
723 static void print_constraints(struct regulator_dev
*rdev
)
725 struct regulation_constraints
*constraints
= rdev
->constraints
;
730 if (constraints
->min_uV
&& constraints
->max_uV
) {
731 if (constraints
->min_uV
== constraints
->max_uV
)
732 count
+= sprintf(buf
+ count
, "%d mV ",
733 constraints
->min_uV
/ 1000);
735 count
+= sprintf(buf
+ count
, "%d <--> %d mV ",
736 constraints
->min_uV
/ 1000,
737 constraints
->max_uV
/ 1000);
740 if (!constraints
->min_uV
||
741 constraints
->min_uV
!= constraints
->max_uV
) {
742 ret
= _regulator_get_voltage(rdev
);
744 count
+= sprintf(buf
+ count
, "at %d mV ", ret
/ 1000);
747 if (constraints
->uV_offset
)
748 count
+= sprintf(buf
, "%dmV offset ",
749 constraints
->uV_offset
/ 1000);
751 if (constraints
->min_uA
&& constraints
->max_uA
) {
752 if (constraints
->min_uA
== constraints
->max_uA
)
753 count
+= sprintf(buf
+ count
, "%d mA ",
754 constraints
->min_uA
/ 1000);
756 count
+= sprintf(buf
+ count
, "%d <--> %d mA ",
757 constraints
->min_uA
/ 1000,
758 constraints
->max_uA
/ 1000);
761 if (!constraints
->min_uA
||
762 constraints
->min_uA
!= constraints
->max_uA
) {
763 ret
= _regulator_get_current_limit(rdev
);
765 count
+= sprintf(buf
+ count
, "at %d mA ", ret
/ 1000);
768 if (constraints
->valid_modes_mask
& REGULATOR_MODE_FAST
)
769 count
+= sprintf(buf
+ count
, "fast ");
770 if (constraints
->valid_modes_mask
& REGULATOR_MODE_NORMAL
)
771 count
+= sprintf(buf
+ count
, "normal ");
772 if (constraints
->valid_modes_mask
& REGULATOR_MODE_IDLE
)
773 count
+= sprintf(buf
+ count
, "idle ");
774 if (constraints
->valid_modes_mask
& REGULATOR_MODE_STANDBY
)
775 count
+= sprintf(buf
+ count
, "standby");
777 rdev_info(rdev
, "%s\n", buf
);
779 if ((constraints
->min_uV
!= constraints
->max_uV
) &&
780 !(constraints
->valid_ops_mask
& REGULATOR_CHANGE_VOLTAGE
))
782 "Voltage range but no REGULATOR_CHANGE_VOLTAGE\n");
785 static int machine_constraints_voltage(struct regulator_dev
*rdev
,
786 struct regulation_constraints
*constraints
)
788 struct regulator_ops
*ops
= rdev
->desc
->ops
;
791 /* do we need to apply the constraint voltage */
792 if (rdev
->constraints
->apply_uV
&&
793 rdev
->constraints
->min_uV
== rdev
->constraints
->max_uV
) {
794 ret
= _regulator_do_set_voltage(rdev
,
795 rdev
->constraints
->min_uV
,
796 rdev
->constraints
->max_uV
);
798 rdev_err(rdev
, "failed to apply %duV constraint\n",
799 rdev
->constraints
->min_uV
);
804 /* constrain machine-level voltage specs to fit
805 * the actual range supported by this regulator.
807 if (ops
->list_voltage
&& rdev
->desc
->n_voltages
) {
808 int count
= rdev
->desc
->n_voltages
;
810 int min_uV
= INT_MAX
;
811 int max_uV
= INT_MIN
;
812 int cmin
= constraints
->min_uV
;
813 int cmax
= constraints
->max_uV
;
815 /* it's safe to autoconfigure fixed-voltage supplies
816 and the constraints are used by list_voltage. */
817 if (count
== 1 && !cmin
) {
820 constraints
->min_uV
= cmin
;
821 constraints
->max_uV
= cmax
;
824 /* voltage constraints are optional */
825 if ((cmin
== 0) && (cmax
== 0))
828 /* else require explicit machine-level constraints */
829 if (cmin
<= 0 || cmax
<= 0 || cmax
< cmin
) {
830 rdev_err(rdev
, "invalid voltage constraints\n");
834 /* initial: [cmin..cmax] valid, [min_uV..max_uV] not */
835 for (i
= 0; i
< count
; i
++) {
838 value
= ops
->list_voltage(rdev
, i
);
842 /* maybe adjust [min_uV..max_uV] */
843 if (value
>= cmin
&& value
< min_uV
)
845 if (value
<= cmax
&& value
> max_uV
)
849 /* final: [min_uV..max_uV] valid iff constraints valid */
850 if (max_uV
< min_uV
) {
851 rdev_err(rdev
, "unsupportable voltage constraints\n");
855 /* use regulator's subset of machine constraints */
856 if (constraints
->min_uV
< min_uV
) {
857 rdev_dbg(rdev
, "override min_uV, %d -> %d\n",
858 constraints
->min_uV
, min_uV
);
859 constraints
->min_uV
= min_uV
;
861 if (constraints
->max_uV
> max_uV
) {
862 rdev_dbg(rdev
, "override max_uV, %d -> %d\n",
863 constraints
->max_uV
, max_uV
);
864 constraints
->max_uV
= max_uV
;
872 * set_machine_constraints - sets regulator constraints
873 * @rdev: regulator source
874 * @constraints: constraints to apply
876 * Allows platform initialisation code to define and constrain
877 * regulator circuits e.g. valid voltage/current ranges, etc. NOTE:
878 * Constraints *must* be set by platform code in order for some
879 * regulator operations to proceed i.e. set_voltage, set_current_limit,
882 static int set_machine_constraints(struct regulator_dev
*rdev
,
883 const struct regulation_constraints
*constraints
)
886 struct regulator_ops
*ops
= rdev
->desc
->ops
;
889 rdev
->constraints
= kmemdup(constraints
, sizeof(*constraints
),
892 rdev
->constraints
= kzalloc(sizeof(*constraints
),
894 if (!rdev
->constraints
)
897 ret
= machine_constraints_voltage(rdev
, rdev
->constraints
);
901 /* do we need to setup our suspend state */
902 if (rdev
->constraints
->initial_state
) {
903 ret
= suspend_prepare(rdev
, rdev
->constraints
->initial_state
);
905 rdev_err(rdev
, "failed to set suspend state\n");
910 if (rdev
->constraints
->initial_mode
) {
911 if (!ops
->set_mode
) {
912 rdev_err(rdev
, "no set_mode operation\n");
917 ret
= ops
->set_mode(rdev
, rdev
->constraints
->initial_mode
);
919 rdev_err(rdev
, "failed to set initial mode: %d\n", ret
);
924 /* If the constraints say the regulator should be on at this point
925 * and we have control then make sure it is enabled.
927 if ((rdev
->constraints
->always_on
|| rdev
->constraints
->boot_on
) &&
929 ret
= ops
->enable(rdev
);
931 rdev_err(rdev
, "failed to enable\n");
936 print_constraints(rdev
);
939 kfree(rdev
->constraints
);
940 rdev
->constraints
= NULL
;
945 * set_supply - set regulator supply regulator
946 * @rdev: regulator name
947 * @supply_rdev: supply regulator name
949 * Called by platform initialisation code to set the supply regulator for this
950 * regulator. This ensures that a regulators supply will also be enabled by the
951 * core if it's child is enabled.
953 static int set_supply(struct regulator_dev
*rdev
,
954 struct regulator_dev
*supply_rdev
)
958 rdev_info(rdev
, "supplied by %s\n", rdev_get_name(supply_rdev
));
960 rdev
->supply
= create_regulator(supply_rdev
, &rdev
->dev
, "SUPPLY");
961 if (rdev
->supply
== NULL
) {
970 * set_consumer_device_supply - Bind a regulator to a symbolic supply
971 * @rdev: regulator source
972 * @consumer_dev_name: dev_name() string for device supply applies to
973 * @supply: symbolic name for supply
975 * Allows platform initialisation code to map physical regulator
976 * sources to symbolic names for supplies for use by devices. Devices
977 * should use these symbolic names to request regulators, avoiding the
978 * need to provide board-specific regulator names as platform data.
980 static int set_consumer_device_supply(struct regulator_dev
*rdev
,
981 const char *consumer_dev_name
,
984 struct regulator_map
*node
;
990 if (consumer_dev_name
!= NULL
)
995 list_for_each_entry(node
, ®ulator_map_list
, list
) {
996 if (node
->dev_name
&& consumer_dev_name
) {
997 if (strcmp(node
->dev_name
, consumer_dev_name
) != 0)
999 } else if (node
->dev_name
|| consumer_dev_name
) {
1003 if (strcmp(node
->supply
, supply
) != 0)
1006 pr_debug("%s: %s/%s is '%s' supply; fail %s/%s\n",
1008 dev_name(&node
->regulator
->dev
),
1009 node
->regulator
->desc
->name
,
1011 dev_name(&rdev
->dev
), rdev_get_name(rdev
));
1015 node
= kzalloc(sizeof(struct regulator_map
), GFP_KERNEL
);
1019 node
->regulator
= rdev
;
1020 node
->supply
= supply
;
1023 node
->dev_name
= kstrdup(consumer_dev_name
, GFP_KERNEL
);
1024 if (node
->dev_name
== NULL
) {
1030 list_add(&node
->list
, ®ulator_map_list
);
1034 static void unset_regulator_supplies(struct regulator_dev
*rdev
)
1036 struct regulator_map
*node
, *n
;
1038 list_for_each_entry_safe(node
, n
, ®ulator_map_list
, list
) {
1039 if (rdev
== node
->regulator
) {
1040 list_del(&node
->list
);
1041 kfree(node
->dev_name
);
1047 #define REG_STR_SIZE 64
1049 static struct regulator
*create_regulator(struct regulator_dev
*rdev
,
1051 const char *supply_name
)
1053 struct regulator
*regulator
;
1054 char buf
[REG_STR_SIZE
];
1057 regulator
= kzalloc(sizeof(*regulator
), GFP_KERNEL
);
1058 if (regulator
== NULL
)
1061 mutex_lock(&rdev
->mutex
);
1062 regulator
->rdev
= rdev
;
1063 list_add(®ulator
->list
, &rdev
->consumer_list
);
1066 regulator
->dev
= dev
;
1068 /* Add a link to the device sysfs entry */
1069 size
= scnprintf(buf
, REG_STR_SIZE
, "%s-%s",
1070 dev
->kobj
.name
, supply_name
);
1071 if (size
>= REG_STR_SIZE
)
1074 regulator
->supply_name
= kstrdup(buf
, GFP_KERNEL
);
1075 if (regulator
->supply_name
== NULL
)
1078 err
= sysfs_create_link(&rdev
->dev
.kobj
, &dev
->kobj
,
1081 rdev_warn(rdev
, "could not add device link %s err %d\n",
1082 dev
->kobj
.name
, err
);
1086 regulator
->supply_name
= kstrdup(supply_name
, GFP_KERNEL
);
1087 if (regulator
->supply_name
== NULL
)
1091 regulator
->debugfs
= debugfs_create_dir(regulator
->supply_name
,
1093 if (!regulator
->debugfs
) {
1094 rdev_warn(rdev
, "Failed to create debugfs directory\n");
1096 debugfs_create_u32("uA_load", 0444, regulator
->debugfs
,
1097 ®ulator
->uA_load
);
1098 debugfs_create_u32("min_uV", 0444, regulator
->debugfs
,
1099 ®ulator
->min_uV
);
1100 debugfs_create_u32("max_uV", 0444, regulator
->debugfs
,
1101 ®ulator
->max_uV
);
1105 * Check now if the regulator is an always on regulator - if
1106 * it is then we don't need to do nearly so much work for
1107 * enable/disable calls.
1109 if (!_regulator_can_change_status(rdev
) &&
1110 _regulator_is_enabled(rdev
))
1111 regulator
->always_on
= true;
1113 mutex_unlock(&rdev
->mutex
);
1116 list_del(®ulator
->list
);
1118 mutex_unlock(&rdev
->mutex
);
1122 static int _regulator_get_enable_time(struct regulator_dev
*rdev
)
1124 if (!rdev
->desc
->ops
->enable_time
)
1126 return rdev
->desc
->ops
->enable_time(rdev
);
1129 static struct regulator_dev
*regulator_dev_lookup(struct device
*dev
,
1133 struct regulator_dev
*r
;
1134 struct device_node
*node
;
1135 struct regulator_map
*map
;
1136 const char *devname
= NULL
;
1138 /* first do a dt based lookup */
1139 if (dev
&& dev
->of_node
) {
1140 node
= of_get_regulator(dev
, supply
);
1142 list_for_each_entry(r
, ®ulator_list
, list
)
1143 if (r
->dev
.parent
&&
1144 node
== r
->dev
.of_node
)
1148 * If we couldn't even get the node then it's
1149 * not just that the device didn't register
1150 * yet, there's no node and we'll never
1157 /* if not found, try doing it non-dt way */
1159 devname
= dev_name(dev
);
1161 list_for_each_entry(r
, ®ulator_list
, list
)
1162 if (strcmp(rdev_get_name(r
), supply
) == 0)
1165 list_for_each_entry(map
, ®ulator_map_list
, list
) {
1166 /* If the mapping has a device set up it must match */
1167 if (map
->dev_name
&&
1168 (!devname
|| strcmp(map
->dev_name
, devname
)))
1171 if (strcmp(map
->supply
, supply
) == 0)
1172 return map
->regulator
;
1179 /* Internal regulator request function */
1180 static struct regulator
*_regulator_get(struct device
*dev
, const char *id
,
1183 struct regulator_dev
*rdev
;
1184 struct regulator
*regulator
= ERR_PTR(-EPROBE_DEFER
);
1185 const char *devname
= NULL
;
1189 pr_err("get() with no identifier\n");
1194 devname
= dev_name(dev
);
1196 mutex_lock(®ulator_list_mutex
);
1198 rdev
= regulator_dev_lookup(dev
, id
, &ret
);
1202 if (board_wants_dummy_regulator
) {
1203 rdev
= dummy_regulator_rdev
;
1207 #ifdef CONFIG_REGULATOR_DUMMY
1209 devname
= "deviceless";
1211 /* If the board didn't flag that it was fully constrained then
1212 * substitute in a dummy regulator so consumers can continue.
1214 if (!has_full_constraints
) {
1215 pr_warn("%s supply %s not found, using dummy regulator\n",
1217 rdev
= dummy_regulator_rdev
;
1222 mutex_unlock(®ulator_list_mutex
);
1226 if (rdev
->exclusive
) {
1227 regulator
= ERR_PTR(-EPERM
);
1231 if (exclusive
&& rdev
->open_count
) {
1232 regulator
= ERR_PTR(-EBUSY
);
1236 if (!try_module_get(rdev
->owner
))
1239 regulator
= create_regulator(rdev
, dev
, id
);
1240 if (regulator
== NULL
) {
1241 regulator
= ERR_PTR(-ENOMEM
);
1242 module_put(rdev
->owner
);
1248 rdev
->exclusive
= 1;
1250 ret
= _regulator_is_enabled(rdev
);
1252 rdev
->use_count
= 1;
1254 rdev
->use_count
= 0;
1258 mutex_unlock(®ulator_list_mutex
);
1264 * regulator_get - lookup and obtain a reference to a regulator.
1265 * @dev: device for regulator "consumer"
1266 * @id: Supply name or regulator ID.
1268 * Returns a struct regulator corresponding to the regulator producer,
1269 * or IS_ERR() condition containing errno.
1271 * Use of supply names configured via regulator_set_device_supply() is
1272 * strongly encouraged. It is recommended that the supply name used
1273 * should match the name used for the supply and/or the relevant
1274 * device pins in the datasheet.
1276 struct regulator
*regulator_get(struct device
*dev
, const char *id
)
1278 return _regulator_get(dev
, id
, 0);
1280 EXPORT_SYMBOL_GPL(regulator_get
);
1282 static void devm_regulator_release(struct device
*dev
, void *res
)
1284 regulator_put(*(struct regulator
**)res
);
1288 * devm_regulator_get - Resource managed regulator_get()
1289 * @dev: device for regulator "consumer"
1290 * @id: Supply name or regulator ID.
1292 * Managed regulator_get(). Regulators returned from this function are
1293 * automatically regulator_put() on driver detach. See regulator_get() for more
1296 struct regulator
*devm_regulator_get(struct device
*dev
, const char *id
)
1298 struct regulator
**ptr
, *regulator
;
1300 ptr
= devres_alloc(devm_regulator_release
, sizeof(*ptr
), GFP_KERNEL
);
1302 return ERR_PTR(-ENOMEM
);
1304 regulator
= regulator_get(dev
, id
);
1305 if (!IS_ERR(regulator
)) {
1307 devres_add(dev
, ptr
);
1314 EXPORT_SYMBOL_GPL(devm_regulator_get
);
1317 * regulator_get_exclusive - obtain exclusive access to a regulator.
1318 * @dev: device for regulator "consumer"
1319 * @id: Supply name or regulator ID.
1321 * Returns a struct regulator corresponding to the regulator producer,
1322 * or IS_ERR() condition containing errno. Other consumers will be
1323 * unable to obtain this reference is held and the use count for the
1324 * regulator will be initialised to reflect the current state of the
1327 * This is intended for use by consumers which cannot tolerate shared
1328 * use of the regulator such as those which need to force the
1329 * regulator off for correct operation of the hardware they are
1332 * Use of supply names configured via regulator_set_device_supply() is
1333 * strongly encouraged. It is recommended that the supply name used
1334 * should match the name used for the supply and/or the relevant
1335 * device pins in the datasheet.
1337 struct regulator
*regulator_get_exclusive(struct device
*dev
, const char *id
)
1339 return _regulator_get(dev
, id
, 1);
1341 EXPORT_SYMBOL_GPL(regulator_get_exclusive
);
1344 * regulator_put - "free" the regulator source
1345 * @regulator: regulator source
1347 * Note: drivers must ensure that all regulator_enable calls made on this
1348 * regulator source are balanced by regulator_disable calls prior to calling
1351 void regulator_put(struct regulator
*regulator
)
1353 struct regulator_dev
*rdev
;
1355 if (regulator
== NULL
|| IS_ERR(regulator
))
1358 mutex_lock(®ulator_list_mutex
);
1359 rdev
= regulator
->rdev
;
1361 debugfs_remove_recursive(regulator
->debugfs
);
1363 /* remove any sysfs entries */
1365 sysfs_remove_link(&rdev
->dev
.kobj
, regulator
->supply_name
);
1366 kfree(regulator
->supply_name
);
1367 list_del(®ulator
->list
);
1371 rdev
->exclusive
= 0;
1373 module_put(rdev
->owner
);
1374 mutex_unlock(®ulator_list_mutex
);
1376 EXPORT_SYMBOL_GPL(regulator_put
);
1378 static int devm_regulator_match(struct device
*dev
, void *res
, void *data
)
1380 struct regulator
**r
= res
;
1389 * devm_regulator_put - Resource managed regulator_put()
1390 * @regulator: regulator to free
1392 * Deallocate a regulator allocated with devm_regulator_get(). Normally
1393 * this function will not need to be called and the resource management
1394 * code will ensure that the resource is freed.
1396 void devm_regulator_put(struct regulator
*regulator
)
1400 rc
= devres_release(regulator
->dev
, devm_regulator_release
,
1401 devm_regulator_match
, regulator
);
1405 EXPORT_SYMBOL_GPL(devm_regulator_put
);
1407 /* locks held by regulator_enable() */
1408 static int _regulator_enable(struct regulator_dev
*rdev
)
1412 /* check voltage and requested load before enabling */
1413 if (rdev
->constraints
&&
1414 (rdev
->constraints
->valid_ops_mask
& REGULATOR_CHANGE_DRMS
))
1415 drms_uA_update(rdev
);
1417 if (rdev
->use_count
== 0) {
1418 /* The regulator may on if it's not switchable or left on */
1419 ret
= _regulator_is_enabled(rdev
);
1420 if (ret
== -EINVAL
|| ret
== 0) {
1421 if (!_regulator_can_change_status(rdev
))
1424 if (!rdev
->desc
->ops
->enable
)
1427 /* Query before enabling in case configuration
1429 ret
= _regulator_get_enable_time(rdev
);
1433 rdev_warn(rdev
, "enable_time() failed: %d\n",
1438 trace_regulator_enable(rdev_get_name(rdev
));
1440 /* Allow the regulator to ramp; it would be useful
1441 * to extend this for bulk operations so that the
1442 * regulators can ramp together. */
1443 ret
= rdev
->desc
->ops
->enable(rdev
);
1447 trace_regulator_enable_delay(rdev_get_name(rdev
));
1449 if (delay
>= 1000) {
1450 mdelay(delay
/ 1000);
1451 udelay(delay
% 1000);
1456 trace_regulator_enable_complete(rdev_get_name(rdev
));
1458 } else if (ret
< 0) {
1459 rdev_err(rdev
, "is_enabled() failed: %d\n", ret
);
1462 /* Fallthrough on positive return values - already enabled */
1471 * regulator_enable - enable regulator output
1472 * @regulator: regulator source
1474 * Request that the regulator be enabled with the regulator output at
1475 * the predefined voltage or current value. Calls to regulator_enable()
1476 * must be balanced with calls to regulator_disable().
1478 * NOTE: the output value can be set by other drivers, boot loader or may be
1479 * hardwired in the regulator.
1481 int regulator_enable(struct regulator
*regulator
)
1483 struct regulator_dev
*rdev
= regulator
->rdev
;
1486 if (regulator
->always_on
)
1490 ret
= regulator_enable(rdev
->supply
);
1495 mutex_lock(&rdev
->mutex
);
1496 ret
= _regulator_enable(rdev
);
1497 mutex_unlock(&rdev
->mutex
);
1499 if (ret
!= 0 && rdev
->supply
)
1500 regulator_disable(rdev
->supply
);
1504 EXPORT_SYMBOL_GPL(regulator_enable
);
1506 /* locks held by regulator_disable() */
1507 static int _regulator_disable(struct regulator_dev
*rdev
)
1511 if (WARN(rdev
->use_count
<= 0,
1512 "unbalanced disables for %s\n", rdev_get_name(rdev
)))
1515 /* are we the last user and permitted to disable ? */
1516 if (rdev
->use_count
== 1 &&
1517 (rdev
->constraints
&& !rdev
->constraints
->always_on
)) {
1519 /* we are last user */
1520 if (_regulator_can_change_status(rdev
) &&
1521 rdev
->desc
->ops
->disable
) {
1522 trace_regulator_disable(rdev_get_name(rdev
));
1524 ret
= rdev
->desc
->ops
->disable(rdev
);
1526 rdev_err(rdev
, "failed to disable\n");
1530 trace_regulator_disable_complete(rdev_get_name(rdev
));
1532 _notifier_call_chain(rdev
, REGULATOR_EVENT_DISABLE
,
1536 rdev
->use_count
= 0;
1537 } else if (rdev
->use_count
> 1) {
1539 if (rdev
->constraints
&&
1540 (rdev
->constraints
->valid_ops_mask
&
1541 REGULATOR_CHANGE_DRMS
))
1542 drms_uA_update(rdev
);
1551 * regulator_disable - disable regulator output
1552 * @regulator: regulator source
1554 * Disable the regulator output voltage or current. Calls to
1555 * regulator_enable() must be balanced with calls to
1556 * regulator_disable().
1558 * NOTE: this will only disable the regulator output if no other consumer
1559 * devices have it enabled, the regulator device supports disabling and
1560 * machine constraints permit this operation.
1562 int regulator_disable(struct regulator
*regulator
)
1564 struct regulator_dev
*rdev
= regulator
->rdev
;
1567 if (regulator
->always_on
)
1570 mutex_lock(&rdev
->mutex
);
1571 ret
= _regulator_disable(rdev
);
1572 mutex_unlock(&rdev
->mutex
);
1574 if (ret
== 0 && rdev
->supply
)
1575 regulator_disable(rdev
->supply
);
1579 EXPORT_SYMBOL_GPL(regulator_disable
);
1581 /* locks held by regulator_force_disable() */
1582 static int _regulator_force_disable(struct regulator_dev
*rdev
)
1587 if (rdev
->desc
->ops
->disable
) {
1588 /* ah well, who wants to live forever... */
1589 ret
= rdev
->desc
->ops
->disable(rdev
);
1591 rdev_err(rdev
, "failed to force disable\n");
1594 /* notify other consumers that power has been forced off */
1595 _notifier_call_chain(rdev
, REGULATOR_EVENT_FORCE_DISABLE
|
1596 REGULATOR_EVENT_DISABLE
, NULL
);
1603 * regulator_force_disable - force disable regulator output
1604 * @regulator: regulator source
1606 * Forcibly disable the regulator output voltage or current.
1607 * NOTE: this *will* disable the regulator output even if other consumer
1608 * devices have it enabled. This should be used for situations when device
1609 * damage will likely occur if the regulator is not disabled (e.g. over temp).
1611 int regulator_force_disable(struct regulator
*regulator
)
1613 struct regulator_dev
*rdev
= regulator
->rdev
;
1616 mutex_lock(&rdev
->mutex
);
1617 regulator
->uA_load
= 0;
1618 ret
= _regulator_force_disable(regulator
->rdev
);
1619 mutex_unlock(&rdev
->mutex
);
1622 while (rdev
->open_count
--)
1623 regulator_disable(rdev
->supply
);
1627 EXPORT_SYMBOL_GPL(regulator_force_disable
);
1629 static void regulator_disable_work(struct work_struct
*work
)
1631 struct regulator_dev
*rdev
= container_of(work
, struct regulator_dev
,
1635 mutex_lock(&rdev
->mutex
);
1637 BUG_ON(!rdev
->deferred_disables
);
1639 count
= rdev
->deferred_disables
;
1640 rdev
->deferred_disables
= 0;
1642 for (i
= 0; i
< count
; i
++) {
1643 ret
= _regulator_disable(rdev
);
1645 rdev_err(rdev
, "Deferred disable failed: %d\n", ret
);
1648 mutex_unlock(&rdev
->mutex
);
1651 for (i
= 0; i
< count
; i
++) {
1652 ret
= regulator_disable(rdev
->supply
);
1655 "Supply disable failed: %d\n", ret
);
1662 * regulator_disable_deferred - disable regulator output with delay
1663 * @regulator: regulator source
1664 * @ms: miliseconds until the regulator is disabled
1666 * Execute regulator_disable() on the regulator after a delay. This
1667 * is intended for use with devices that require some time to quiesce.
1669 * NOTE: this will only disable the regulator output if no other consumer
1670 * devices have it enabled, the regulator device supports disabling and
1671 * machine constraints permit this operation.
1673 int regulator_disable_deferred(struct regulator
*regulator
, int ms
)
1675 struct regulator_dev
*rdev
= regulator
->rdev
;
1678 if (regulator
->always_on
)
1681 mutex_lock(&rdev
->mutex
);
1682 rdev
->deferred_disables
++;
1683 mutex_unlock(&rdev
->mutex
);
1685 ret
= schedule_delayed_work(&rdev
->disable_work
,
1686 msecs_to_jiffies(ms
));
1692 EXPORT_SYMBOL_GPL(regulator_disable_deferred
);
1695 * regulator_is_enabled_regmap - standard is_enabled() for regmap users
1697 * @rdev: regulator to operate on
1699 * Regulators that use regmap for their register I/O can set the
1700 * enable_reg and enable_mask fields in their descriptor and then use
1701 * this as their is_enabled operation, saving some code.
1703 int regulator_is_enabled_regmap(struct regulator_dev
*rdev
)
1708 ret
= regmap_read(rdev
->regmap
, rdev
->desc
->enable_reg
, &val
);
1712 return (val
& rdev
->desc
->enable_mask
) != 0;
1714 EXPORT_SYMBOL_GPL(regulator_is_enabled_regmap
);
1717 * regulator_enable_regmap - standard enable() for regmap users
1719 * @rdev: regulator to operate on
1721 * Regulators that use regmap for their register I/O can set the
1722 * enable_reg and enable_mask fields in their descriptor and then use
1723 * this as their enable() operation, saving some code.
1725 int regulator_enable_regmap(struct regulator_dev
*rdev
)
1727 return regmap_update_bits(rdev
->regmap
, rdev
->desc
->enable_reg
,
1728 rdev
->desc
->enable_mask
,
1729 rdev
->desc
->enable_mask
);
1731 EXPORT_SYMBOL_GPL(regulator_enable_regmap
);
1734 * regulator_disable_regmap - standard disable() for regmap users
1736 * @rdev: regulator to operate on
1738 * Regulators that use regmap for their register I/O can set the
1739 * enable_reg and enable_mask fields in their descriptor and then use
1740 * this as their disable() operation, saving some code.
1742 int regulator_disable_regmap(struct regulator_dev
*rdev
)
1744 return regmap_update_bits(rdev
->regmap
, rdev
->desc
->enable_reg
,
1745 rdev
->desc
->enable_mask
, 0);
1747 EXPORT_SYMBOL_GPL(regulator_disable_regmap
);
1749 static int _regulator_is_enabled(struct regulator_dev
*rdev
)
1751 /* If we don't know then assume that the regulator is always on */
1752 if (!rdev
->desc
->ops
->is_enabled
)
1755 return rdev
->desc
->ops
->is_enabled(rdev
);
1759 * regulator_is_enabled - is the regulator output enabled
1760 * @regulator: regulator source
1762 * Returns positive if the regulator driver backing the source/client
1763 * has requested that the device be enabled, zero if it hasn't, else a
1764 * negative errno code.
1766 * Note that the device backing this regulator handle can have multiple
1767 * users, so it might be enabled even if regulator_enable() was never
1768 * called for this particular source.
1770 int regulator_is_enabled(struct regulator
*regulator
)
1774 if (regulator
->always_on
)
1777 mutex_lock(®ulator
->rdev
->mutex
);
1778 ret
= _regulator_is_enabled(regulator
->rdev
);
1779 mutex_unlock(®ulator
->rdev
->mutex
);
1783 EXPORT_SYMBOL_GPL(regulator_is_enabled
);
1786 * regulator_count_voltages - count regulator_list_voltage() selectors
1787 * @regulator: regulator source
1789 * Returns number of selectors, or negative errno. Selectors are
1790 * numbered starting at zero, and typically correspond to bitfields
1791 * in hardware registers.
1793 int regulator_count_voltages(struct regulator
*regulator
)
1795 struct regulator_dev
*rdev
= regulator
->rdev
;
1797 return rdev
->desc
->n_voltages
? : -EINVAL
;
1799 EXPORT_SYMBOL_GPL(regulator_count_voltages
);
1802 * regulator_list_voltage_linear - List voltages with simple calculation
1804 * @rdev: Regulator device
1805 * @selector: Selector to convert into a voltage
1807 * Regulators with a simple linear mapping between voltages and
1808 * selectors can set min_uV and uV_step in the regulator descriptor
1809 * and then use this function as their list_voltage() operation,
1811 int regulator_list_voltage_linear(struct regulator_dev
*rdev
,
1812 unsigned int selector
)
1814 if (selector
>= rdev
->desc
->n_voltages
)
1817 return rdev
->desc
->min_uV
+ (rdev
->desc
->uV_step
* selector
);
1819 EXPORT_SYMBOL_GPL(regulator_list_voltage_linear
);
1822 * regulator_list_voltage_table - List voltages with table based mapping
1824 * @rdev: Regulator device
1825 * @selector: Selector to convert into a voltage
1827 * Regulators with table based mapping between voltages and
1828 * selectors can set volt_table in the regulator descriptor
1829 * and then use this function as their list_voltage() operation.
1831 int regulator_list_voltage_table(struct regulator_dev
*rdev
,
1832 unsigned int selector
)
1834 if (!rdev
->desc
->volt_table
) {
1835 BUG_ON(!rdev
->desc
->volt_table
);
1839 if (selector
>= rdev
->desc
->n_voltages
)
1842 return rdev
->desc
->volt_table
[selector
];
1844 EXPORT_SYMBOL_GPL(regulator_list_voltage_table
);
1847 * regulator_list_voltage - enumerate supported voltages
1848 * @regulator: regulator source
1849 * @selector: identify voltage to list
1850 * Context: can sleep
1852 * Returns a voltage that can be passed to @regulator_set_voltage(),
1853 * zero if this selector code can't be used on this system, or a
1856 int regulator_list_voltage(struct regulator
*regulator
, unsigned selector
)
1858 struct regulator_dev
*rdev
= regulator
->rdev
;
1859 struct regulator_ops
*ops
= rdev
->desc
->ops
;
1862 if (!ops
->list_voltage
|| selector
>= rdev
->desc
->n_voltages
)
1865 mutex_lock(&rdev
->mutex
);
1866 ret
= ops
->list_voltage(rdev
, selector
);
1867 mutex_unlock(&rdev
->mutex
);
1870 if (ret
< rdev
->constraints
->min_uV
)
1872 else if (ret
> rdev
->constraints
->max_uV
)
1878 EXPORT_SYMBOL_GPL(regulator_list_voltage
);
1881 * regulator_is_supported_voltage - check if a voltage range can be supported
1883 * @regulator: Regulator to check.
1884 * @min_uV: Minimum required voltage in uV.
1885 * @max_uV: Maximum required voltage in uV.
1887 * Returns a boolean or a negative error code.
1889 int regulator_is_supported_voltage(struct regulator
*regulator
,
1890 int min_uV
, int max_uV
)
1892 struct regulator_dev
*rdev
= regulator
->rdev
;
1893 int i
, voltages
, ret
;
1895 /* If we can't change voltage check the current voltage */
1896 if (!(rdev
->constraints
->valid_ops_mask
& REGULATOR_CHANGE_VOLTAGE
)) {
1897 ret
= regulator_get_voltage(regulator
);
1899 return (min_uV
>= ret
&& ret
<= max_uV
);
1904 ret
= regulator_count_voltages(regulator
);
1909 for (i
= 0; i
< voltages
; i
++) {
1910 ret
= regulator_list_voltage(regulator
, i
);
1912 if (ret
>= min_uV
&& ret
<= max_uV
)
1918 EXPORT_SYMBOL_GPL(regulator_is_supported_voltage
);
1921 * regulator_get_voltage_sel_regmap - standard get_voltage_sel for regmap users
1923 * @rdev: regulator to operate on
1925 * Regulators that use regmap for their register I/O can set the
1926 * vsel_reg and vsel_mask fields in their descriptor and then use this
1927 * as their get_voltage_vsel operation, saving some code.
1929 int regulator_get_voltage_sel_regmap(struct regulator_dev
*rdev
)
1934 ret
= regmap_read(rdev
->regmap
, rdev
->desc
->vsel_reg
, &val
);
1938 val
&= rdev
->desc
->vsel_mask
;
1939 val
>>= ffs(rdev
->desc
->vsel_mask
) - 1;
1943 EXPORT_SYMBOL_GPL(regulator_get_voltage_sel_regmap
);
1946 * regulator_set_voltage_sel_regmap - standard set_voltage_sel for regmap users
1948 * @rdev: regulator to operate on
1949 * @sel: Selector to set
1951 * Regulators that use regmap for their register I/O can set the
1952 * vsel_reg and vsel_mask fields in their descriptor and then use this
1953 * as their set_voltage_vsel operation, saving some code.
1955 int regulator_set_voltage_sel_regmap(struct regulator_dev
*rdev
, unsigned sel
)
1957 sel
<<= ffs(rdev
->desc
->vsel_mask
) - 1;
1959 return regmap_update_bits(rdev
->regmap
, rdev
->desc
->vsel_reg
,
1960 rdev
->desc
->vsel_mask
, sel
);
1962 EXPORT_SYMBOL_GPL(regulator_set_voltage_sel_regmap
);
1965 * regulator_map_voltage_iterate - map_voltage() based on list_voltage()
1967 * @rdev: Regulator to operate on
1968 * @min_uV: Lower bound for voltage
1969 * @max_uV: Upper bound for voltage
1971 * Drivers implementing set_voltage_sel() and list_voltage() can use
1972 * this as their map_voltage() operation. It will find a suitable
1973 * voltage by calling list_voltage() until it gets something in bounds
1974 * for the requested voltages.
1976 int regulator_map_voltage_iterate(struct regulator_dev
*rdev
,
1977 int min_uV
, int max_uV
)
1979 int best_val
= INT_MAX
;
1983 /* Find the smallest voltage that falls within the specified
1986 for (i
= 0; i
< rdev
->desc
->n_voltages
; i
++) {
1987 ret
= rdev
->desc
->ops
->list_voltage(rdev
, i
);
1991 if (ret
< best_val
&& ret
>= min_uV
&& ret
<= max_uV
) {
1997 if (best_val
!= INT_MAX
)
2002 EXPORT_SYMBOL_GPL(regulator_map_voltage_iterate
);
2005 * regulator_map_voltage_linear - map_voltage() for simple linear mappings
2007 * @rdev: Regulator to operate on
2008 * @min_uV: Lower bound for voltage
2009 * @max_uV: Upper bound for voltage
2011 * Drivers providing min_uV and uV_step in their regulator_desc can
2012 * use this as their map_voltage() operation.
2014 int regulator_map_voltage_linear(struct regulator_dev
*rdev
,
2015 int min_uV
, int max_uV
)
2019 if (!rdev
->desc
->uV_step
) {
2020 BUG_ON(!rdev
->desc
->uV_step
);
2024 ret
= DIV_ROUND_UP(min_uV
- rdev
->desc
->min_uV
, rdev
->desc
->uV_step
);
2028 /* Map back into a voltage to verify we're still in bounds */
2029 voltage
= rdev
->desc
->ops
->list_voltage(rdev
, ret
);
2030 if (voltage
< min_uV
|| voltage
> max_uV
)
2035 EXPORT_SYMBOL_GPL(regulator_map_voltage_linear
);
2037 static int _regulator_do_set_voltage(struct regulator_dev
*rdev
,
2038 int min_uV
, int max_uV
)
2043 unsigned int selector
;
2044 int old_selector
= -1;
2046 trace_regulator_set_voltage(rdev_get_name(rdev
), min_uV
, max_uV
);
2048 min_uV
+= rdev
->constraints
->uV_offset
;
2049 max_uV
+= rdev
->constraints
->uV_offset
;
2052 * If we can't obtain the old selector there is not enough
2053 * info to call set_voltage_time_sel().
2055 if (_regulator_is_enabled(rdev
) &&
2056 rdev
->desc
->ops
->set_voltage_time_sel
&&
2057 rdev
->desc
->ops
->get_voltage_sel
) {
2058 old_selector
= rdev
->desc
->ops
->get_voltage_sel(rdev
);
2059 if (old_selector
< 0)
2060 return old_selector
;
2063 if (rdev
->desc
->ops
->set_voltage
) {
2064 ret
= rdev
->desc
->ops
->set_voltage(rdev
, min_uV
, max_uV
,
2068 if (rdev
->desc
->ops
->list_voltage
)
2069 best_val
= rdev
->desc
->ops
->list_voltage(rdev
,
2072 best_val
= _regulator_get_voltage(rdev
);
2075 } else if (rdev
->desc
->ops
->set_voltage_sel
) {
2076 if (rdev
->desc
->ops
->map_voltage
) {
2077 ret
= rdev
->desc
->ops
->map_voltage(rdev
, min_uV
,
2080 if (rdev
->desc
->ops
->list_voltage
==
2081 regulator_list_voltage_linear
)
2082 ret
= regulator_map_voltage_linear(rdev
,
2085 ret
= regulator_map_voltage_iterate(rdev
,
2090 best_val
= rdev
->desc
->ops
->list_voltage(rdev
, ret
);
2091 if (min_uV
<= best_val
&& max_uV
>= best_val
) {
2093 ret
= rdev
->desc
->ops
->set_voltage_sel(rdev
,
2103 /* Call set_voltage_time_sel if successfully obtained old_selector */
2104 if (ret
== 0 && _regulator_is_enabled(rdev
) && old_selector
>= 0 &&
2105 rdev
->desc
->ops
->set_voltage_time_sel
) {
2107 delay
= rdev
->desc
->ops
->set_voltage_time_sel(rdev
,
2108 old_selector
, selector
);
2110 rdev_warn(rdev
, "set_voltage_time_sel() failed: %d\n",
2115 /* Insert any necessary delays */
2116 if (delay
>= 1000) {
2117 mdelay(delay
/ 1000);
2118 udelay(delay
% 1000);
2124 if (ret
== 0 && best_val
>= 0)
2125 _notifier_call_chain(rdev
, REGULATOR_EVENT_VOLTAGE_CHANGE
,
2128 trace_regulator_set_voltage_complete(rdev_get_name(rdev
), best_val
);
2134 * regulator_set_voltage - set regulator output voltage
2135 * @regulator: regulator source
2136 * @min_uV: Minimum required voltage in uV
2137 * @max_uV: Maximum acceptable voltage in uV
2139 * Sets a voltage regulator to the desired output voltage. This can be set
2140 * during any regulator state. IOW, regulator can be disabled or enabled.
2142 * If the regulator is enabled then the voltage will change to the new value
2143 * immediately otherwise if the regulator is disabled the regulator will
2144 * output at the new voltage when enabled.
2146 * NOTE: If the regulator is shared between several devices then the lowest
2147 * request voltage that meets the system constraints will be used.
2148 * Regulator system constraints must be set for this regulator before
2149 * calling this function otherwise this call will fail.
2151 int regulator_set_voltage(struct regulator
*regulator
, int min_uV
, int max_uV
)
2153 struct regulator_dev
*rdev
= regulator
->rdev
;
2156 mutex_lock(&rdev
->mutex
);
2158 /* If we're setting the same range as last time the change
2159 * should be a noop (some cpufreq implementations use the same
2160 * voltage for multiple frequencies, for example).
2162 if (regulator
->min_uV
== min_uV
&& regulator
->max_uV
== max_uV
)
2166 if (!rdev
->desc
->ops
->set_voltage
&&
2167 !rdev
->desc
->ops
->set_voltage_sel
) {
2172 /* constraints check */
2173 ret
= regulator_check_voltage(rdev
, &min_uV
, &max_uV
);
2176 regulator
->min_uV
= min_uV
;
2177 regulator
->max_uV
= max_uV
;
2179 ret
= regulator_check_consumers(rdev
, &min_uV
, &max_uV
);
2183 ret
= _regulator_do_set_voltage(rdev
, min_uV
, max_uV
);
2186 mutex_unlock(&rdev
->mutex
);
2189 EXPORT_SYMBOL_GPL(regulator_set_voltage
);
2192 * regulator_set_voltage_time - get raise/fall time
2193 * @regulator: regulator source
2194 * @old_uV: starting voltage in microvolts
2195 * @new_uV: target voltage in microvolts
2197 * Provided with the starting and ending voltage, this function attempts to
2198 * calculate the time in microseconds required to rise or fall to this new
2201 int regulator_set_voltage_time(struct regulator
*regulator
,
2202 int old_uV
, int new_uV
)
2204 struct regulator_dev
*rdev
= regulator
->rdev
;
2205 struct regulator_ops
*ops
= rdev
->desc
->ops
;
2211 /* Currently requires operations to do this */
2212 if (!ops
->list_voltage
|| !ops
->set_voltage_time_sel
2213 || !rdev
->desc
->n_voltages
)
2216 for (i
= 0; i
< rdev
->desc
->n_voltages
; i
++) {
2217 /* We only look for exact voltage matches here */
2218 voltage
= regulator_list_voltage(regulator
, i
);
2223 if (voltage
== old_uV
)
2225 if (voltage
== new_uV
)
2229 if (old_sel
< 0 || new_sel
< 0)
2232 return ops
->set_voltage_time_sel(rdev
, old_sel
, new_sel
);
2234 EXPORT_SYMBOL_GPL(regulator_set_voltage_time
);
2237 * regulator_sync_voltage - re-apply last regulator output voltage
2238 * @regulator: regulator source
2240 * Re-apply the last configured voltage. This is intended to be used
2241 * where some external control source the consumer is cooperating with
2242 * has caused the configured voltage to change.
2244 int regulator_sync_voltage(struct regulator
*regulator
)
2246 struct regulator_dev
*rdev
= regulator
->rdev
;
2247 int ret
, min_uV
, max_uV
;
2249 mutex_lock(&rdev
->mutex
);
2251 if (!rdev
->desc
->ops
->set_voltage
&&
2252 !rdev
->desc
->ops
->set_voltage_sel
) {
2257 /* This is only going to work if we've had a voltage configured. */
2258 if (!regulator
->min_uV
&& !regulator
->max_uV
) {
2263 min_uV
= regulator
->min_uV
;
2264 max_uV
= regulator
->max_uV
;
2266 /* This should be a paranoia check... */
2267 ret
= regulator_check_voltage(rdev
, &min_uV
, &max_uV
);
2271 ret
= regulator_check_consumers(rdev
, &min_uV
, &max_uV
);
2275 ret
= _regulator_do_set_voltage(rdev
, min_uV
, max_uV
);
2278 mutex_unlock(&rdev
->mutex
);
2281 EXPORT_SYMBOL_GPL(regulator_sync_voltage
);
2283 static int _regulator_get_voltage(struct regulator_dev
*rdev
)
2287 if (rdev
->desc
->ops
->get_voltage_sel
) {
2288 sel
= rdev
->desc
->ops
->get_voltage_sel(rdev
);
2291 ret
= rdev
->desc
->ops
->list_voltage(rdev
, sel
);
2292 } else if (rdev
->desc
->ops
->get_voltage
) {
2293 ret
= rdev
->desc
->ops
->get_voltage(rdev
);
2300 return ret
- rdev
->constraints
->uV_offset
;
2304 * regulator_get_voltage - get regulator output voltage
2305 * @regulator: regulator source
2307 * This returns the current regulator voltage in uV.
2309 * NOTE: If the regulator is disabled it will return the voltage value. This
2310 * function should not be used to determine regulator state.
2312 int regulator_get_voltage(struct regulator
*regulator
)
2316 mutex_lock(®ulator
->rdev
->mutex
);
2318 ret
= _regulator_get_voltage(regulator
->rdev
);
2320 mutex_unlock(®ulator
->rdev
->mutex
);
2324 EXPORT_SYMBOL_GPL(regulator_get_voltage
);
2327 * regulator_set_current_limit - set regulator output current limit
2328 * @regulator: regulator source
2329 * @min_uA: Minimuum supported current in uA
2330 * @max_uA: Maximum supported current in uA
2332 * Sets current sink to the desired output current. This can be set during
2333 * any regulator state. IOW, regulator can be disabled or enabled.
2335 * If the regulator is enabled then the current will change to the new value
2336 * immediately otherwise if the regulator is disabled the regulator will
2337 * output at the new current when enabled.
2339 * NOTE: Regulator system constraints must be set for this regulator before
2340 * calling this function otherwise this call will fail.
2342 int regulator_set_current_limit(struct regulator
*regulator
,
2343 int min_uA
, int max_uA
)
2345 struct regulator_dev
*rdev
= regulator
->rdev
;
2348 mutex_lock(&rdev
->mutex
);
2351 if (!rdev
->desc
->ops
->set_current_limit
) {
2356 /* constraints check */
2357 ret
= regulator_check_current_limit(rdev
, &min_uA
, &max_uA
);
2361 ret
= rdev
->desc
->ops
->set_current_limit(rdev
, min_uA
, max_uA
);
2363 mutex_unlock(&rdev
->mutex
);
2366 EXPORT_SYMBOL_GPL(regulator_set_current_limit
);
2368 static int _regulator_get_current_limit(struct regulator_dev
*rdev
)
2372 mutex_lock(&rdev
->mutex
);
2375 if (!rdev
->desc
->ops
->get_current_limit
) {
2380 ret
= rdev
->desc
->ops
->get_current_limit(rdev
);
2382 mutex_unlock(&rdev
->mutex
);
2387 * regulator_get_current_limit - get regulator output current
2388 * @regulator: regulator source
2390 * This returns the current supplied by the specified current sink in uA.
2392 * NOTE: If the regulator is disabled it will return the current value. This
2393 * function should not be used to determine regulator state.
2395 int regulator_get_current_limit(struct regulator
*regulator
)
2397 return _regulator_get_current_limit(regulator
->rdev
);
2399 EXPORT_SYMBOL_GPL(regulator_get_current_limit
);
2402 * regulator_set_mode - set regulator operating mode
2403 * @regulator: regulator source
2404 * @mode: operating mode - one of the REGULATOR_MODE constants
2406 * Set regulator operating mode to increase regulator efficiency or improve
2407 * regulation performance.
2409 * NOTE: Regulator system constraints must be set for this regulator before
2410 * calling this function otherwise this call will fail.
2412 int regulator_set_mode(struct regulator
*regulator
, unsigned int mode
)
2414 struct regulator_dev
*rdev
= regulator
->rdev
;
2416 int regulator_curr_mode
;
2418 mutex_lock(&rdev
->mutex
);
2421 if (!rdev
->desc
->ops
->set_mode
) {
2426 /* return if the same mode is requested */
2427 if (rdev
->desc
->ops
->get_mode
) {
2428 regulator_curr_mode
= rdev
->desc
->ops
->get_mode(rdev
);
2429 if (regulator_curr_mode
== mode
) {
2435 /* constraints check */
2436 ret
= regulator_mode_constrain(rdev
, &mode
);
2440 ret
= rdev
->desc
->ops
->set_mode(rdev
, mode
);
2442 mutex_unlock(&rdev
->mutex
);
2445 EXPORT_SYMBOL_GPL(regulator_set_mode
);
2447 static unsigned int _regulator_get_mode(struct regulator_dev
*rdev
)
2451 mutex_lock(&rdev
->mutex
);
2454 if (!rdev
->desc
->ops
->get_mode
) {
2459 ret
= rdev
->desc
->ops
->get_mode(rdev
);
2461 mutex_unlock(&rdev
->mutex
);
2466 * regulator_get_mode - get regulator operating mode
2467 * @regulator: regulator source
2469 * Get the current regulator operating mode.
2471 unsigned int regulator_get_mode(struct regulator
*regulator
)
2473 return _regulator_get_mode(regulator
->rdev
);
2475 EXPORT_SYMBOL_GPL(regulator_get_mode
);
2478 * regulator_set_optimum_mode - set regulator optimum operating mode
2479 * @regulator: regulator source
2480 * @uA_load: load current
2482 * Notifies the regulator core of a new device load. This is then used by
2483 * DRMS (if enabled by constraints) to set the most efficient regulator
2484 * operating mode for the new regulator loading.
2486 * Consumer devices notify their supply regulator of the maximum power
2487 * they will require (can be taken from device datasheet in the power
2488 * consumption tables) when they change operational status and hence power
2489 * state. Examples of operational state changes that can affect power
2490 * consumption are :-
2492 * o Device is opened / closed.
2493 * o Device I/O is about to begin or has just finished.
2494 * o Device is idling in between work.
2496 * This information is also exported via sysfs to userspace.
2498 * DRMS will sum the total requested load on the regulator and change
2499 * to the most efficient operating mode if platform constraints allow.
2501 * Returns the new regulator mode or error.
2503 int regulator_set_optimum_mode(struct regulator
*regulator
, int uA_load
)
2505 struct regulator_dev
*rdev
= regulator
->rdev
;
2506 struct regulator
*consumer
;
2507 int ret
, output_uV
, input_uV
, total_uA_load
= 0;
2510 mutex_lock(&rdev
->mutex
);
2513 * first check to see if we can set modes at all, otherwise just
2514 * tell the consumer everything is OK.
2516 regulator
->uA_load
= uA_load
;
2517 ret
= regulator_check_drms(rdev
);
2523 if (!rdev
->desc
->ops
->get_optimum_mode
)
2527 * we can actually do this so any errors are indicators of
2528 * potential real failure.
2532 if (!rdev
->desc
->ops
->set_mode
)
2535 /* get output voltage */
2536 output_uV
= _regulator_get_voltage(rdev
);
2537 if (output_uV
<= 0) {
2538 rdev_err(rdev
, "invalid output voltage found\n");
2542 /* get input voltage */
2545 input_uV
= regulator_get_voltage(rdev
->supply
);
2547 input_uV
= rdev
->constraints
->input_uV
;
2548 if (input_uV
<= 0) {
2549 rdev_err(rdev
, "invalid input voltage found\n");
2553 /* calc total requested load for this regulator */
2554 list_for_each_entry(consumer
, &rdev
->consumer_list
, list
)
2555 total_uA_load
+= consumer
->uA_load
;
2557 mode
= rdev
->desc
->ops
->get_optimum_mode(rdev
,
2558 input_uV
, output_uV
,
2560 ret
= regulator_mode_constrain(rdev
, &mode
);
2562 rdev_err(rdev
, "failed to get optimum mode @ %d uA %d -> %d uV\n",
2563 total_uA_load
, input_uV
, output_uV
);
2567 ret
= rdev
->desc
->ops
->set_mode(rdev
, mode
);
2569 rdev_err(rdev
, "failed to set optimum mode %x\n", mode
);
2574 mutex_unlock(&rdev
->mutex
);
2577 EXPORT_SYMBOL_GPL(regulator_set_optimum_mode
);
2580 * regulator_register_notifier - register regulator event notifier
2581 * @regulator: regulator source
2582 * @nb: notifier block
2584 * Register notifier block to receive regulator events.
2586 int regulator_register_notifier(struct regulator
*regulator
,
2587 struct notifier_block
*nb
)
2589 return blocking_notifier_chain_register(®ulator
->rdev
->notifier
,
2592 EXPORT_SYMBOL_GPL(regulator_register_notifier
);
2595 * regulator_unregister_notifier - unregister regulator event notifier
2596 * @regulator: regulator source
2597 * @nb: notifier block
2599 * Unregister regulator event notifier block.
2601 int regulator_unregister_notifier(struct regulator
*regulator
,
2602 struct notifier_block
*nb
)
2604 return blocking_notifier_chain_unregister(®ulator
->rdev
->notifier
,
2607 EXPORT_SYMBOL_GPL(regulator_unregister_notifier
);
2609 /* notify regulator consumers and downstream regulator consumers.
2610 * Note mutex must be held by caller.
2612 static void _notifier_call_chain(struct regulator_dev
*rdev
,
2613 unsigned long event
, void *data
)
2615 /* call rdev chain first */
2616 blocking_notifier_call_chain(&rdev
->notifier
, event
, data
);
2620 * regulator_bulk_get - get multiple regulator consumers
2622 * @dev: Device to supply
2623 * @num_consumers: Number of consumers to register
2624 * @consumers: Configuration of consumers; clients are stored here.
2626 * @return 0 on success, an errno on failure.
2628 * This helper function allows drivers to get several regulator
2629 * consumers in one operation. If any of the regulators cannot be
2630 * acquired then any regulators that were allocated will be freed
2631 * before returning to the caller.
2633 int regulator_bulk_get(struct device
*dev
, int num_consumers
,
2634 struct regulator_bulk_data
*consumers
)
2639 for (i
= 0; i
< num_consumers
; i
++)
2640 consumers
[i
].consumer
= NULL
;
2642 for (i
= 0; i
< num_consumers
; i
++) {
2643 consumers
[i
].consumer
= regulator_get(dev
,
2644 consumers
[i
].supply
);
2645 if (IS_ERR(consumers
[i
].consumer
)) {
2646 ret
= PTR_ERR(consumers
[i
].consumer
);
2647 dev_err(dev
, "Failed to get supply '%s': %d\n",
2648 consumers
[i
].supply
, ret
);
2649 consumers
[i
].consumer
= NULL
;
2658 regulator_put(consumers
[i
].consumer
);
2662 EXPORT_SYMBOL_GPL(regulator_bulk_get
);
2665 * devm_regulator_bulk_get - managed get multiple regulator consumers
2667 * @dev: Device to supply
2668 * @num_consumers: Number of consumers to register
2669 * @consumers: Configuration of consumers; clients are stored here.
2671 * @return 0 on success, an errno on failure.
2673 * This helper function allows drivers to get several regulator
2674 * consumers in one operation with management, the regulators will
2675 * automatically be freed when the device is unbound. If any of the
2676 * regulators cannot be acquired then any regulators that were
2677 * allocated will be freed before returning to the caller.
2679 int devm_regulator_bulk_get(struct device
*dev
, int num_consumers
,
2680 struct regulator_bulk_data
*consumers
)
2685 for (i
= 0; i
< num_consumers
; i
++)
2686 consumers
[i
].consumer
= NULL
;
2688 for (i
= 0; i
< num_consumers
; i
++) {
2689 consumers
[i
].consumer
= devm_regulator_get(dev
,
2690 consumers
[i
].supply
);
2691 if (IS_ERR(consumers
[i
].consumer
)) {
2692 ret
= PTR_ERR(consumers
[i
].consumer
);
2693 dev_err(dev
, "Failed to get supply '%s': %d\n",
2694 consumers
[i
].supply
, ret
);
2695 consumers
[i
].consumer
= NULL
;
2703 for (i
= 0; i
< num_consumers
&& consumers
[i
].consumer
; i
++)
2704 devm_regulator_put(consumers
[i
].consumer
);
2708 EXPORT_SYMBOL_GPL(devm_regulator_bulk_get
);
2710 static void regulator_bulk_enable_async(void *data
, async_cookie_t cookie
)
2712 struct regulator_bulk_data
*bulk
= data
;
2714 bulk
->ret
= regulator_enable(bulk
->consumer
);
2718 * regulator_bulk_enable - enable multiple regulator consumers
2720 * @num_consumers: Number of consumers
2721 * @consumers: Consumer data; clients are stored here.
2722 * @return 0 on success, an errno on failure
2724 * This convenience API allows consumers to enable multiple regulator
2725 * clients in a single API call. If any consumers cannot be enabled
2726 * then any others that were enabled will be disabled again prior to
2729 int regulator_bulk_enable(int num_consumers
,
2730 struct regulator_bulk_data
*consumers
)
2732 LIST_HEAD(async_domain
);
2736 for (i
= 0; i
< num_consumers
; i
++) {
2737 if (consumers
[i
].consumer
->always_on
)
2738 consumers
[i
].ret
= 0;
2740 async_schedule_domain(regulator_bulk_enable_async
,
2741 &consumers
[i
], &async_domain
);
2744 async_synchronize_full_domain(&async_domain
);
2746 /* If any consumer failed we need to unwind any that succeeded */
2747 for (i
= 0; i
< num_consumers
; i
++) {
2748 if (consumers
[i
].ret
!= 0) {
2749 ret
= consumers
[i
].ret
;
2757 pr_err("Failed to enable %s: %d\n", consumers
[i
].supply
, ret
);
2759 regulator_disable(consumers
[i
].consumer
);
2763 EXPORT_SYMBOL_GPL(regulator_bulk_enable
);
2766 * regulator_bulk_disable - disable multiple regulator consumers
2768 * @num_consumers: Number of consumers
2769 * @consumers: Consumer data; clients are stored here.
2770 * @return 0 on success, an errno on failure
2772 * This convenience API allows consumers to disable multiple regulator
2773 * clients in a single API call. If any consumers cannot be disabled
2774 * then any others that were disabled will be enabled again prior to
2777 int regulator_bulk_disable(int num_consumers
,
2778 struct regulator_bulk_data
*consumers
)
2783 for (i
= num_consumers
- 1; i
>= 0; --i
) {
2784 ret
= regulator_disable(consumers
[i
].consumer
);
2792 pr_err("Failed to disable %s: %d\n", consumers
[i
].supply
, ret
);
2793 for (++i
; i
< num_consumers
; ++i
) {
2794 r
= regulator_enable(consumers
[i
].consumer
);
2796 pr_err("Failed to reename %s: %d\n",
2797 consumers
[i
].supply
, r
);
2802 EXPORT_SYMBOL_GPL(regulator_bulk_disable
);
2805 * regulator_bulk_force_disable - force disable multiple regulator consumers
2807 * @num_consumers: Number of consumers
2808 * @consumers: Consumer data; clients are stored here.
2809 * @return 0 on success, an errno on failure
2811 * This convenience API allows consumers to forcibly disable multiple regulator
2812 * clients in a single API call.
2813 * NOTE: This should be used for situations when device damage will
2814 * likely occur if the regulators are not disabled (e.g. over temp).
2815 * Although regulator_force_disable function call for some consumers can
2816 * return error numbers, the function is called for all consumers.
2818 int regulator_bulk_force_disable(int num_consumers
,
2819 struct regulator_bulk_data
*consumers
)
2824 for (i
= 0; i
< num_consumers
; i
++)
2826 regulator_force_disable(consumers
[i
].consumer
);
2828 for (i
= 0; i
< num_consumers
; i
++) {
2829 if (consumers
[i
].ret
!= 0) {
2830 ret
= consumers
[i
].ret
;
2839 EXPORT_SYMBOL_GPL(regulator_bulk_force_disable
);
2842 * regulator_bulk_free - free multiple regulator consumers
2844 * @num_consumers: Number of consumers
2845 * @consumers: Consumer data; clients are stored here.
2847 * This convenience API allows consumers to free multiple regulator
2848 * clients in a single API call.
2850 void regulator_bulk_free(int num_consumers
,
2851 struct regulator_bulk_data
*consumers
)
2855 for (i
= 0; i
< num_consumers
; i
++) {
2856 regulator_put(consumers
[i
].consumer
);
2857 consumers
[i
].consumer
= NULL
;
2860 EXPORT_SYMBOL_GPL(regulator_bulk_free
);
2863 * regulator_notifier_call_chain - call regulator event notifier
2864 * @rdev: regulator source
2865 * @event: notifier block
2866 * @data: callback-specific data.
2868 * Called by regulator drivers to notify clients a regulator event has
2869 * occurred. We also notify regulator clients downstream.
2870 * Note lock must be held by caller.
2872 int regulator_notifier_call_chain(struct regulator_dev
*rdev
,
2873 unsigned long event
, void *data
)
2875 _notifier_call_chain(rdev
, event
, data
);
2879 EXPORT_SYMBOL_GPL(regulator_notifier_call_chain
);
2882 * regulator_mode_to_status - convert a regulator mode into a status
2884 * @mode: Mode to convert
2886 * Convert a regulator mode into a status.
2888 int regulator_mode_to_status(unsigned int mode
)
2891 case REGULATOR_MODE_FAST
:
2892 return REGULATOR_STATUS_FAST
;
2893 case REGULATOR_MODE_NORMAL
:
2894 return REGULATOR_STATUS_NORMAL
;
2895 case REGULATOR_MODE_IDLE
:
2896 return REGULATOR_STATUS_IDLE
;
2897 case REGULATOR_MODE_STANDBY
:
2898 return REGULATOR_STATUS_STANDBY
;
2903 EXPORT_SYMBOL_GPL(regulator_mode_to_status
);
2906 * To avoid cluttering sysfs (and memory) with useless state, only
2907 * create attributes that can be meaningfully displayed.
2909 static int add_regulator_attributes(struct regulator_dev
*rdev
)
2911 struct device
*dev
= &rdev
->dev
;
2912 struct regulator_ops
*ops
= rdev
->desc
->ops
;
2915 /* some attributes need specific methods to be displayed */
2916 if ((ops
->get_voltage
&& ops
->get_voltage(rdev
) >= 0) ||
2917 (ops
->get_voltage_sel
&& ops
->get_voltage_sel(rdev
) >= 0)) {
2918 status
= device_create_file(dev
, &dev_attr_microvolts
);
2922 if (ops
->get_current_limit
) {
2923 status
= device_create_file(dev
, &dev_attr_microamps
);
2927 if (ops
->get_mode
) {
2928 status
= device_create_file(dev
, &dev_attr_opmode
);
2932 if (ops
->is_enabled
) {
2933 status
= device_create_file(dev
, &dev_attr_state
);
2937 if (ops
->get_status
) {
2938 status
= device_create_file(dev
, &dev_attr_status
);
2943 /* some attributes are type-specific */
2944 if (rdev
->desc
->type
== REGULATOR_CURRENT
) {
2945 status
= device_create_file(dev
, &dev_attr_requested_microamps
);
2950 /* all the other attributes exist to support constraints;
2951 * don't show them if there are no constraints, or if the
2952 * relevant supporting methods are missing.
2954 if (!rdev
->constraints
)
2957 /* constraints need specific supporting methods */
2958 if (ops
->set_voltage
|| ops
->set_voltage_sel
) {
2959 status
= device_create_file(dev
, &dev_attr_min_microvolts
);
2962 status
= device_create_file(dev
, &dev_attr_max_microvolts
);
2966 if (ops
->set_current_limit
) {
2967 status
= device_create_file(dev
, &dev_attr_min_microamps
);
2970 status
= device_create_file(dev
, &dev_attr_max_microamps
);
2975 status
= device_create_file(dev
, &dev_attr_suspend_standby_state
);
2978 status
= device_create_file(dev
, &dev_attr_suspend_mem_state
);
2981 status
= device_create_file(dev
, &dev_attr_suspend_disk_state
);
2985 if (ops
->set_suspend_voltage
) {
2986 status
= device_create_file(dev
,
2987 &dev_attr_suspend_standby_microvolts
);
2990 status
= device_create_file(dev
,
2991 &dev_attr_suspend_mem_microvolts
);
2994 status
= device_create_file(dev
,
2995 &dev_attr_suspend_disk_microvolts
);
3000 if (ops
->set_suspend_mode
) {
3001 status
= device_create_file(dev
,
3002 &dev_attr_suspend_standby_mode
);
3005 status
= device_create_file(dev
,
3006 &dev_attr_suspend_mem_mode
);
3009 status
= device_create_file(dev
,
3010 &dev_attr_suspend_disk_mode
);
3018 static void rdev_init_debugfs(struct regulator_dev
*rdev
)
3020 rdev
->debugfs
= debugfs_create_dir(rdev_get_name(rdev
), debugfs_root
);
3021 if (!rdev
->debugfs
) {
3022 rdev_warn(rdev
, "Failed to create debugfs directory\n");
3026 debugfs_create_u32("use_count", 0444, rdev
->debugfs
,
3028 debugfs_create_u32("open_count", 0444, rdev
->debugfs
,
3033 * regulator_register - register regulator
3034 * @regulator_desc: regulator to register
3035 * @config: runtime configuration for regulator
3037 * Called by regulator drivers to register a regulator.
3038 * Returns 0 on success.
3040 struct regulator_dev
*
3041 regulator_register(const struct regulator_desc
*regulator_desc
,
3042 const struct regulator_config
*config
)
3044 const struct regulation_constraints
*constraints
= NULL
;
3045 const struct regulator_init_data
*init_data
;
3046 static atomic_t regulator_no
= ATOMIC_INIT(0);
3047 struct regulator_dev
*rdev
;
3050 const char *supply
= NULL
;
3052 if (regulator_desc
== NULL
|| config
== NULL
)
3053 return ERR_PTR(-EINVAL
);
3058 if (regulator_desc
->name
== NULL
|| regulator_desc
->ops
== NULL
)
3059 return ERR_PTR(-EINVAL
);
3061 if (regulator_desc
->type
!= REGULATOR_VOLTAGE
&&
3062 regulator_desc
->type
!= REGULATOR_CURRENT
)
3063 return ERR_PTR(-EINVAL
);
3065 /* Only one of each should be implemented */
3066 WARN_ON(regulator_desc
->ops
->get_voltage
&&
3067 regulator_desc
->ops
->get_voltage_sel
);
3068 WARN_ON(regulator_desc
->ops
->set_voltage
&&
3069 regulator_desc
->ops
->set_voltage_sel
);
3071 /* If we're using selectors we must implement list_voltage. */
3072 if (regulator_desc
->ops
->get_voltage_sel
&&
3073 !regulator_desc
->ops
->list_voltage
) {
3074 return ERR_PTR(-EINVAL
);
3076 if (regulator_desc
->ops
->set_voltage_sel
&&
3077 !regulator_desc
->ops
->list_voltage
) {
3078 return ERR_PTR(-EINVAL
);
3081 init_data
= config
->init_data
;
3083 rdev
= kzalloc(sizeof(struct regulator_dev
), GFP_KERNEL
);
3085 return ERR_PTR(-ENOMEM
);
3087 mutex_lock(®ulator_list_mutex
);
3089 mutex_init(&rdev
->mutex
);
3090 rdev
->reg_data
= config
->driver_data
;
3091 rdev
->owner
= regulator_desc
->owner
;
3092 rdev
->desc
= regulator_desc
;
3094 rdev
->regmap
= config
->regmap
;
3096 rdev
->regmap
= dev_get_regmap(dev
, NULL
);
3097 INIT_LIST_HEAD(&rdev
->consumer_list
);
3098 INIT_LIST_HEAD(&rdev
->list
);
3099 BLOCKING_INIT_NOTIFIER_HEAD(&rdev
->notifier
);
3100 INIT_DELAYED_WORK(&rdev
->disable_work
, regulator_disable_work
);
3102 /* preform any regulator specific init */
3103 if (init_data
&& init_data
->regulator_init
) {
3104 ret
= init_data
->regulator_init(rdev
->reg_data
);
3109 /* register with sysfs */
3110 rdev
->dev
.class = ®ulator_class
;
3111 rdev
->dev
.of_node
= config
->of_node
;
3112 rdev
->dev
.parent
= dev
;
3113 dev_set_name(&rdev
->dev
, "regulator.%d",
3114 atomic_inc_return(®ulator_no
) - 1);
3115 ret
= device_register(&rdev
->dev
);
3117 put_device(&rdev
->dev
);
3121 dev_set_drvdata(&rdev
->dev
, rdev
);
3123 /* set regulator constraints */
3125 constraints
= &init_data
->constraints
;
3127 ret
= set_machine_constraints(rdev
, constraints
);
3131 /* add attributes supported by this regulator */
3132 ret
= add_regulator_attributes(rdev
);
3136 if (init_data
&& init_data
->supply_regulator
)
3137 supply
= init_data
->supply_regulator
;
3138 else if (regulator_desc
->supply_name
)
3139 supply
= regulator_desc
->supply_name
;
3142 struct regulator_dev
*r
;
3144 r
= regulator_dev_lookup(dev
, supply
, &ret
);
3147 dev_err(dev
, "Failed to find supply %s\n", supply
);
3148 ret
= -EPROBE_DEFER
;
3152 ret
= set_supply(rdev
, r
);
3156 /* Enable supply if rail is enabled */
3157 if (_regulator_is_enabled(rdev
)) {
3158 ret
= regulator_enable(rdev
->supply
);
3164 /* add consumers devices */
3166 for (i
= 0; i
< init_data
->num_consumer_supplies
; i
++) {
3167 ret
= set_consumer_device_supply(rdev
,
3168 init_data
->consumer_supplies
[i
].dev_name
,
3169 init_data
->consumer_supplies
[i
].supply
);
3171 dev_err(dev
, "Failed to set supply %s\n",
3172 init_data
->consumer_supplies
[i
].supply
);
3173 goto unset_supplies
;
3178 list_add(&rdev
->list
, ®ulator_list
);
3180 rdev_init_debugfs(rdev
);
3182 mutex_unlock(®ulator_list_mutex
);
3186 unset_regulator_supplies(rdev
);
3190 regulator_put(rdev
->supply
);
3191 kfree(rdev
->constraints
);
3192 device_unregister(&rdev
->dev
);
3193 /* device core frees rdev */
3194 rdev
= ERR_PTR(ret
);
3199 rdev
= ERR_PTR(ret
);
3202 EXPORT_SYMBOL_GPL(regulator_register
);
3205 * regulator_unregister - unregister regulator
3206 * @rdev: regulator to unregister
3208 * Called by regulator drivers to unregister a regulator.
3210 void regulator_unregister(struct regulator_dev
*rdev
)
3216 regulator_put(rdev
->supply
);
3217 mutex_lock(®ulator_list_mutex
);
3218 debugfs_remove_recursive(rdev
->debugfs
);
3219 flush_work_sync(&rdev
->disable_work
.work
);
3220 WARN_ON(rdev
->open_count
);
3221 unset_regulator_supplies(rdev
);
3222 list_del(&rdev
->list
);
3223 kfree(rdev
->constraints
);
3224 device_unregister(&rdev
->dev
);
3225 mutex_unlock(®ulator_list_mutex
);
3227 EXPORT_SYMBOL_GPL(regulator_unregister
);
3230 * regulator_suspend_prepare - prepare regulators for system wide suspend
3231 * @state: system suspend state
3233 * Configure each regulator with it's suspend operating parameters for state.
3234 * This will usually be called by machine suspend code prior to supending.
3236 int regulator_suspend_prepare(suspend_state_t state
)
3238 struct regulator_dev
*rdev
;
3241 /* ON is handled by regulator active state */
3242 if (state
== PM_SUSPEND_ON
)
3245 mutex_lock(®ulator_list_mutex
);
3246 list_for_each_entry(rdev
, ®ulator_list
, list
) {
3248 mutex_lock(&rdev
->mutex
);
3249 ret
= suspend_prepare(rdev
, state
);
3250 mutex_unlock(&rdev
->mutex
);
3253 rdev_err(rdev
, "failed to prepare\n");
3258 mutex_unlock(®ulator_list_mutex
);
3261 EXPORT_SYMBOL_GPL(regulator_suspend_prepare
);
3264 * regulator_suspend_finish - resume regulators from system wide suspend
3266 * Turn on regulators that might be turned off by regulator_suspend_prepare
3267 * and that should be turned on according to the regulators properties.
3269 int regulator_suspend_finish(void)
3271 struct regulator_dev
*rdev
;
3274 mutex_lock(®ulator_list_mutex
);
3275 list_for_each_entry(rdev
, ®ulator_list
, list
) {
3276 struct regulator_ops
*ops
= rdev
->desc
->ops
;
3278 mutex_lock(&rdev
->mutex
);
3279 if ((rdev
->use_count
> 0 || rdev
->constraints
->always_on
) &&
3281 error
= ops
->enable(rdev
);
3285 if (!has_full_constraints
)
3289 if (!_regulator_is_enabled(rdev
))
3292 error
= ops
->disable(rdev
);
3297 mutex_unlock(&rdev
->mutex
);
3299 mutex_unlock(®ulator_list_mutex
);
3302 EXPORT_SYMBOL_GPL(regulator_suspend_finish
);
3305 * regulator_has_full_constraints - the system has fully specified constraints
3307 * Calling this function will cause the regulator API to disable all
3308 * regulators which have a zero use count and don't have an always_on
3309 * constraint in a late_initcall.
3311 * The intention is that this will become the default behaviour in a
3312 * future kernel release so users are encouraged to use this facility
3315 void regulator_has_full_constraints(void)
3317 has_full_constraints
= 1;
3319 EXPORT_SYMBOL_GPL(regulator_has_full_constraints
);
3322 * regulator_use_dummy_regulator - Provide a dummy regulator when none is found
3324 * Calling this function will cause the regulator API to provide a
3325 * dummy regulator to consumers if no physical regulator is found,
3326 * allowing most consumers to proceed as though a regulator were
3327 * configured. This allows systems such as those with software
3328 * controllable regulators for the CPU core only to be brought up more
3331 void regulator_use_dummy_regulator(void)
3333 board_wants_dummy_regulator
= true;
3335 EXPORT_SYMBOL_GPL(regulator_use_dummy_regulator
);
3338 * rdev_get_drvdata - get rdev regulator driver data
3341 * Get rdev regulator driver private data. This call can be used in the
3342 * regulator driver context.
3344 void *rdev_get_drvdata(struct regulator_dev
*rdev
)
3346 return rdev
->reg_data
;
3348 EXPORT_SYMBOL_GPL(rdev_get_drvdata
);
3351 * regulator_get_drvdata - get regulator driver data
3352 * @regulator: regulator
3354 * Get regulator driver private data. This call can be used in the consumer
3355 * driver context when non API regulator specific functions need to be called.
3357 void *regulator_get_drvdata(struct regulator
*regulator
)
3359 return regulator
->rdev
->reg_data
;
3361 EXPORT_SYMBOL_GPL(regulator_get_drvdata
);
3364 * regulator_set_drvdata - set regulator driver data
3365 * @regulator: regulator
3368 void regulator_set_drvdata(struct regulator
*regulator
, void *data
)
3370 regulator
->rdev
->reg_data
= data
;
3372 EXPORT_SYMBOL_GPL(regulator_set_drvdata
);
3375 * regulator_get_id - get regulator ID
3378 int rdev_get_id(struct regulator_dev
*rdev
)
3380 return rdev
->desc
->id
;
3382 EXPORT_SYMBOL_GPL(rdev_get_id
);
3384 struct device
*rdev_get_dev(struct regulator_dev
*rdev
)
3388 EXPORT_SYMBOL_GPL(rdev_get_dev
);
3390 void *regulator_get_init_drvdata(struct regulator_init_data
*reg_init_data
)
3392 return reg_init_data
->driver_data
;
3394 EXPORT_SYMBOL_GPL(regulator_get_init_drvdata
);
3396 #ifdef CONFIG_DEBUG_FS
3397 static ssize_t
supply_map_read_file(struct file
*file
, char __user
*user_buf
,
3398 size_t count
, loff_t
*ppos
)
3400 char *buf
= kmalloc(PAGE_SIZE
, GFP_KERNEL
);
3401 ssize_t len
, ret
= 0;
3402 struct regulator_map
*map
;
3407 list_for_each_entry(map
, ®ulator_map_list
, list
) {
3408 len
= snprintf(buf
+ ret
, PAGE_SIZE
- ret
,
3410 rdev_get_name(map
->regulator
), map
->dev_name
,
3414 if (ret
> PAGE_SIZE
) {
3420 ret
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, ret
);
3428 static const struct file_operations supply_map_fops
= {
3429 #ifdef CONFIG_DEBUG_FS
3430 .read
= supply_map_read_file
,
3431 .llseek
= default_llseek
,
3435 static int __init
regulator_init(void)
3439 ret
= class_register(®ulator_class
);
3441 debugfs_root
= debugfs_create_dir("regulator", NULL
);
3443 pr_warn("regulator: Failed to create debugfs directory\n");
3445 debugfs_create_file("supply_map", 0444, debugfs_root
, NULL
,
3448 regulator_dummy_init();
3453 /* init early to allow our consumers to complete system booting */
3454 core_initcall(regulator_init
);
3456 static int __init
regulator_init_complete(void)
3458 struct regulator_dev
*rdev
;
3459 struct regulator_ops
*ops
;
3460 struct regulation_constraints
*c
;
3463 mutex_lock(®ulator_list_mutex
);
3465 /* If we have a full configuration then disable any regulators
3466 * which are not in use or always_on. This will become the
3467 * default behaviour in the future.
3469 list_for_each_entry(rdev
, ®ulator_list
, list
) {
3470 ops
= rdev
->desc
->ops
;
3471 c
= rdev
->constraints
;
3473 if (!ops
->disable
|| (c
&& c
->always_on
))
3476 mutex_lock(&rdev
->mutex
);
3478 if (rdev
->use_count
)
3481 /* If we can't read the status assume it's on. */
3482 if (ops
->is_enabled
)
3483 enabled
= ops
->is_enabled(rdev
);
3490 if (has_full_constraints
) {
3491 /* We log since this may kill the system if it
3493 rdev_info(rdev
, "disabling\n");
3494 ret
= ops
->disable(rdev
);
3496 rdev_err(rdev
, "couldn't disable: %d\n", ret
);
3499 /* The intention is that in future we will
3500 * assume that full constraints are provided
3501 * so warn even if we aren't going to do
3504 rdev_warn(rdev
, "incomplete constraints, leaving on\n");
3508 mutex_unlock(&rdev
->mutex
);
3511 mutex_unlock(®ulator_list_mutex
);
3515 late_initcall(regulator_init_complete
);