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/device.h>
19 #include <linux/err.h>
20 #include <linux/mutex.h>
21 #include <linux/suspend.h>
22 #include <linux/regulator/consumer.h>
23 #include <linux/regulator/driver.h>
24 #include <linux/regulator/machine.h>
26 #define REGULATOR_VERSION "0.5"
28 static DEFINE_MUTEX(regulator_list_mutex);
29 static LIST_HEAD(regulator_list);
30 static LIST_HEAD(regulator_map_list);
33 * struct regulator_map
35 * Used to provide symbolic supply names to devices.
37 struct regulator_map {
38 struct list_head list;
41 struct regulator_dev *regulator;
47 * One for each consumer device.
51 struct list_head list;
56 struct device_attribute dev_attr;
57 struct regulator_dev *rdev;
60 static int _regulator_is_enabled(struct regulator_dev *rdev);
61 static int _regulator_disable(struct regulator_dev *rdev);
62 static int _regulator_get_voltage(struct regulator_dev *rdev);
63 static int _regulator_get_current_limit(struct regulator_dev *rdev);
64 static unsigned int _regulator_get_mode(struct regulator_dev *rdev);
65 static void _notifier_call_chain(struct regulator_dev *rdev,
66 unsigned long event, void *data);
68 /* gets the regulator for a given consumer device */
69 static struct regulator *get_device_regulator(struct device *dev)
71 struct regulator *regulator = NULL;
72 struct regulator_dev *rdev;
74 mutex_lock(®ulator_list_mutex);
75 list_for_each_entry(rdev, ®ulator_list, list) {
76 mutex_lock(&rdev->mutex);
77 list_for_each_entry(regulator, &rdev->consumer_list, list) {
78 if (regulator->dev == dev) {
79 mutex_unlock(&rdev->mutex);
80 mutex_unlock(®ulator_list_mutex);
84 mutex_unlock(&rdev->mutex);
86 mutex_unlock(®ulator_list_mutex);
90 /* Platform voltage constraint check */
91 static int regulator_check_voltage(struct regulator_dev *rdev,
92 int *min_uV, int *max_uV)
94 BUG_ON(*min_uV > *max_uV);
96 if (!rdev->constraints) {
97 printk(KERN_ERR "%s: no constraints for %s\n", __func__,
101 if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) {
102 printk(KERN_ERR "%s: operation not allowed for %s\n",
103 __func__, rdev->desc->name);
107 if (*max_uV > rdev->constraints->max_uV)
108 *max_uV = rdev->constraints->max_uV;
109 if (*min_uV < rdev->constraints->min_uV)
110 *min_uV = rdev->constraints->min_uV;
112 if (*min_uV > *max_uV)
118 /* current constraint check */
119 static int regulator_check_current_limit(struct regulator_dev *rdev,
120 int *min_uA, int *max_uA)
122 BUG_ON(*min_uA > *max_uA);
124 if (!rdev->constraints) {
125 printk(KERN_ERR "%s: no constraints for %s\n", __func__,
129 if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_CURRENT)) {
130 printk(KERN_ERR "%s: operation not allowed for %s\n",
131 __func__, rdev->desc->name);
135 if (*max_uA > rdev->constraints->max_uA)
136 *max_uA = rdev->constraints->max_uA;
137 if (*min_uA < rdev->constraints->min_uA)
138 *min_uA = rdev->constraints->min_uA;
140 if (*min_uA > *max_uA)
146 /* operating mode constraint check */
147 static int regulator_check_mode(struct regulator_dev *rdev, int mode)
150 case REGULATOR_MODE_FAST:
151 case REGULATOR_MODE_NORMAL:
152 case REGULATOR_MODE_IDLE:
153 case REGULATOR_MODE_STANDBY:
159 if (!rdev->constraints) {
160 printk(KERN_ERR "%s: no constraints for %s\n", __func__,
164 if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_MODE)) {
165 printk(KERN_ERR "%s: operation not allowed for %s\n",
166 __func__, rdev->desc->name);
169 if (!(rdev->constraints->valid_modes_mask & mode)) {
170 printk(KERN_ERR "%s: invalid mode %x for %s\n",
171 __func__, mode, rdev->desc->name);
177 /* dynamic regulator mode switching constraint check */
178 static int regulator_check_drms(struct regulator_dev *rdev)
180 if (!rdev->constraints) {
181 printk(KERN_ERR "%s: no constraints for %s\n", __func__,
185 if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_DRMS)) {
186 printk(KERN_ERR "%s: operation not allowed for %s\n",
187 __func__, rdev->desc->name);
193 static ssize_t device_requested_uA_show(struct device *dev,
194 struct device_attribute *attr, char *buf)
196 struct regulator *regulator;
198 regulator = get_device_regulator(dev);
199 if (regulator == NULL)
202 return sprintf(buf, "%d\n", regulator->uA_load);
205 static ssize_t regulator_uV_show(struct device *dev,
206 struct device_attribute *attr, char *buf)
208 struct regulator_dev *rdev = dev_get_drvdata(dev);
211 mutex_lock(&rdev->mutex);
212 ret = sprintf(buf, "%d\n", _regulator_get_voltage(rdev));
213 mutex_unlock(&rdev->mutex);
217 static DEVICE_ATTR(microvolts, 0444, regulator_uV_show, NULL);
219 static ssize_t regulator_uA_show(struct device *dev,
220 struct device_attribute *attr, char *buf)
222 struct regulator_dev *rdev = dev_get_drvdata(dev);
224 return sprintf(buf, "%d\n", _regulator_get_current_limit(rdev));
226 static DEVICE_ATTR(microamps, 0444, regulator_uA_show, NULL);
228 static ssize_t regulator_name_show(struct device *dev,
229 struct device_attribute *attr, char *buf)
231 struct regulator_dev *rdev = dev_get_drvdata(dev);
234 if (rdev->constraints->name)
235 name = rdev->constraints->name;
236 else if (rdev->desc->name)
237 name = rdev->desc->name;
241 return sprintf(buf, "%s\n", name);
244 static ssize_t regulator_print_opmode(char *buf, int mode)
247 case REGULATOR_MODE_FAST:
248 return sprintf(buf, "fast\n");
249 case REGULATOR_MODE_NORMAL:
250 return sprintf(buf, "normal\n");
251 case REGULATOR_MODE_IDLE:
252 return sprintf(buf, "idle\n");
253 case REGULATOR_MODE_STANDBY:
254 return sprintf(buf, "standby\n");
256 return sprintf(buf, "unknown\n");
259 static ssize_t regulator_opmode_show(struct device *dev,
260 struct device_attribute *attr, char *buf)
262 struct regulator_dev *rdev = dev_get_drvdata(dev);
264 return regulator_print_opmode(buf, _regulator_get_mode(rdev));
266 static DEVICE_ATTR(opmode, 0444, regulator_opmode_show, NULL);
268 static ssize_t regulator_print_state(char *buf, int state)
271 return sprintf(buf, "enabled\n");
273 return sprintf(buf, "disabled\n");
275 return sprintf(buf, "unknown\n");
278 static ssize_t regulator_state_show(struct device *dev,
279 struct device_attribute *attr, char *buf)
281 struct regulator_dev *rdev = dev_get_drvdata(dev);
283 return regulator_print_state(buf, _regulator_is_enabled(rdev));
285 static DEVICE_ATTR(state, 0444, regulator_state_show, NULL);
287 static ssize_t regulator_status_show(struct device *dev,
288 struct device_attribute *attr, char *buf)
290 struct regulator_dev *rdev = dev_get_drvdata(dev);
294 status = rdev->desc->ops->get_status(rdev);
299 case REGULATOR_STATUS_OFF:
302 case REGULATOR_STATUS_ON:
305 case REGULATOR_STATUS_ERROR:
308 case REGULATOR_STATUS_FAST:
311 case REGULATOR_STATUS_NORMAL:
314 case REGULATOR_STATUS_IDLE:
317 case REGULATOR_STATUS_STANDBY:
324 return sprintf(buf, "%s\n", label);
326 static DEVICE_ATTR(status, 0444, regulator_status_show, NULL);
328 static ssize_t regulator_min_uA_show(struct device *dev,
329 struct device_attribute *attr, char *buf)
331 struct regulator_dev *rdev = dev_get_drvdata(dev);
333 if (!rdev->constraints)
334 return sprintf(buf, "constraint not defined\n");
336 return sprintf(buf, "%d\n", rdev->constraints->min_uA);
338 static DEVICE_ATTR(min_microamps, 0444, regulator_min_uA_show, NULL);
340 static ssize_t regulator_max_uA_show(struct device *dev,
341 struct device_attribute *attr, char *buf)
343 struct regulator_dev *rdev = dev_get_drvdata(dev);
345 if (!rdev->constraints)
346 return sprintf(buf, "constraint not defined\n");
348 return sprintf(buf, "%d\n", rdev->constraints->max_uA);
350 static DEVICE_ATTR(max_microamps, 0444, regulator_max_uA_show, NULL);
352 static ssize_t regulator_min_uV_show(struct device *dev,
353 struct device_attribute *attr, char *buf)
355 struct regulator_dev *rdev = dev_get_drvdata(dev);
357 if (!rdev->constraints)
358 return sprintf(buf, "constraint not defined\n");
360 return sprintf(buf, "%d\n", rdev->constraints->min_uV);
362 static DEVICE_ATTR(min_microvolts, 0444, regulator_min_uV_show, NULL);
364 static ssize_t regulator_max_uV_show(struct device *dev,
365 struct device_attribute *attr, char *buf)
367 struct regulator_dev *rdev = dev_get_drvdata(dev);
369 if (!rdev->constraints)
370 return sprintf(buf, "constraint not defined\n");
372 return sprintf(buf, "%d\n", rdev->constraints->max_uV);
374 static DEVICE_ATTR(max_microvolts, 0444, regulator_max_uV_show, NULL);
376 static ssize_t regulator_total_uA_show(struct device *dev,
377 struct device_attribute *attr, char *buf)
379 struct regulator_dev *rdev = dev_get_drvdata(dev);
380 struct regulator *regulator;
383 mutex_lock(&rdev->mutex);
384 list_for_each_entry(regulator, &rdev->consumer_list, list)
385 uA += regulator->uA_load;
386 mutex_unlock(&rdev->mutex);
387 return sprintf(buf, "%d\n", uA);
389 static DEVICE_ATTR(requested_microamps, 0444, regulator_total_uA_show, NULL);
391 static ssize_t regulator_num_users_show(struct device *dev,
392 struct device_attribute *attr, char *buf)
394 struct regulator_dev *rdev = dev_get_drvdata(dev);
395 return sprintf(buf, "%d\n", rdev->use_count);
398 static ssize_t regulator_type_show(struct device *dev,
399 struct device_attribute *attr, char *buf)
401 struct regulator_dev *rdev = dev_get_drvdata(dev);
403 switch (rdev->desc->type) {
404 case REGULATOR_VOLTAGE:
405 return sprintf(buf, "voltage\n");
406 case REGULATOR_CURRENT:
407 return sprintf(buf, "current\n");
409 return sprintf(buf, "unknown\n");
412 static ssize_t regulator_suspend_mem_uV_show(struct device *dev,
413 struct device_attribute *attr, char *buf)
415 struct regulator_dev *rdev = dev_get_drvdata(dev);
417 return sprintf(buf, "%d\n", rdev->constraints->state_mem.uV);
419 static DEVICE_ATTR(suspend_mem_microvolts, 0444,
420 regulator_suspend_mem_uV_show, NULL);
422 static ssize_t regulator_suspend_disk_uV_show(struct device *dev,
423 struct device_attribute *attr, char *buf)
425 struct regulator_dev *rdev = dev_get_drvdata(dev);
427 return sprintf(buf, "%d\n", rdev->constraints->state_disk.uV);
429 static DEVICE_ATTR(suspend_disk_microvolts, 0444,
430 regulator_suspend_disk_uV_show, NULL);
432 static ssize_t regulator_suspend_standby_uV_show(struct device *dev,
433 struct device_attribute *attr, char *buf)
435 struct regulator_dev *rdev = dev_get_drvdata(dev);
437 return sprintf(buf, "%d\n", rdev->constraints->state_standby.uV);
439 static DEVICE_ATTR(suspend_standby_microvolts, 0444,
440 regulator_suspend_standby_uV_show, NULL);
442 static ssize_t regulator_suspend_mem_mode_show(struct device *dev,
443 struct device_attribute *attr, char *buf)
445 struct regulator_dev *rdev = dev_get_drvdata(dev);
447 return regulator_print_opmode(buf,
448 rdev->constraints->state_mem.mode);
450 static DEVICE_ATTR(suspend_mem_mode, 0444,
451 regulator_suspend_mem_mode_show, NULL);
453 static ssize_t regulator_suspend_disk_mode_show(struct device *dev,
454 struct device_attribute *attr, char *buf)
456 struct regulator_dev *rdev = dev_get_drvdata(dev);
458 return regulator_print_opmode(buf,
459 rdev->constraints->state_disk.mode);
461 static DEVICE_ATTR(suspend_disk_mode, 0444,
462 regulator_suspend_disk_mode_show, NULL);
464 static ssize_t regulator_suspend_standby_mode_show(struct device *dev,
465 struct device_attribute *attr, char *buf)
467 struct regulator_dev *rdev = dev_get_drvdata(dev);
469 return regulator_print_opmode(buf,
470 rdev->constraints->state_standby.mode);
472 static DEVICE_ATTR(suspend_standby_mode, 0444,
473 regulator_suspend_standby_mode_show, NULL);
475 static ssize_t regulator_suspend_mem_state_show(struct device *dev,
476 struct device_attribute *attr, char *buf)
478 struct regulator_dev *rdev = dev_get_drvdata(dev);
480 return regulator_print_state(buf,
481 rdev->constraints->state_mem.enabled);
483 static DEVICE_ATTR(suspend_mem_state, 0444,
484 regulator_suspend_mem_state_show, NULL);
486 static ssize_t regulator_suspend_disk_state_show(struct device *dev,
487 struct device_attribute *attr, char *buf)
489 struct regulator_dev *rdev = dev_get_drvdata(dev);
491 return regulator_print_state(buf,
492 rdev->constraints->state_disk.enabled);
494 static DEVICE_ATTR(suspend_disk_state, 0444,
495 regulator_suspend_disk_state_show, NULL);
497 static ssize_t regulator_suspend_standby_state_show(struct device *dev,
498 struct device_attribute *attr, char *buf)
500 struct regulator_dev *rdev = dev_get_drvdata(dev);
502 return regulator_print_state(buf,
503 rdev->constraints->state_standby.enabled);
505 static DEVICE_ATTR(suspend_standby_state, 0444,
506 regulator_suspend_standby_state_show, NULL);
510 * These are the only attributes are present for all regulators.
511 * Other attributes are a function of regulator functionality.
513 static struct device_attribute regulator_dev_attrs[] = {
514 __ATTR(name, 0444, regulator_name_show, NULL),
515 __ATTR(num_users, 0444, regulator_num_users_show, NULL),
516 __ATTR(type, 0444, regulator_type_show, NULL),
520 static void regulator_dev_release(struct device *dev)
522 struct regulator_dev *rdev = dev_get_drvdata(dev);
526 static struct class regulator_class = {
528 .dev_release = regulator_dev_release,
529 .dev_attrs = regulator_dev_attrs,
532 /* Calculate the new optimum regulator operating mode based on the new total
533 * consumer load. All locks held by caller */
534 static void drms_uA_update(struct regulator_dev *rdev)
536 struct regulator *sibling;
537 int current_uA = 0, output_uV, input_uV, err;
540 err = regulator_check_drms(rdev);
541 if (err < 0 || !rdev->desc->ops->get_optimum_mode ||
542 !rdev->desc->ops->get_voltage || !rdev->desc->ops->set_mode);
545 /* get output voltage */
546 output_uV = rdev->desc->ops->get_voltage(rdev);
550 /* get input voltage */
551 if (rdev->supply && rdev->supply->desc->ops->get_voltage)
552 input_uV = rdev->supply->desc->ops->get_voltage(rdev->supply);
554 input_uV = rdev->constraints->input_uV;
558 /* calc total requested load */
559 list_for_each_entry(sibling, &rdev->consumer_list, list)
560 current_uA += sibling->uA_load;
562 /* now get the optimum mode for our new total regulator load */
563 mode = rdev->desc->ops->get_optimum_mode(rdev, input_uV,
564 output_uV, current_uA);
566 /* check the new mode is allowed */
567 err = regulator_check_mode(rdev, mode);
569 rdev->desc->ops->set_mode(rdev, mode);
572 static int suspend_set_state(struct regulator_dev *rdev,
573 struct regulator_state *rstate)
577 /* enable & disable are mandatory for suspend control */
578 if (!rdev->desc->ops->set_suspend_enable ||
579 !rdev->desc->ops->set_suspend_disable) {
580 printk(KERN_ERR "%s: no way to set suspend state\n",
586 ret = rdev->desc->ops->set_suspend_enable(rdev);
588 ret = rdev->desc->ops->set_suspend_disable(rdev);
590 printk(KERN_ERR "%s: failed to enabled/disable\n", __func__);
594 if (rdev->desc->ops->set_suspend_voltage && rstate->uV > 0) {
595 ret = rdev->desc->ops->set_suspend_voltage(rdev, rstate->uV);
597 printk(KERN_ERR "%s: failed to set voltage\n",
603 if (rdev->desc->ops->set_suspend_mode && rstate->mode > 0) {
604 ret = rdev->desc->ops->set_suspend_mode(rdev, rstate->mode);
606 printk(KERN_ERR "%s: failed to set mode\n", __func__);
613 /* locks held by caller */
614 static int suspend_prepare(struct regulator_dev *rdev, suspend_state_t state)
616 if (!rdev->constraints)
620 case PM_SUSPEND_STANDBY:
621 return suspend_set_state(rdev,
622 &rdev->constraints->state_standby);
624 return suspend_set_state(rdev,
625 &rdev->constraints->state_mem);
627 return suspend_set_state(rdev,
628 &rdev->constraints->state_disk);
634 static void print_constraints(struct regulator_dev *rdev)
636 struct regulation_constraints *constraints = rdev->constraints;
640 if (rdev->desc->type == REGULATOR_VOLTAGE) {
641 if (constraints->min_uV == constraints->max_uV)
642 count = sprintf(buf, "%d mV ",
643 constraints->min_uV / 1000);
645 count = sprintf(buf, "%d <--> %d mV ",
646 constraints->min_uV / 1000,
647 constraints->max_uV / 1000);
649 if (constraints->min_uA == constraints->max_uA)
650 count = sprintf(buf, "%d mA ",
651 constraints->min_uA / 1000);
653 count = sprintf(buf, "%d <--> %d mA ",
654 constraints->min_uA / 1000,
655 constraints->max_uA / 1000);
657 if (constraints->valid_modes_mask & REGULATOR_MODE_FAST)
658 count += sprintf(buf + count, "fast ");
659 if (constraints->valid_modes_mask & REGULATOR_MODE_NORMAL)
660 count += sprintf(buf + count, "normal ");
661 if (constraints->valid_modes_mask & REGULATOR_MODE_IDLE)
662 count += sprintf(buf + count, "idle ");
663 if (constraints->valid_modes_mask & REGULATOR_MODE_STANDBY)
664 count += sprintf(buf + count, "standby");
666 printk(KERN_INFO "regulator: %s: %s\n", rdev->desc->name, buf);
670 * set_machine_constraints - sets regulator constraints
671 * @rdev: regulator source
672 * @constraints: constraints to apply
674 * Allows platform initialisation code to define and constrain
675 * regulator circuits e.g. valid voltage/current ranges, etc. NOTE:
676 * Constraints *must* be set by platform code in order for some
677 * regulator operations to proceed i.e. set_voltage, set_current_limit,
680 static int set_machine_constraints(struct regulator_dev *rdev,
681 struct regulation_constraints *constraints)
685 struct regulator_ops *ops = rdev->desc->ops;
687 if (constraints->name)
688 name = constraints->name;
689 else if (rdev->desc->name)
690 name = rdev->desc->name;
694 /* constrain machine-level voltage specs to fit
695 * the actual range supported by this regulator.
697 if (ops->list_voltage && rdev->desc->n_voltages) {
698 int count = rdev->desc->n_voltages;
700 int min_uV = INT_MAX;
701 int max_uV = INT_MIN;
702 int cmin = constraints->min_uV;
703 int cmax = constraints->max_uV;
705 /* it's safe to autoconfigure fixed-voltage supplies */
706 if (count == 1 && !cmin) {
711 /* voltage constraints are optional */
712 if ((cmin == 0) && (cmax == 0))
715 /* else require explicit machine-level constraints */
716 if (cmin <= 0 || cmax <= 0 || cmax < cmin) {
717 pr_err("%s: %s '%s' voltage constraints\n",
718 __func__, "invalid", name);
723 /* initial: [cmin..cmax] valid, [min_uV..max_uV] not */
724 for (i = 0; i < count; i++) {
727 value = ops->list_voltage(rdev, i);
731 /* maybe adjust [min_uV..max_uV] */
732 if (value >= cmin && value < min_uV)
734 if (value <= cmax && value > max_uV)
738 /* final: [min_uV..max_uV] valid iff constraints valid */
739 if (max_uV < min_uV) {
740 pr_err("%s: %s '%s' voltage constraints\n",
741 __func__, "unsupportable", name);
746 /* use regulator's subset of machine constraints */
747 if (constraints->min_uV < min_uV) {
748 pr_debug("%s: override '%s' %s, %d -> %d\n",
749 __func__, name, "min_uV",
750 constraints->min_uV, min_uV);
751 constraints->min_uV = min_uV;
753 if (constraints->max_uV > max_uV) {
754 pr_debug("%s: override '%s' %s, %d -> %d\n",
755 __func__, name, "max_uV",
756 constraints->max_uV, max_uV);
757 constraints->max_uV = max_uV;
761 rdev->constraints = constraints;
763 /* do we need to apply the constraint voltage */
764 if (rdev->constraints->apply_uV &&
765 rdev->constraints->min_uV == rdev->constraints->max_uV &&
767 ret = ops->set_voltage(rdev,
768 rdev->constraints->min_uV, rdev->constraints->max_uV);
770 printk(KERN_ERR "%s: failed to apply %duV constraint to %s\n",
772 rdev->constraints->min_uV, name);
773 rdev->constraints = NULL;
778 /* do we need to setup our suspend state */
779 if (constraints->initial_state) {
780 ret = suspend_prepare(rdev, constraints->initial_state);
782 printk(KERN_ERR "%s: failed to set suspend state for %s\n",
784 rdev->constraints = NULL;
789 if (constraints->initial_mode) {
790 if (!ops->set_mode) {
791 printk(KERN_ERR "%s: no set_mode operation for %s\n",
797 ret = ops->set_mode(rdev, constraints->initial_mode);
800 "%s: failed to set initial mode for %s: %d\n",
801 __func__, name, ret);
806 /* If the constraints say the regulator should be on at this point
807 * and we have control then make sure it is enabled.
809 if ((constraints->always_on || constraints->boot_on) && ops->enable) {
810 ret = ops->enable(rdev);
812 printk(KERN_ERR "%s: failed to enable %s\n",
814 rdev->constraints = NULL;
819 print_constraints(rdev);
825 * set_supply - set regulator supply regulator
826 * @rdev: regulator name
827 * @supply_rdev: supply regulator name
829 * Called by platform initialisation code to set the supply regulator for this
830 * regulator. This ensures that a regulators supply will also be enabled by the
831 * core if it's child is enabled.
833 static int set_supply(struct regulator_dev *rdev,
834 struct regulator_dev *supply_rdev)
838 err = sysfs_create_link(&rdev->dev.kobj, &supply_rdev->dev.kobj,
842 "%s: could not add device link %s err %d\n",
843 __func__, supply_rdev->dev.kobj.name, err);
846 rdev->supply = supply_rdev;
847 list_add(&rdev->slist, &supply_rdev->supply_list);
853 * set_consumer_device_supply: Bind a regulator to a symbolic supply
854 * @rdev: regulator source
855 * @consumer_dev: device the supply applies to
856 * @supply: symbolic name for supply
858 * Allows platform initialisation code to map physical regulator
859 * sources to symbolic names for supplies for use by devices. Devices
860 * should use these symbolic names to request regulators, avoiding the
861 * need to provide board-specific regulator names as platform data.
863 static int set_consumer_device_supply(struct regulator_dev *rdev,
864 struct device *consumer_dev, const char *supply)
866 struct regulator_map *node;
871 list_for_each_entry(node, ®ulator_map_list, list) {
872 if (consumer_dev != node->dev)
874 if (strcmp(node->supply, supply) != 0)
877 dev_dbg(consumer_dev, "%s/%s is '%s' supply; fail %s/%s\n",
878 dev_name(&node->regulator->dev),
879 node->regulator->desc->name,
881 dev_name(&rdev->dev), rdev->desc->name);
885 node = kmalloc(sizeof(struct regulator_map), GFP_KERNEL);
889 node->regulator = rdev;
890 node->dev = consumer_dev;
891 node->supply = supply;
893 list_add(&node->list, ®ulator_map_list);
897 static void unset_consumer_device_supply(struct regulator_dev *rdev,
898 struct device *consumer_dev)
900 struct regulator_map *node, *n;
902 list_for_each_entry_safe(node, n, ®ulator_map_list, list) {
903 if (rdev == node->regulator &&
904 consumer_dev == node->dev) {
905 list_del(&node->list);
912 static void unset_regulator_supplies(struct regulator_dev *rdev)
914 struct regulator_map *node, *n;
916 list_for_each_entry_safe(node, n, ®ulator_map_list, list) {
917 if (rdev == node->regulator) {
918 list_del(&node->list);
925 #define REG_STR_SIZE 32
927 static struct regulator *create_regulator(struct regulator_dev *rdev,
929 const char *supply_name)
931 struct regulator *regulator;
932 char buf[REG_STR_SIZE];
935 regulator = kzalloc(sizeof(*regulator), GFP_KERNEL);
936 if (regulator == NULL)
939 mutex_lock(&rdev->mutex);
940 regulator->rdev = rdev;
941 list_add(®ulator->list, &rdev->consumer_list);
944 /* create a 'requested_microamps_name' sysfs entry */
945 size = scnprintf(buf, REG_STR_SIZE, "microamps_requested_%s",
947 if (size >= REG_STR_SIZE)
950 regulator->dev = dev;
951 regulator->dev_attr.attr.name = kstrdup(buf, GFP_KERNEL);
952 if (regulator->dev_attr.attr.name == NULL)
955 regulator->dev_attr.attr.owner = THIS_MODULE;
956 regulator->dev_attr.attr.mode = 0444;
957 regulator->dev_attr.show = device_requested_uA_show;
958 err = device_create_file(dev, ®ulator->dev_attr);
960 printk(KERN_WARNING "%s: could not add regulator_dev"
961 " load sysfs\n", __func__);
965 /* also add a link to the device sysfs entry */
966 size = scnprintf(buf, REG_STR_SIZE, "%s-%s",
967 dev->kobj.name, supply_name);
968 if (size >= REG_STR_SIZE)
971 regulator->supply_name = kstrdup(buf, GFP_KERNEL);
972 if (regulator->supply_name == NULL)
975 err = sysfs_create_link(&rdev->dev.kobj, &dev->kobj,
979 "%s: could not add device link %s err %d\n",
980 __func__, dev->kobj.name, err);
981 device_remove_file(dev, ®ulator->dev_attr);
985 mutex_unlock(&rdev->mutex);
988 kfree(regulator->supply_name);
990 device_remove_file(regulator->dev, ®ulator->dev_attr);
992 kfree(regulator->dev_attr.attr.name);
994 list_del(®ulator->list);
996 mutex_unlock(&rdev->mutex);
1001 * regulator_get - lookup and obtain a reference to a regulator.
1002 * @dev: device for regulator "consumer"
1003 * @id: Supply name or regulator ID.
1005 * Returns a struct regulator corresponding to the regulator producer,
1006 * or IS_ERR() condition containing errno.
1008 * Use of supply names configured via regulator_set_device_supply() is
1009 * strongly encouraged. It is recommended that the supply name used
1010 * should match the name used for the supply and/or the relevant
1011 * device pins in the datasheet.
1013 struct regulator *regulator_get(struct device *dev, const char *id)
1015 struct regulator_dev *rdev;
1016 struct regulator_map *map;
1017 struct regulator *regulator = ERR_PTR(-ENODEV);
1020 printk(KERN_ERR "regulator: get() with no identifier\n");
1024 mutex_lock(®ulator_list_mutex);
1026 list_for_each_entry(map, ®ulator_map_list, list) {
1027 if (dev == map->dev &&
1028 strcmp(map->supply, id) == 0) {
1029 rdev = map->regulator;
1033 mutex_unlock(®ulator_list_mutex);
1037 if (!try_module_get(rdev->owner))
1040 regulator = create_regulator(rdev, dev, id);
1041 if (regulator == NULL) {
1042 regulator = ERR_PTR(-ENOMEM);
1043 module_put(rdev->owner);
1047 mutex_unlock(®ulator_list_mutex);
1050 EXPORT_SYMBOL_GPL(regulator_get);
1053 * regulator_put - "free" the regulator source
1054 * @regulator: regulator source
1056 * Note: drivers must ensure that all regulator_enable calls made on this
1057 * regulator source are balanced by regulator_disable calls prior to calling
1060 void regulator_put(struct regulator *regulator)
1062 struct regulator_dev *rdev;
1064 if (regulator == NULL || IS_ERR(regulator))
1067 mutex_lock(®ulator_list_mutex);
1068 rdev = regulator->rdev;
1070 /* remove any sysfs entries */
1071 if (regulator->dev) {
1072 sysfs_remove_link(&rdev->dev.kobj, regulator->supply_name);
1073 kfree(regulator->supply_name);
1074 device_remove_file(regulator->dev, ®ulator->dev_attr);
1075 kfree(regulator->dev_attr.attr.name);
1077 list_del(®ulator->list);
1080 module_put(rdev->owner);
1081 mutex_unlock(®ulator_list_mutex);
1083 EXPORT_SYMBOL_GPL(regulator_put);
1085 /* locks held by regulator_enable() */
1086 static int _regulator_enable(struct regulator_dev *rdev)
1090 if (!rdev->constraints) {
1091 printk(KERN_ERR "%s: %s has no constraints\n",
1092 __func__, rdev->desc->name);
1096 /* do we need to enable the supply regulator first */
1098 ret = _regulator_enable(rdev->supply);
1100 printk(KERN_ERR "%s: failed to enable %s: %d\n",
1101 __func__, rdev->desc->name, ret);
1106 /* check voltage and requested load before enabling */
1107 if (rdev->desc->ops->enable) {
1109 if (rdev->constraints &&
1110 (rdev->constraints->valid_ops_mask &
1111 REGULATOR_CHANGE_DRMS))
1112 drms_uA_update(rdev);
1114 ret = rdev->desc->ops->enable(rdev);
1116 printk(KERN_ERR "%s: failed to enable %s: %d\n",
1117 __func__, rdev->desc->name, ret);
1128 * regulator_enable - enable regulator output
1129 * @regulator: regulator source
1131 * Request that the regulator be enabled with the regulator output at
1132 * the predefined voltage or current value. Calls to regulator_enable()
1133 * must be balanced with calls to regulator_disable().
1135 * NOTE: the output value can be set by other drivers, boot loader or may be
1136 * hardwired in the regulator.
1138 int regulator_enable(struct regulator *regulator)
1140 struct regulator_dev *rdev = regulator->rdev;
1143 mutex_lock(&rdev->mutex);
1144 ret = _regulator_enable(rdev);
1145 mutex_unlock(&rdev->mutex);
1148 EXPORT_SYMBOL_GPL(regulator_enable);
1150 /* locks held by regulator_disable() */
1151 static int _regulator_disable(struct regulator_dev *rdev)
1155 if (WARN(rdev->use_count <= 0,
1156 "unbalanced disables for %s\n",
1160 /* are we the last user and permitted to disable ? */
1161 if (rdev->use_count == 1 && !rdev->constraints->always_on) {
1163 /* we are last user */
1164 if (rdev->desc->ops->disable) {
1165 ret = rdev->desc->ops->disable(rdev);
1167 printk(KERN_ERR "%s: failed to disable %s\n",
1168 __func__, rdev->desc->name);
1173 /* decrease our supplies ref count and disable if required */
1175 _regulator_disable(rdev->supply);
1177 rdev->use_count = 0;
1178 } else if (rdev->use_count > 1) {
1180 if (rdev->constraints &&
1181 (rdev->constraints->valid_ops_mask &
1182 REGULATOR_CHANGE_DRMS))
1183 drms_uA_update(rdev);
1191 * regulator_disable - disable regulator output
1192 * @regulator: regulator source
1194 * Disable the regulator output voltage or current. Calls to
1195 * regulator_enable() must be balanced with calls to
1196 * regulator_disable().
1198 * NOTE: this will only disable the regulator output if no other consumer
1199 * devices have it enabled, the regulator device supports disabling and
1200 * machine constraints permit this operation.
1202 int regulator_disable(struct regulator *regulator)
1204 struct regulator_dev *rdev = regulator->rdev;
1207 mutex_lock(&rdev->mutex);
1208 ret = _regulator_disable(rdev);
1209 mutex_unlock(&rdev->mutex);
1212 EXPORT_SYMBOL_GPL(regulator_disable);
1214 /* locks held by regulator_force_disable() */
1215 static int _regulator_force_disable(struct regulator_dev *rdev)
1220 if (rdev->desc->ops->disable) {
1221 /* ah well, who wants to live forever... */
1222 ret = rdev->desc->ops->disable(rdev);
1224 printk(KERN_ERR "%s: failed to force disable %s\n",
1225 __func__, rdev->desc->name);
1228 /* notify other consumers that power has been forced off */
1229 _notifier_call_chain(rdev, REGULATOR_EVENT_FORCE_DISABLE,
1233 /* decrease our supplies ref count and disable if required */
1235 _regulator_disable(rdev->supply);
1237 rdev->use_count = 0;
1242 * regulator_force_disable - force disable regulator output
1243 * @regulator: regulator source
1245 * Forcibly disable the regulator output voltage or current.
1246 * NOTE: this *will* disable the regulator output even if other consumer
1247 * devices have it enabled. This should be used for situations when device
1248 * damage will likely occur if the regulator is not disabled (e.g. over temp).
1250 int regulator_force_disable(struct regulator *regulator)
1254 mutex_lock(®ulator->rdev->mutex);
1255 regulator->uA_load = 0;
1256 ret = _regulator_force_disable(regulator->rdev);
1257 mutex_unlock(®ulator->rdev->mutex);
1260 EXPORT_SYMBOL_GPL(regulator_force_disable);
1262 static int _regulator_is_enabled(struct regulator_dev *rdev)
1266 mutex_lock(&rdev->mutex);
1269 if (!rdev->desc->ops->is_enabled) {
1274 ret = rdev->desc->ops->is_enabled(rdev);
1276 mutex_unlock(&rdev->mutex);
1281 * regulator_is_enabled - is the regulator output enabled
1282 * @regulator: regulator source
1284 * Returns positive if the regulator driver backing the source/client
1285 * has requested that the device be enabled, zero if it hasn't, else a
1286 * negative errno code.
1288 * Note that the device backing this regulator handle can have multiple
1289 * users, so it might be enabled even if regulator_enable() was never
1290 * called for this particular source.
1292 int regulator_is_enabled(struct regulator *regulator)
1294 return _regulator_is_enabled(regulator->rdev);
1296 EXPORT_SYMBOL_GPL(regulator_is_enabled);
1299 * regulator_count_voltages - count regulator_list_voltage() selectors
1300 * @regulator: regulator source
1302 * Returns number of selectors, or negative errno. Selectors are
1303 * numbered starting at zero, and typically correspond to bitfields
1304 * in hardware registers.
1306 int regulator_count_voltages(struct regulator *regulator)
1308 struct regulator_dev *rdev = regulator->rdev;
1310 return rdev->desc->n_voltages ? : -EINVAL;
1312 EXPORT_SYMBOL_GPL(regulator_count_voltages);
1315 * regulator_list_voltage - enumerate supported voltages
1316 * @regulator: regulator source
1317 * @selector: identify voltage to list
1318 * Context: can sleep
1320 * Returns a voltage that can be passed to @regulator_set_voltage(),
1321 * zero if this selector code can't be used on this sytem, or a
1324 int regulator_list_voltage(struct regulator *regulator, unsigned selector)
1326 struct regulator_dev *rdev = regulator->rdev;
1327 struct regulator_ops *ops = rdev->desc->ops;
1330 if (!ops->list_voltage || selector >= rdev->desc->n_voltages)
1333 mutex_lock(&rdev->mutex);
1334 ret = ops->list_voltage(rdev, selector);
1335 mutex_unlock(&rdev->mutex);
1338 if (ret < rdev->constraints->min_uV)
1340 else if (ret > rdev->constraints->max_uV)
1346 EXPORT_SYMBOL_GPL(regulator_list_voltage);
1349 * regulator_set_voltage - set regulator output voltage
1350 * @regulator: regulator source
1351 * @min_uV: Minimum required voltage in uV
1352 * @max_uV: Maximum acceptable voltage in uV
1354 * Sets a voltage regulator to the desired output voltage. This can be set
1355 * during any regulator state. IOW, regulator can be disabled or enabled.
1357 * If the regulator is enabled then the voltage will change to the new value
1358 * immediately otherwise if the regulator is disabled the regulator will
1359 * output at the new voltage when enabled.
1361 * NOTE: If the regulator is shared between several devices then the lowest
1362 * request voltage that meets the system constraints will be used.
1363 * Regulator system constraints must be set for this regulator before
1364 * calling this function otherwise this call will fail.
1366 int regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV)
1368 struct regulator_dev *rdev = regulator->rdev;
1371 mutex_lock(&rdev->mutex);
1374 if (!rdev->desc->ops->set_voltage) {
1379 /* constraints check */
1380 ret = regulator_check_voltage(rdev, &min_uV, &max_uV);
1383 regulator->min_uV = min_uV;
1384 regulator->max_uV = max_uV;
1385 ret = rdev->desc->ops->set_voltage(rdev, min_uV, max_uV);
1388 _notifier_call_chain(rdev, REGULATOR_EVENT_VOLTAGE_CHANGE, NULL);
1389 mutex_unlock(&rdev->mutex);
1392 EXPORT_SYMBOL_GPL(regulator_set_voltage);
1394 static int _regulator_get_voltage(struct regulator_dev *rdev)
1397 if (rdev->desc->ops->get_voltage)
1398 return rdev->desc->ops->get_voltage(rdev);
1404 * regulator_get_voltage - get regulator output voltage
1405 * @regulator: regulator source
1407 * This returns the current regulator voltage in uV.
1409 * NOTE: If the regulator is disabled it will return the voltage value. This
1410 * function should not be used to determine regulator state.
1412 int regulator_get_voltage(struct regulator *regulator)
1416 mutex_lock(®ulator->rdev->mutex);
1418 ret = _regulator_get_voltage(regulator->rdev);
1420 mutex_unlock(®ulator->rdev->mutex);
1424 EXPORT_SYMBOL_GPL(regulator_get_voltage);
1427 * regulator_set_current_limit - set regulator output current limit
1428 * @regulator: regulator source
1429 * @min_uA: Minimuum supported current in uA
1430 * @max_uA: Maximum supported current in uA
1432 * Sets current sink to the desired output current. This can be set during
1433 * any regulator state. IOW, regulator can be disabled or enabled.
1435 * If the regulator is enabled then the current will change to the new value
1436 * immediately otherwise if the regulator is disabled the regulator will
1437 * output at the new current when enabled.
1439 * NOTE: Regulator system constraints must be set for this regulator before
1440 * calling this function otherwise this call will fail.
1442 int regulator_set_current_limit(struct regulator *regulator,
1443 int min_uA, int max_uA)
1445 struct regulator_dev *rdev = regulator->rdev;
1448 mutex_lock(&rdev->mutex);
1451 if (!rdev->desc->ops->set_current_limit) {
1456 /* constraints check */
1457 ret = regulator_check_current_limit(rdev, &min_uA, &max_uA);
1461 ret = rdev->desc->ops->set_current_limit(rdev, min_uA, max_uA);
1463 mutex_unlock(&rdev->mutex);
1466 EXPORT_SYMBOL_GPL(regulator_set_current_limit);
1468 static int _regulator_get_current_limit(struct regulator_dev *rdev)
1472 mutex_lock(&rdev->mutex);
1475 if (!rdev->desc->ops->get_current_limit) {
1480 ret = rdev->desc->ops->get_current_limit(rdev);
1482 mutex_unlock(&rdev->mutex);
1487 * regulator_get_current_limit - get regulator output current
1488 * @regulator: regulator source
1490 * This returns the current supplied by the specified current sink in uA.
1492 * NOTE: If the regulator is disabled it will return the current value. This
1493 * function should not be used to determine regulator state.
1495 int regulator_get_current_limit(struct regulator *regulator)
1497 return _regulator_get_current_limit(regulator->rdev);
1499 EXPORT_SYMBOL_GPL(regulator_get_current_limit);
1502 * regulator_set_mode - set regulator operating mode
1503 * @regulator: regulator source
1504 * @mode: operating mode - one of the REGULATOR_MODE constants
1506 * Set regulator operating mode to increase regulator efficiency or improve
1507 * regulation performance.
1509 * NOTE: Regulator system constraints must be set for this regulator before
1510 * calling this function otherwise this call will fail.
1512 int regulator_set_mode(struct regulator *regulator, unsigned int mode)
1514 struct regulator_dev *rdev = regulator->rdev;
1517 mutex_lock(&rdev->mutex);
1520 if (!rdev->desc->ops->set_mode) {
1525 /* constraints check */
1526 ret = regulator_check_mode(rdev, mode);
1530 ret = rdev->desc->ops->set_mode(rdev, mode);
1532 mutex_unlock(&rdev->mutex);
1535 EXPORT_SYMBOL_GPL(regulator_set_mode);
1537 static unsigned int _regulator_get_mode(struct regulator_dev *rdev)
1541 mutex_lock(&rdev->mutex);
1544 if (!rdev->desc->ops->get_mode) {
1549 ret = rdev->desc->ops->get_mode(rdev);
1551 mutex_unlock(&rdev->mutex);
1556 * regulator_get_mode - get regulator operating mode
1557 * @regulator: regulator source
1559 * Get the current regulator operating mode.
1561 unsigned int regulator_get_mode(struct regulator *regulator)
1563 return _regulator_get_mode(regulator->rdev);
1565 EXPORT_SYMBOL_GPL(regulator_get_mode);
1568 * regulator_set_optimum_mode - set regulator optimum operating mode
1569 * @regulator: regulator source
1570 * @uA_load: load current
1572 * Notifies the regulator core of a new device load. This is then used by
1573 * DRMS (if enabled by constraints) to set the most efficient regulator
1574 * operating mode for the new regulator loading.
1576 * Consumer devices notify their supply regulator of the maximum power
1577 * they will require (can be taken from device datasheet in the power
1578 * consumption tables) when they change operational status and hence power
1579 * state. Examples of operational state changes that can affect power
1580 * consumption are :-
1582 * o Device is opened / closed.
1583 * o Device I/O is about to begin or has just finished.
1584 * o Device is idling in between work.
1586 * This information is also exported via sysfs to userspace.
1588 * DRMS will sum the total requested load on the regulator and change
1589 * to the most efficient operating mode if platform constraints allow.
1591 * Returns the new regulator mode or error.
1593 int regulator_set_optimum_mode(struct regulator *regulator, int uA_load)
1595 struct regulator_dev *rdev = regulator->rdev;
1596 struct regulator *consumer;
1597 int ret, output_uV, input_uV, total_uA_load = 0;
1600 mutex_lock(&rdev->mutex);
1602 regulator->uA_load = uA_load;
1603 ret = regulator_check_drms(rdev);
1609 if (!rdev->desc->ops->get_optimum_mode)
1612 /* get output voltage */
1613 output_uV = rdev->desc->ops->get_voltage(rdev);
1614 if (output_uV <= 0) {
1615 printk(KERN_ERR "%s: invalid output voltage found for %s\n",
1616 __func__, rdev->desc->name);
1620 /* get input voltage */
1621 if (rdev->supply && rdev->supply->desc->ops->get_voltage)
1622 input_uV = rdev->supply->desc->ops->get_voltage(rdev->supply);
1624 input_uV = rdev->constraints->input_uV;
1625 if (input_uV <= 0) {
1626 printk(KERN_ERR "%s: invalid input voltage found for %s\n",
1627 __func__, rdev->desc->name);
1631 /* calc total requested load for this regulator */
1632 list_for_each_entry(consumer, &rdev->consumer_list, list)
1633 total_uA_load += consumer->uA_load;
1635 mode = rdev->desc->ops->get_optimum_mode(rdev,
1636 input_uV, output_uV,
1638 ret = regulator_check_mode(rdev, mode);
1640 printk(KERN_ERR "%s: failed to get optimum mode for %s @"
1641 " %d uA %d -> %d uV\n", __func__, rdev->desc->name,
1642 total_uA_load, input_uV, output_uV);
1646 ret = rdev->desc->ops->set_mode(rdev, mode);
1648 printk(KERN_ERR "%s: failed to set optimum mode %x for %s\n",
1649 __func__, mode, rdev->desc->name);
1654 mutex_unlock(&rdev->mutex);
1657 EXPORT_SYMBOL_GPL(regulator_set_optimum_mode);
1660 * regulator_register_notifier - register regulator event notifier
1661 * @regulator: regulator source
1662 * @nb: notifier block
1664 * Register notifier block to receive regulator events.
1666 int regulator_register_notifier(struct regulator *regulator,
1667 struct notifier_block *nb)
1669 return blocking_notifier_chain_register(®ulator->rdev->notifier,
1672 EXPORT_SYMBOL_GPL(regulator_register_notifier);
1675 * regulator_unregister_notifier - unregister regulator event notifier
1676 * @regulator: regulator source
1677 * @nb: notifier block
1679 * Unregister regulator event notifier block.
1681 int regulator_unregister_notifier(struct regulator *regulator,
1682 struct notifier_block *nb)
1684 return blocking_notifier_chain_unregister(®ulator->rdev->notifier,
1687 EXPORT_SYMBOL_GPL(regulator_unregister_notifier);
1689 /* notify regulator consumers and downstream regulator consumers.
1690 * Note mutex must be held by caller.
1692 static void _notifier_call_chain(struct regulator_dev *rdev,
1693 unsigned long event, void *data)
1695 struct regulator_dev *_rdev;
1697 /* call rdev chain first */
1698 blocking_notifier_call_chain(&rdev->notifier, event, NULL);
1700 /* now notify regulator we supply */
1701 list_for_each_entry(_rdev, &rdev->supply_list, slist) {
1702 mutex_lock(&_rdev->mutex);
1703 _notifier_call_chain(_rdev, event, data);
1704 mutex_unlock(&_rdev->mutex);
1709 * regulator_bulk_get - get multiple regulator consumers
1711 * @dev: Device to supply
1712 * @num_consumers: Number of consumers to register
1713 * @consumers: Configuration of consumers; clients are stored here.
1715 * @return 0 on success, an errno on failure.
1717 * This helper function allows drivers to get several regulator
1718 * consumers in one operation. If any of the regulators cannot be
1719 * acquired then any regulators that were allocated will be freed
1720 * before returning to the caller.
1722 int regulator_bulk_get(struct device *dev, int num_consumers,
1723 struct regulator_bulk_data *consumers)
1728 for (i = 0; i < num_consumers; i++)
1729 consumers[i].consumer = NULL;
1731 for (i = 0; i < num_consumers; i++) {
1732 consumers[i].consumer = regulator_get(dev,
1733 consumers[i].supply);
1734 if (IS_ERR(consumers[i].consumer)) {
1735 dev_err(dev, "Failed to get supply '%s'\n",
1736 consumers[i].supply);
1737 ret = PTR_ERR(consumers[i].consumer);
1738 consumers[i].consumer = NULL;
1746 for (i = 0; i < num_consumers && consumers[i].consumer; i++)
1747 regulator_put(consumers[i].consumer);
1751 EXPORT_SYMBOL_GPL(regulator_bulk_get);
1754 * regulator_bulk_enable - enable multiple regulator consumers
1756 * @num_consumers: Number of consumers
1757 * @consumers: Consumer data; clients are stored here.
1758 * @return 0 on success, an errno on failure
1760 * This convenience API allows consumers to enable multiple regulator
1761 * clients in a single API call. If any consumers cannot be enabled
1762 * then any others that were enabled will be disabled again prior to
1765 int regulator_bulk_enable(int num_consumers,
1766 struct regulator_bulk_data *consumers)
1771 for (i = 0; i < num_consumers; i++) {
1772 ret = regulator_enable(consumers[i].consumer);
1780 printk(KERN_ERR "Failed to enable %s\n", consumers[i].supply);
1781 for (i = 0; i < num_consumers; i++)
1782 regulator_disable(consumers[i].consumer);
1786 EXPORT_SYMBOL_GPL(regulator_bulk_enable);
1789 * regulator_bulk_disable - disable multiple regulator consumers
1791 * @num_consumers: Number of consumers
1792 * @consumers: Consumer data; clients are stored here.
1793 * @return 0 on success, an errno on failure
1795 * This convenience API allows consumers to disable multiple regulator
1796 * clients in a single API call. If any consumers cannot be enabled
1797 * then any others that were disabled will be disabled again prior to
1800 int regulator_bulk_disable(int num_consumers,
1801 struct regulator_bulk_data *consumers)
1806 for (i = 0; i < num_consumers; i++) {
1807 ret = regulator_disable(consumers[i].consumer);
1815 printk(KERN_ERR "Failed to disable %s\n", consumers[i].supply);
1816 for (i = 0; i < num_consumers; i++)
1817 regulator_enable(consumers[i].consumer);
1821 EXPORT_SYMBOL_GPL(regulator_bulk_disable);
1824 * regulator_bulk_free - free multiple regulator consumers
1826 * @num_consumers: Number of consumers
1827 * @consumers: Consumer data; clients are stored here.
1829 * This convenience API allows consumers to free multiple regulator
1830 * clients in a single API call.
1832 void regulator_bulk_free(int num_consumers,
1833 struct regulator_bulk_data *consumers)
1837 for (i = 0; i < num_consumers; i++) {
1838 regulator_put(consumers[i].consumer);
1839 consumers[i].consumer = NULL;
1842 EXPORT_SYMBOL_GPL(regulator_bulk_free);
1845 * regulator_notifier_call_chain - call regulator event notifier
1846 * @rdev: regulator source
1847 * @event: notifier block
1848 * @data: callback-specific data.
1850 * Called by regulator drivers to notify clients a regulator event has
1851 * occurred. We also notify regulator clients downstream.
1852 * Note lock must be held by caller.
1854 int regulator_notifier_call_chain(struct regulator_dev *rdev,
1855 unsigned long event, void *data)
1857 _notifier_call_chain(rdev, event, data);
1861 EXPORT_SYMBOL_GPL(regulator_notifier_call_chain);
1864 * To avoid cluttering sysfs (and memory) with useless state, only
1865 * create attributes that can be meaningfully displayed.
1867 static int add_regulator_attributes(struct regulator_dev *rdev)
1869 struct device *dev = &rdev->dev;
1870 struct regulator_ops *ops = rdev->desc->ops;
1873 /* some attributes need specific methods to be displayed */
1874 if (ops->get_voltage) {
1875 status = device_create_file(dev, &dev_attr_microvolts);
1879 if (ops->get_current_limit) {
1880 status = device_create_file(dev, &dev_attr_microamps);
1884 if (ops->get_mode) {
1885 status = device_create_file(dev, &dev_attr_opmode);
1889 if (ops->is_enabled) {
1890 status = device_create_file(dev, &dev_attr_state);
1894 if (ops->get_status) {
1895 status = device_create_file(dev, &dev_attr_status);
1900 /* some attributes are type-specific */
1901 if (rdev->desc->type == REGULATOR_CURRENT) {
1902 status = device_create_file(dev, &dev_attr_requested_microamps);
1907 /* all the other attributes exist to support constraints;
1908 * don't show them if there are no constraints, or if the
1909 * relevant supporting methods are missing.
1911 if (!rdev->constraints)
1914 /* constraints need specific supporting methods */
1915 if (ops->set_voltage) {
1916 status = device_create_file(dev, &dev_attr_min_microvolts);
1919 status = device_create_file(dev, &dev_attr_max_microvolts);
1923 if (ops->set_current_limit) {
1924 status = device_create_file(dev, &dev_attr_min_microamps);
1927 status = device_create_file(dev, &dev_attr_max_microamps);
1932 /* suspend mode constraints need multiple supporting methods */
1933 if (!(ops->set_suspend_enable && ops->set_suspend_disable))
1936 status = device_create_file(dev, &dev_attr_suspend_standby_state);
1939 status = device_create_file(dev, &dev_attr_suspend_mem_state);
1942 status = device_create_file(dev, &dev_attr_suspend_disk_state);
1946 if (ops->set_suspend_voltage) {
1947 status = device_create_file(dev,
1948 &dev_attr_suspend_standby_microvolts);
1951 status = device_create_file(dev,
1952 &dev_attr_suspend_mem_microvolts);
1955 status = device_create_file(dev,
1956 &dev_attr_suspend_disk_microvolts);
1961 if (ops->set_suspend_mode) {
1962 status = device_create_file(dev,
1963 &dev_attr_suspend_standby_mode);
1966 status = device_create_file(dev,
1967 &dev_attr_suspend_mem_mode);
1970 status = device_create_file(dev,
1971 &dev_attr_suspend_disk_mode);
1980 * regulator_register - register regulator
1981 * @regulator_desc: regulator to register
1982 * @dev: struct device for the regulator
1983 * @init_data: platform provided init data, passed through by driver
1984 * @driver_data: private regulator data
1986 * Called by regulator drivers to register a regulator.
1987 * Returns 0 on success.
1989 struct regulator_dev *regulator_register(struct regulator_desc *regulator_desc,
1990 struct device *dev, struct regulator_init_data *init_data,
1993 static atomic_t regulator_no = ATOMIC_INIT(0);
1994 struct regulator_dev *rdev;
1997 if (regulator_desc == NULL)
1998 return ERR_PTR(-EINVAL);
2000 if (regulator_desc->name == NULL || regulator_desc->ops == NULL)
2001 return ERR_PTR(-EINVAL);
2003 if (!regulator_desc->type == REGULATOR_VOLTAGE &&
2004 !regulator_desc->type == REGULATOR_CURRENT)
2005 return ERR_PTR(-EINVAL);
2008 return ERR_PTR(-EINVAL);
2010 rdev = kzalloc(sizeof(struct regulator_dev), GFP_KERNEL);
2012 return ERR_PTR(-ENOMEM);
2014 mutex_lock(®ulator_list_mutex);
2016 mutex_init(&rdev->mutex);
2017 rdev->reg_data = driver_data;
2018 rdev->owner = regulator_desc->owner;
2019 rdev->desc = regulator_desc;
2020 INIT_LIST_HEAD(&rdev->consumer_list);
2021 INIT_LIST_HEAD(&rdev->supply_list);
2022 INIT_LIST_HEAD(&rdev->list);
2023 INIT_LIST_HEAD(&rdev->slist);
2024 BLOCKING_INIT_NOTIFIER_HEAD(&rdev->notifier);
2026 /* preform any regulator specific init */
2027 if (init_data->regulator_init) {
2028 ret = init_data->regulator_init(rdev->reg_data);
2033 /* register with sysfs */
2034 rdev->dev.class = ®ulator_class;
2035 rdev->dev.parent = dev;
2036 dev_set_name(&rdev->dev, "regulator.%d",
2037 atomic_inc_return(®ulator_no) - 1);
2038 ret = device_register(&rdev->dev);
2042 dev_set_drvdata(&rdev->dev, rdev);
2044 /* set regulator constraints */
2045 ret = set_machine_constraints(rdev, &init_data->constraints);
2049 /* add attributes supported by this regulator */
2050 ret = add_regulator_attributes(rdev);
2054 /* set supply regulator if it exists */
2055 if (init_data->supply_regulator_dev) {
2056 ret = set_supply(rdev,
2057 dev_get_drvdata(init_data->supply_regulator_dev));
2062 /* add consumers devices */
2063 for (i = 0; i < init_data->num_consumer_supplies; i++) {
2064 ret = set_consumer_device_supply(rdev,
2065 init_data->consumer_supplies[i].dev,
2066 init_data->consumer_supplies[i].supply);
2068 for (--i; i >= 0; i--)
2069 unset_consumer_device_supply(rdev,
2070 init_data->consumer_supplies[i].dev);
2075 list_add(&rdev->list, ®ulator_list);
2077 mutex_unlock(®ulator_list_mutex);
2081 device_unregister(&rdev->dev);
2084 rdev = ERR_PTR(ret);
2087 EXPORT_SYMBOL_GPL(regulator_register);
2090 * regulator_unregister - unregister regulator
2091 * @rdev: regulator to unregister
2093 * Called by regulator drivers to unregister a regulator.
2095 void regulator_unregister(struct regulator_dev *rdev)
2100 mutex_lock(®ulator_list_mutex);
2101 unset_regulator_supplies(rdev);
2102 list_del(&rdev->list);
2104 sysfs_remove_link(&rdev->dev.kobj, "supply");
2105 device_unregister(&rdev->dev);
2106 mutex_unlock(®ulator_list_mutex);
2108 EXPORT_SYMBOL_GPL(regulator_unregister);
2111 * regulator_suspend_prepare - prepare regulators for system wide suspend
2112 * @state: system suspend state
2114 * Configure each regulator with it's suspend operating parameters for state.
2115 * This will usually be called by machine suspend code prior to supending.
2117 int regulator_suspend_prepare(suspend_state_t state)
2119 struct regulator_dev *rdev;
2122 /* ON is handled by regulator active state */
2123 if (state == PM_SUSPEND_ON)
2126 mutex_lock(®ulator_list_mutex);
2127 list_for_each_entry(rdev, ®ulator_list, list) {
2129 mutex_lock(&rdev->mutex);
2130 ret = suspend_prepare(rdev, state);
2131 mutex_unlock(&rdev->mutex);
2134 printk(KERN_ERR "%s: failed to prepare %s\n",
2135 __func__, rdev->desc->name);
2140 mutex_unlock(®ulator_list_mutex);
2143 EXPORT_SYMBOL_GPL(regulator_suspend_prepare);
2146 * rdev_get_drvdata - get rdev regulator driver data
2149 * Get rdev regulator driver private data. This call can be used in the
2150 * regulator driver context.
2152 void *rdev_get_drvdata(struct regulator_dev *rdev)
2154 return rdev->reg_data;
2156 EXPORT_SYMBOL_GPL(rdev_get_drvdata);
2159 * regulator_get_drvdata - get regulator driver data
2160 * @regulator: regulator
2162 * Get regulator driver private data. This call can be used in the consumer
2163 * driver context when non API regulator specific functions need to be called.
2165 void *regulator_get_drvdata(struct regulator *regulator)
2167 return regulator->rdev->reg_data;
2169 EXPORT_SYMBOL_GPL(regulator_get_drvdata);
2172 * regulator_set_drvdata - set regulator driver data
2173 * @regulator: regulator
2176 void regulator_set_drvdata(struct regulator *regulator, void *data)
2178 regulator->rdev->reg_data = data;
2180 EXPORT_SYMBOL_GPL(regulator_set_drvdata);
2183 * regulator_get_id - get regulator ID
2186 int rdev_get_id(struct regulator_dev *rdev)
2188 return rdev->desc->id;
2190 EXPORT_SYMBOL_GPL(rdev_get_id);
2192 struct device *rdev_get_dev(struct regulator_dev *rdev)
2196 EXPORT_SYMBOL_GPL(rdev_get_dev);
2198 void *regulator_get_init_drvdata(struct regulator_init_data *reg_init_data)
2200 return reg_init_data->driver_data;
2202 EXPORT_SYMBOL_GPL(regulator_get_init_drvdata);
2204 static int __init regulator_init(void)
2206 printk(KERN_INFO "regulator: core version %s\n", REGULATOR_VERSION);
2207 return class_register(®ulator_class);
2210 /* init early to allow our consumers to complete system booting */
2211 core_initcall(regulator_init);