/drivers/regulator/core.c
C | 2961 lines | 1949 code | 426 blank | 586 comment | 401 complexity | 2b3d507c313a74f8f6669437141af36c MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0
Large files files are truncated, but you can click here to view the full file
1/*
2 * core.c -- Voltage/Current Regulator framework.
3 *
4 * Copyright 2007, 2008 Wolfson Microelectronics PLC.
5 * Copyright 2008 SlimLogic Ltd.
6 *
7 * Author: Liam Girdwood <lrg@slimlogic.co.uk>
8 *
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License as published by the
11 * Free Software Foundation; either version 2 of the License, or (at your
12 * option) any later version.
13 *
14 */
15
16#define pr_fmt(fmt) "%s: " fmt, __func__
17
18#include <linux/kernel.h>
19#include <linux/init.h>
20#include <linux/debugfs.h>
21#include <linux/device.h>
22#include <linux/slab.h>
23#include <linux/err.h>
24#include <linux/mutex.h>
25#include <linux/suspend.h>
26#include <linux/delay.h>
27#include <linux/regulator/consumer.h>
28#include <linux/regulator/driver.h>
29#include <linux/regulator/machine.h>
30
31#define CREATE_TRACE_POINTS
32#include <trace/events/regulator.h>
33
34#include "dummy.h"
35
36#define rdev_err(rdev, fmt, ...) \
37 pr_err("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
38#define rdev_warn(rdev, fmt, ...) \
39 pr_warn("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
40#define rdev_info(rdev, fmt, ...) \
41 pr_info("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
42#define rdev_dbg(rdev, fmt, ...) \
43 pr_debug("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
44
45static DEFINE_MUTEX(regulator_list_mutex);
46static LIST_HEAD(regulator_list);
47static LIST_HEAD(regulator_map_list);
48static bool has_full_constraints;
49static bool board_wants_dummy_regulator;
50
51#ifdef CONFIG_DEBUG_FS
52static struct dentry *debugfs_root;
53#endif
54
55/*
56 * struct regulator_map
57 *
58 * Used to provide symbolic supply names to devices.
59 */
60struct regulator_map {
61 struct list_head list;
62 const char *dev_name; /* The dev_name() for the consumer */
63 const char *supply;
64 struct regulator_dev *regulator;
65};
66
67/*
68 * struct regulator
69 *
70 * One for each consumer device.
71 */
72struct regulator {
73 struct device *dev;
74 struct list_head list;
75 int uA_load;
76 int min_uV;
77 int max_uV;
78 char *supply_name;
79 struct device_attribute dev_attr;
80 struct regulator_dev *rdev;
81};
82
83static int _regulator_is_enabled(struct regulator_dev *rdev);
84static int _regulator_disable(struct regulator_dev *rdev,
85 struct regulator_dev **supply_rdev_ptr);
86static int _regulator_get_voltage(struct regulator_dev *rdev);
87static int _regulator_get_current_limit(struct regulator_dev *rdev);
88static unsigned int _regulator_get_mode(struct regulator_dev *rdev);
89static void _notifier_call_chain(struct regulator_dev *rdev,
90 unsigned long event, void *data);
91static int _regulator_do_set_voltage(struct regulator_dev *rdev,
92 int min_uV, int max_uV);
93
94static const char *rdev_get_name(struct regulator_dev *rdev)
95{
96 if (rdev->constraints && rdev->constraints->name)
97 return rdev->constraints->name;
98 else if (rdev->desc->name)
99 return rdev->desc->name;
100 else
101 return "";
102}
103
104/* gets the regulator for a given consumer device */
105static struct regulator *get_device_regulator(struct device *dev)
106{
107 struct regulator *regulator = NULL;
108 struct regulator_dev *rdev;
109
110 mutex_lock(®ulator_list_mutex);
111 list_for_each_entry(rdev, ®ulator_list, list) {
112 mutex_lock(&rdev->mutex);
113 list_for_each_entry(regulator, &rdev->consumer_list, list) {
114 if (regulator->dev == dev) {
115 mutex_unlock(&rdev->mutex);
116 mutex_unlock(®ulator_list_mutex);
117 return regulator;
118 }
119 }
120 mutex_unlock(&rdev->mutex);
121 }
122 mutex_unlock(®ulator_list_mutex);
123 return NULL;
124}
125
126/* Platform voltage constraint check */
127static int regulator_check_voltage(struct regulator_dev *rdev,
128 int *min_uV, int *max_uV)
129{
130 BUG_ON(*min_uV > *max_uV);
131
132 if (!rdev->constraints) {
133 rdev_err(rdev, "no constraints\n");
134 return -ENODEV;
135 }
136 if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) {
137 rdev_err(rdev, "operation not allowed\n");
138 return -EPERM;
139 }
140
141 if (*max_uV > rdev->constraints->max_uV)
142 *max_uV = rdev->constraints->max_uV;
143 if (*min_uV < rdev->constraints->min_uV)
144 *min_uV = rdev->constraints->min_uV;
145
146 if (*min_uV > *max_uV)
147 return -EINVAL;
148
149 return 0;
150}
151
152/* Make sure we select a voltage that suits the needs of all
153 * regulator consumers
154 */
155static int regulator_check_consumers(struct regulator_dev *rdev,
156 int *min_uV, int *max_uV)
157{
158 struct regulator *regulator;
159
160 list_for_each_entry(regulator, &rdev->consumer_list, list) {
161 /*
162 * Assume consumers that didn't say anything are OK
163 * with anything in the constraint range.
164 */
165 if (!regulator->min_uV && !regulator->max_uV)
166 continue;
167
168 if (*max_uV > regulator->max_uV)
169 *max_uV = regulator->max_uV;
170 if (*min_uV < regulator->min_uV)
171 *min_uV = regulator->min_uV;
172 }
173
174 if (*min_uV > *max_uV)
175 return -EINVAL;
176
177 return 0;
178}
179
180/* current constraint check */
181static int regulator_check_current_limit(struct regulator_dev *rdev,
182 int *min_uA, int *max_uA)
183{
184 BUG_ON(*min_uA > *max_uA);
185
186 if (!rdev->constraints) {
187 rdev_err(rdev, "no constraints\n");
188 return -ENODEV;
189 }
190 if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_CURRENT)) {
191 rdev_err(rdev, "operation not allowed\n");
192 return -EPERM;
193 }
194
195 if (*max_uA > rdev->constraints->max_uA)
196 *max_uA = rdev->constraints->max_uA;
197 if (*min_uA < rdev->constraints->min_uA)
198 *min_uA = rdev->constraints->min_uA;
199
200 if (*min_uA > *max_uA)
201 return -EINVAL;
202
203 return 0;
204}
205
206/* operating mode constraint check */
207static int regulator_mode_constrain(struct regulator_dev *rdev, int *mode)
208{
209 switch (*mode) {
210 case REGULATOR_MODE_FAST:
211 case REGULATOR_MODE_NORMAL:
212 case REGULATOR_MODE_IDLE:
213 case REGULATOR_MODE_STANDBY:
214 break;
215 default:
216 return -EINVAL;
217 }
218
219 if (!rdev->constraints) {
220 rdev_err(rdev, "no constraints\n");
221 return -ENODEV;
222 }
223 if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_MODE)) {
224 rdev_err(rdev, "operation not allowed\n");
225 return -EPERM;
226 }
227
228 /* The modes are bitmasks, the most power hungry modes having
229 * the lowest values. If the requested mode isn't supported
230 * try higher modes. */
231 while (*mode) {
232 if (rdev->constraints->valid_modes_mask & *mode)
233 return 0;
234 *mode /= 2;
235 }
236
237 return -EINVAL;
238}
239
240/* dynamic regulator mode switching constraint check */
241static int regulator_check_drms(struct regulator_dev *rdev)
242{
243 if (!rdev->constraints) {
244 rdev_err(rdev, "no constraints\n");
245 return -ENODEV;
246 }
247 if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_DRMS)) {
248 rdev_err(rdev, "operation not allowed\n");
249 return -EPERM;
250 }
251 return 0;
252}
253
254static ssize_t device_requested_uA_show(struct device *dev,
255 struct device_attribute *attr, char *buf)
256{
257 struct regulator *regulator;
258
259 regulator = get_device_regulator(dev);
260 if (regulator == NULL)
261 return 0;
262
263 return sprintf(buf, "%d\n", regulator->uA_load);
264}
265
266static ssize_t regulator_uV_show(struct device *dev,
267 struct device_attribute *attr, char *buf)
268{
269 struct regulator_dev *rdev = dev_get_drvdata(dev);
270 ssize_t ret;
271
272 mutex_lock(&rdev->mutex);
273 ret = sprintf(buf, "%d\n", _regulator_get_voltage(rdev));
274 mutex_unlock(&rdev->mutex);
275
276 return ret;
277}
278static DEVICE_ATTR(microvolts, 0444, regulator_uV_show, NULL);
279
280static ssize_t regulator_uA_show(struct device *dev,
281 struct device_attribute *attr, char *buf)
282{
283 struct regulator_dev *rdev = dev_get_drvdata(dev);
284
285 return sprintf(buf, "%d\n", _regulator_get_current_limit(rdev));
286}
287static DEVICE_ATTR(microamps, 0444, regulator_uA_show, NULL);
288
289static ssize_t regulator_name_show(struct device *dev,
290 struct device_attribute *attr, char *buf)
291{
292 struct regulator_dev *rdev = dev_get_drvdata(dev);
293
294 return sprintf(buf, "%s\n", rdev_get_name(rdev));
295}
296
297static ssize_t regulator_print_opmode(char *buf, int mode)
298{
299 switch (mode) {
300 case REGULATOR_MODE_FAST:
301 return sprintf(buf, "fast\n");
302 case REGULATOR_MODE_NORMAL:
303 return sprintf(buf, "normal\n");
304 case REGULATOR_MODE_IDLE:
305 return sprintf(buf, "idle\n");
306 case REGULATOR_MODE_STANDBY:
307 return sprintf(buf, "standby\n");
308 }
309 return sprintf(buf, "unknown\n");
310}
311
312static ssize_t regulator_opmode_show(struct device *dev,
313 struct device_attribute *attr, char *buf)
314{
315 struct regulator_dev *rdev = dev_get_drvdata(dev);
316
317 return regulator_print_opmode(buf, _regulator_get_mode(rdev));
318}
319static DEVICE_ATTR(opmode, 0444, regulator_opmode_show, NULL);
320
321static ssize_t regulator_print_state(char *buf, int state)
322{
323 if (state > 0)
324 return sprintf(buf, "enabled\n");
325 else if (state == 0)
326 return sprintf(buf, "disabled\n");
327 else
328 return sprintf(buf, "unknown\n");
329}
330
331static ssize_t regulator_state_show(struct device *dev,
332 struct device_attribute *attr, char *buf)
333{
334 struct regulator_dev *rdev = dev_get_drvdata(dev);
335 ssize_t ret;
336
337 mutex_lock(&rdev->mutex);
338 ret = regulator_print_state(buf, _regulator_is_enabled(rdev));
339 mutex_unlock(&rdev->mutex);
340
341 return ret;
342}
343static DEVICE_ATTR(state, 0444, regulator_state_show, NULL);
344
345static ssize_t regulator_status_show(struct device *dev,
346 struct device_attribute *attr, char *buf)
347{
348 struct regulator_dev *rdev = dev_get_drvdata(dev);
349 int status;
350 char *label;
351
352 status = rdev->desc->ops->get_status(rdev);
353 if (status < 0)
354 return status;
355
356 switch (status) {
357 case REGULATOR_STATUS_OFF:
358 label = "off";
359 break;
360 case REGULATOR_STATUS_ON:
361 label = "on";
362 break;
363 case REGULATOR_STATUS_ERROR:
364 label = "error";
365 break;
366 case REGULATOR_STATUS_FAST:
367 label = "fast";
368 break;
369 case REGULATOR_STATUS_NORMAL:
370 label = "normal";
371 break;
372 case REGULATOR_STATUS_IDLE:
373 label = "idle";
374 break;
375 case REGULATOR_STATUS_STANDBY:
376 label = "standby";
377 break;
378 default:
379 return -ERANGE;
380 }
381
382 return sprintf(buf, "%s\n", label);
383}
384static DEVICE_ATTR(status, 0444, regulator_status_show, NULL);
385
386static ssize_t regulator_min_uA_show(struct device *dev,
387 struct device_attribute *attr, char *buf)
388{
389 struct regulator_dev *rdev = dev_get_drvdata(dev);
390
391 if (!rdev->constraints)
392 return sprintf(buf, "constraint not defined\n");
393
394 return sprintf(buf, "%d\n", rdev->constraints->min_uA);
395}
396static DEVICE_ATTR(min_microamps, 0444, regulator_min_uA_show, NULL);
397
398static ssize_t regulator_max_uA_show(struct device *dev,
399 struct device_attribute *attr, char *buf)
400{
401 struct regulator_dev *rdev = dev_get_drvdata(dev);
402
403 if (!rdev->constraints)
404 return sprintf(buf, "constraint not defined\n");
405
406 return sprintf(buf, "%d\n", rdev->constraints->max_uA);
407}
408static DEVICE_ATTR(max_microamps, 0444, regulator_max_uA_show, NULL);
409
410static ssize_t regulator_min_uV_show(struct device *dev,
411 struct device_attribute *attr, char *buf)
412{
413 struct regulator_dev *rdev = dev_get_drvdata(dev);
414
415 if (!rdev->constraints)
416 return sprintf(buf, "constraint not defined\n");
417
418 return sprintf(buf, "%d\n", rdev->constraints->min_uV);
419}
420static DEVICE_ATTR(min_microvolts, 0444, regulator_min_uV_show, NULL);
421
422static ssize_t regulator_max_uV_show(struct device *dev,
423 struct device_attribute *attr, char *buf)
424{
425 struct regulator_dev *rdev = dev_get_drvdata(dev);
426
427 if (!rdev->constraints)
428 return sprintf(buf, "constraint not defined\n");
429
430 return sprintf(buf, "%d\n", rdev->constraints->max_uV);
431}
432static DEVICE_ATTR(max_microvolts, 0444, regulator_max_uV_show, NULL);
433
434static ssize_t regulator_total_uA_show(struct device *dev,
435 struct device_attribute *attr, char *buf)
436{
437 struct regulator_dev *rdev = dev_get_drvdata(dev);
438 struct regulator *regulator;
439 int uA = 0;
440
441 mutex_lock(&rdev->mutex);
442 list_for_each_entry(regulator, &rdev->consumer_list, list)
443 uA += regulator->uA_load;
444 mutex_unlock(&rdev->mutex);
445 return sprintf(buf, "%d\n", uA);
446}
447static DEVICE_ATTR(requested_microamps, 0444, regulator_total_uA_show, NULL);
448
449static ssize_t regulator_num_users_show(struct device *dev,
450 struct device_attribute *attr, char *buf)
451{
452 struct regulator_dev *rdev = dev_get_drvdata(dev);
453 return sprintf(buf, "%d\n", rdev->use_count);
454}
455
456static ssize_t regulator_type_show(struct device *dev,
457 struct device_attribute *attr, char *buf)
458{
459 struct regulator_dev *rdev = dev_get_drvdata(dev);
460
461 switch (rdev->desc->type) {
462 case REGULATOR_VOLTAGE:
463 return sprintf(buf, "voltage\n");
464 case REGULATOR_CURRENT:
465 return sprintf(buf, "current\n");
466 }
467 return sprintf(buf, "unknown\n");
468}
469
470static ssize_t regulator_suspend_mem_uV_show(struct device *dev,
471 struct device_attribute *attr, char *buf)
472{
473 struct regulator_dev *rdev = dev_get_drvdata(dev);
474
475 return sprintf(buf, "%d\n", rdev->constraints->state_mem.uV);
476}
477static DEVICE_ATTR(suspend_mem_microvolts, 0444,
478 regulator_suspend_mem_uV_show, NULL);
479
480static ssize_t regulator_suspend_disk_uV_show(struct device *dev,
481 struct device_attribute *attr, char *buf)
482{
483 struct regulator_dev *rdev = dev_get_drvdata(dev);
484
485 return sprintf(buf, "%d\n", rdev->constraints->state_disk.uV);
486}
487static DEVICE_ATTR(suspend_disk_microvolts, 0444,
488 regulator_suspend_disk_uV_show, NULL);
489
490static ssize_t regulator_suspend_standby_uV_show(struct device *dev,
491 struct device_attribute *attr, char *buf)
492{
493 struct regulator_dev *rdev = dev_get_drvdata(dev);
494
495 return sprintf(buf, "%d\n", rdev->constraints->state_standby.uV);
496}
497static DEVICE_ATTR(suspend_standby_microvolts, 0444,
498 regulator_suspend_standby_uV_show, NULL);
499
500static ssize_t regulator_suspend_mem_mode_show(struct device *dev,
501 struct device_attribute *attr, char *buf)
502{
503 struct regulator_dev *rdev = dev_get_drvdata(dev);
504
505 return regulator_print_opmode(buf,
506 rdev->constraints->state_mem.mode);
507}
508static DEVICE_ATTR(suspend_mem_mode, 0444,
509 regulator_suspend_mem_mode_show, NULL);
510
511static ssize_t regulator_suspend_disk_mode_show(struct device *dev,
512 struct device_attribute *attr, char *buf)
513{
514 struct regulator_dev *rdev = dev_get_drvdata(dev);
515
516 return regulator_print_opmode(buf,
517 rdev->constraints->state_disk.mode);
518}
519static DEVICE_ATTR(suspend_disk_mode, 0444,
520 regulator_suspend_disk_mode_show, NULL);
521
522static ssize_t regulator_suspend_standby_mode_show(struct device *dev,
523 struct device_attribute *attr, char *buf)
524{
525 struct regulator_dev *rdev = dev_get_drvdata(dev);
526
527 return regulator_print_opmode(buf,
528 rdev->constraints->state_standby.mode);
529}
530static DEVICE_ATTR(suspend_standby_mode, 0444,
531 regulator_suspend_standby_mode_show, NULL);
532
533static ssize_t regulator_suspend_mem_state_show(struct device *dev,
534 struct device_attribute *attr, char *buf)
535{
536 struct regulator_dev *rdev = dev_get_drvdata(dev);
537
538 return regulator_print_state(buf,
539 rdev->constraints->state_mem.enabled);
540}
541static DEVICE_ATTR(suspend_mem_state, 0444,
542 regulator_suspend_mem_state_show, NULL);
543
544static ssize_t regulator_suspend_disk_state_show(struct device *dev,
545 struct device_attribute *attr, char *buf)
546{
547 struct regulator_dev *rdev = dev_get_drvdata(dev);
548
549 return regulator_print_state(buf,
550 rdev->constraints->state_disk.enabled);
551}
552static DEVICE_ATTR(suspend_disk_state, 0444,
553 regulator_suspend_disk_state_show, NULL);
554
555static ssize_t regulator_suspend_standby_state_show(struct device *dev,
556 struct device_attribute *attr, char *buf)
557{
558 struct regulator_dev *rdev = dev_get_drvdata(dev);
559
560 return regulator_print_state(buf,
561 rdev->constraints->state_standby.enabled);
562}
563static DEVICE_ATTR(suspend_standby_state, 0444,
564 regulator_suspend_standby_state_show, NULL);
565
566
567/*
568 * These are the only attributes are present for all regulators.
569 * Other attributes are a function of regulator functionality.
570 */
571static struct device_attribute regulator_dev_attrs[] = {
572 __ATTR(name, 0444, regulator_name_show, NULL),
573 __ATTR(num_users, 0444, regulator_num_users_show, NULL),
574 __ATTR(type, 0444, regulator_type_show, NULL),
575 __ATTR_NULL,
576};
577
578static void regulator_dev_release(struct device *dev)
579{
580 struct regulator_dev *rdev = dev_get_drvdata(dev);
581 kfree(rdev);
582}
583
584static struct class regulator_class = {
585 .name = "regulator",
586 .dev_release = regulator_dev_release,
587 .dev_attrs = regulator_dev_attrs,
588};
589
590/* Calculate the new optimum regulator operating mode based on the new total
591 * consumer load. All locks held by caller */
592static void drms_uA_update(struct regulator_dev *rdev)
593{
594 struct regulator *sibling;
595 int current_uA = 0, output_uV, input_uV, err;
596 unsigned int mode;
597
598 err = regulator_check_drms(rdev);
599 if (err < 0 || !rdev->desc->ops->get_optimum_mode ||
600 (!rdev->desc->ops->get_voltage &&
601 !rdev->desc->ops->get_voltage_sel) ||
602 !rdev->desc->ops->set_mode)
603 return;
604
605 /* get output voltage */
606 output_uV = _regulator_get_voltage(rdev);
607 if (output_uV <= 0)
608 return;
609
610 /* get input voltage */
611 input_uV = 0;
612 if (rdev->supply)
613 input_uV = _regulator_get_voltage(rdev);
614 if (input_uV <= 0)
615 input_uV = rdev->constraints->input_uV;
616 if (input_uV <= 0)
617 return;
618
619 /* calc total requested load */
620 list_for_each_entry(sibling, &rdev->consumer_list, list)
621 current_uA += sibling->uA_load;
622
623 /* now get the optimum mode for our new total regulator load */
624 mode = rdev->desc->ops->get_optimum_mode(rdev, input_uV,
625 output_uV, current_uA);
626
627 /* check the new mode is allowed */
628 err = regulator_mode_constrain(rdev, &mode);
629 if (err == 0)
630 rdev->desc->ops->set_mode(rdev, mode);
631}
632
633static int suspend_set_state(struct regulator_dev *rdev,
634 struct regulator_state *rstate)
635{
636 int ret = 0;
637 bool can_set_state;
638
639 can_set_state = rdev->desc->ops->set_suspend_enable &&
640 rdev->desc->ops->set_suspend_disable;
641
642 /* If we have no suspend mode configration don't set anything;
643 * only warn if the driver actually makes the suspend mode
644 * configurable.
645 */
646 if (!rstate->enabled && !rstate->disabled) {
647 if (can_set_state)
648 rdev_warn(rdev, "No configuration\n");
649 return 0;
650 }
651
652 if (rstate->enabled && rstate->disabled) {
653 rdev_err(rdev, "invalid configuration\n");
654 return -EINVAL;
655 }
656
657 if (!can_set_state) {
658 rdev_err(rdev, "no way to set suspend state\n");
659 return -EINVAL;
660 }
661
662 if (rstate->enabled)
663 ret = rdev->desc->ops->set_suspend_enable(rdev);
664 else
665 ret = rdev->desc->ops->set_suspend_disable(rdev);
666 if (ret < 0) {
667 rdev_err(rdev, "failed to enabled/disable\n");
668 return ret;
669 }
670
671 if (rdev->desc->ops->set_suspend_voltage && rstate->uV > 0) {
672 ret = rdev->desc->ops->set_suspend_voltage(rdev, rstate->uV);
673 if (ret < 0) {
674 rdev_err(rdev, "failed to set voltage\n");
675 return ret;
676 }
677 }
678
679 if (rdev->desc->ops->set_suspend_mode && rstate->mode > 0) {
680 ret = rdev->desc->ops->set_suspend_mode(rdev, rstate->mode);
681 if (ret < 0) {
682 rdev_err(rdev, "failed to set mode\n");
683 return ret;
684 }
685 }
686 return ret;
687}
688
689/* locks held by caller */
690static int suspend_prepare(struct regulator_dev *rdev, suspend_state_t state)
691{
692 if (!rdev->constraints)
693 return -EINVAL;
694
695 switch (state) {
696 case PM_SUSPEND_STANDBY:
697 return suspend_set_state(rdev,
698 &rdev->constraints->state_standby);
699 case PM_SUSPEND_MEM:
700 return suspend_set_state(rdev,
701 &rdev->constraints->state_mem);
702 case PM_SUSPEND_MAX:
703 return suspend_set_state(rdev,
704 &rdev->constraints->state_disk);
705 default:
706 return -EINVAL;
707 }
708}
709
710static void print_constraints(struct regulator_dev *rdev)
711{
712 struct regulation_constraints *constraints = rdev->constraints;
713 char buf[80] = "";
714 int count = 0;
715 int ret;
716
717 if (constraints->min_uV && constraints->max_uV) {
718 if (constraints->min_uV == constraints->max_uV)
719 count += sprintf(buf + count, "%d mV ",
720 constraints->min_uV / 1000);
721 else
722 count += sprintf(buf + count, "%d <--> %d mV ",
723 constraints->min_uV / 1000,
724 constraints->max_uV / 1000);
725 }
726
727 if (!constraints->min_uV ||
728 constraints->min_uV != constraints->max_uV) {
729 ret = _regulator_get_voltage(rdev);
730 if (ret > 0)
731 count += sprintf(buf + count, "at %d mV ", ret / 1000);
732 }
733
734 if (constraints->uV_offset)
735 count += sprintf(buf, "%dmV offset ",
736 constraints->uV_offset / 1000);
737
738 if (constraints->min_uA && constraints->max_uA) {
739 if (constraints->min_uA == constraints->max_uA)
740 count += sprintf(buf + count, "%d mA ",
741 constraints->min_uA / 1000);
742 else
743 count += sprintf(buf + count, "%d <--> %d mA ",
744 constraints->min_uA / 1000,
745 constraints->max_uA / 1000);
746 }
747
748 if (!constraints->min_uA ||
749 constraints->min_uA != constraints->max_uA) {
750 ret = _regulator_get_current_limit(rdev);
751 if (ret > 0)
752 count += sprintf(buf + count, "at %d mA ", ret / 1000);
753 }
754
755 if (constraints->valid_modes_mask & REGULATOR_MODE_FAST)
756 count += sprintf(buf + count, "fast ");
757 if (constraints->valid_modes_mask & REGULATOR_MODE_NORMAL)
758 count += sprintf(buf + count, "normal ");
759 if (constraints->valid_modes_mask & REGULATOR_MODE_IDLE)
760 count += sprintf(buf + count, "idle ");
761 if (constraints->valid_modes_mask & REGULATOR_MODE_STANDBY)
762 count += sprintf(buf + count, "standby");
763
764 rdev_info(rdev, "%s\n", buf);
765}
766
767static int machine_constraints_voltage(struct regulator_dev *rdev,
768 struct regulation_constraints *constraints)
769{
770 struct regulator_ops *ops = rdev->desc->ops;
771 int ret;
772
773 /* do we need to apply the constraint voltage */
774 if (rdev->constraints->apply_uV &&
775 rdev->constraints->min_uV == rdev->constraints->max_uV) {
776 ret = _regulator_do_set_voltage(rdev,
777 rdev->constraints->min_uV,
778 rdev->constraints->max_uV);
779 if (ret < 0) {
780 rdev_err(rdev, "failed to apply %duV constraint\n",
781 rdev->constraints->min_uV);
782 rdev->constraints = NULL;
783 return ret;
784 }
785 }
786
787 /* constrain machine-level voltage specs to fit
788 * the actual range supported by this regulator.
789 */
790 if (ops->list_voltage && rdev->desc->n_voltages) {
791 int count = rdev->desc->n_voltages;
792 int i;
793 int min_uV = INT_MAX;
794 int max_uV = INT_MIN;
795 int cmin = constraints->min_uV;
796 int cmax = constraints->max_uV;
797
798 /* it's safe to autoconfigure fixed-voltage supplies
799 and the constraints are used by list_voltage. */
800 if (count == 1 && !cmin) {
801 cmin = 1;
802 cmax = INT_MAX;
803 constraints->min_uV = cmin;
804 constraints->max_uV = cmax;
805 }
806
807 /* voltage constraints are optional */
808 if ((cmin == 0) && (cmax == 0))
809 return 0;
810
811 /* else require explicit machine-level constraints */
812 if (cmin <= 0 || cmax <= 0 || cmax < cmin) {
813 rdev_err(rdev, "invalid voltage constraints\n");
814 return -EINVAL;
815 }
816
817 /* initial: [cmin..cmax] valid, [min_uV..max_uV] not */
818 for (i = 0; i < count; i++) {
819 int value;
820
821 value = ops->list_voltage(rdev, i);
822 if (value <= 0)
823 continue;
824
825 /* maybe adjust [min_uV..max_uV] */
826 if (value >= cmin && value < min_uV)
827 min_uV = value;
828 if (value <= cmax && value > max_uV)
829 max_uV = value;
830 }
831
832 /* final: [min_uV..max_uV] valid iff constraints valid */
833 if (max_uV < min_uV) {
834 rdev_err(rdev, "unsupportable voltage constraints\n");
835 return -EINVAL;
836 }
837
838 /* use regulator's subset of machine constraints */
839 if (constraints->min_uV < min_uV) {
840 rdev_dbg(rdev, "override min_uV, %d -> %d\n",
841 constraints->min_uV, min_uV);
842 constraints->min_uV = min_uV;
843 }
844 if (constraints->max_uV > max_uV) {
845 rdev_dbg(rdev, "override max_uV, %d -> %d\n",
846 constraints->max_uV, max_uV);
847 constraints->max_uV = max_uV;
848 }
849 }
850
851 return 0;
852}
853
854/**
855 * set_machine_constraints - sets regulator constraints
856 * @rdev: regulator source
857 * @constraints: constraints to apply
858 *
859 * Allows platform initialisation code to define and constrain
860 * regulator circuits e.g. valid voltage/current ranges, etc. NOTE:
861 * Constraints *must* be set by platform code in order for some
862 * regulator operations to proceed i.e. set_voltage, set_current_limit,
863 * set_mode.
864 */
865static int set_machine_constraints(struct regulator_dev *rdev,
866 const struct regulation_constraints *constraints)
867{
868 int ret = 0;
869 struct regulator_ops *ops = rdev->desc->ops;
870
871 rdev->constraints = kmemdup(constraints, sizeof(*constraints),
872 GFP_KERNEL);
873 if (!rdev->constraints)
874 return -ENOMEM;
875
876 ret = machine_constraints_voltage(rdev, rdev->constraints);
877 if (ret != 0)
878 goto out;
879
880 /* do we need to setup our suspend state */
881 if (constraints->initial_state) {
882 ret = suspend_prepare(rdev, rdev->constraints->initial_state);
883 if (ret < 0) {
884 rdev_err(rdev, "failed to set suspend state\n");
885 rdev->constraints = NULL;
886 goto out;
887 }
888 }
889
890 if (constraints->initial_mode) {
891 if (!ops->set_mode) {
892 rdev_err(rdev, "no set_mode operation\n");
893 ret = -EINVAL;
894 goto out;
895 }
896
897 ret = ops->set_mode(rdev, rdev->constraints->initial_mode);
898 if (ret < 0) {
899 rdev_err(rdev, "failed to set initial mode: %d\n", ret);
900 goto out;
901 }
902 }
903
904 /* If the constraints say the regulator should be on at this point
905 * and we have control then make sure it is enabled.
906 */
907 if ((rdev->constraints->always_on || rdev->constraints->boot_on) &&
908 ops->enable) {
909 ret = ops->enable(rdev);
910 if (ret < 0) {
911 rdev_err(rdev, "failed to enable\n");
912 rdev->constraints = NULL;
913 goto out;
914 }
915 }
916
917 print_constraints(rdev);
918out:
919 return ret;
920}
921
922/**
923 * set_supply - set regulator supply regulator
924 * @rdev: regulator name
925 * @supply_rdev: supply regulator name
926 *
927 * Called by platform initialisation code to set the supply regulator for this
928 * regulator. This ensures that a regulators supply will also be enabled by the
929 * core if it's child is enabled.
930 */
931static int set_supply(struct regulator_dev *rdev,
932 struct regulator_dev *supply_rdev)
933{
934 int err;
935
936 err = sysfs_create_link(&rdev->dev.kobj, &supply_rdev->dev.kobj,
937 "supply");
938 if (err) {
939 rdev_err(rdev, "could not add device link %s err %d\n",
940 supply_rdev->dev.kobj.name, err);
941 goto out;
942 }
943 rdev->supply = supply_rdev;
944 list_add(&rdev->slist, &supply_rdev->supply_list);
945out:
946 return err;
947}
948
949/**
950 * set_consumer_device_supply - Bind a regulator to a symbolic supply
951 * @rdev: regulator source
952 * @consumer_dev: device the supply applies to
953 * @consumer_dev_name: dev_name() string for device supply applies to
954 * @supply: symbolic name for supply
955 *
956 * Allows platform initialisation code to map physical regulator
957 * sources to symbolic names for supplies for use by devices. Devices
958 * should use these symbolic names to request regulators, avoiding the
959 * need to provide board-specific regulator names as platform data.
960 *
961 * Only one of consumer_dev and consumer_dev_name may be specified.
962 */
963static int set_consumer_device_supply(struct regulator_dev *rdev,
964 struct device *consumer_dev, const char *consumer_dev_name,
965 const char *supply)
966{
967 struct regulator_map *node;
968 int has_dev;
969
970 if (consumer_dev && consumer_dev_name)
971 return -EINVAL;
972
973 if (!consumer_dev_name && consumer_dev)
974 consumer_dev_name = dev_name(consumer_dev);
975
976 if (supply == NULL)
977 return -EINVAL;
978
979 if (consumer_dev_name != NULL)
980 has_dev = 1;
981 else
982 has_dev = 0;
983
984 list_for_each_entry(node, ®ulator_map_list, list) {
985 if (node->dev_name && consumer_dev_name) {
986 if (strcmp(node->dev_name, consumer_dev_name) != 0)
987 continue;
988 } else if (node->dev_name || consumer_dev_name) {
989 continue;
990 }
991
992 if (strcmp(node->supply, supply) != 0)
993 continue;
994
995 dev_dbg(consumer_dev, "%s/%s is '%s' supply; fail %s/%s\n",
996 dev_name(&node->regulator->dev),
997 node->regulator->desc->name,
998 supply,
999 dev_name(&rdev->dev), rdev_get_name(rdev));
1000 return -EBUSY;
1001 }
1002
1003 node = kzalloc(sizeof(struct regulator_map), GFP_KERNEL);
1004 if (node == NULL)
1005 return -ENOMEM;
1006
1007 node->regulator = rdev;
1008 node->supply = supply;
1009
1010 if (has_dev) {
1011 node->dev_name = kstrdup(consumer_dev_name, GFP_KERNEL);
1012 if (node->dev_name == NULL) {
1013 kfree(node);
1014 return -ENOMEM;
1015 }
1016 }
1017
1018 list_add(&node->list, ®ulator_map_list);
1019 return 0;
1020}
1021
1022static void unset_regulator_supplies(struct regulator_dev *rdev)
1023{
1024 struct regulator_map *node, *n;
1025
1026 list_for_each_entry_safe(node, n, ®ulator_map_list, list) {
1027 if (rdev == node->regulator) {
1028 list_del(&node->list);
1029 kfree(node->dev_name);
1030 kfree(node);
1031 }
1032 }
1033}
1034
1035#define REG_STR_SIZE 32
1036
1037static struct regulator *create_regulator(struct regulator_dev *rdev,
1038 struct device *dev,
1039 const char *supply_name)
1040{
1041 struct regulator *regulator;
1042 char buf[REG_STR_SIZE];
1043 int err, size;
1044
1045 regulator = kzalloc(sizeof(*regulator), GFP_KERNEL);
1046 if (regulator == NULL)
1047 return NULL;
1048
1049 mutex_lock(&rdev->mutex);
1050 regulator->rdev = rdev;
1051 list_add(®ulator->list, &rdev->consumer_list);
1052
1053 if (dev) {
1054 /* create a 'requested_microamps_name' sysfs entry */
1055 size = scnprintf(buf, REG_STR_SIZE, "microamps_requested_%s",
1056 supply_name);
1057 if (size >= REG_STR_SIZE)
1058 goto overflow_err;
1059
1060 regulator->dev = dev;
1061 sysfs_attr_init(®ulator->dev_attr.attr);
1062 regulator->dev_attr.attr.name = kstrdup(buf, GFP_KERNEL);
1063 if (regulator->dev_attr.attr.name == NULL)
1064 goto attr_name_err;
1065
1066 regulator->dev_attr.attr.mode = 0444;
1067 regulator->dev_attr.show = device_requested_uA_show;
1068 err = device_create_file(dev, ®ulator->dev_attr);
1069 if (err < 0) {
1070 rdev_warn(rdev, "could not add regulator_dev requested microamps sysfs entry\n");
1071 goto attr_name_err;
1072 }
1073
1074 /* also add a link to the device sysfs entry */
1075 size = scnprintf(buf, REG_STR_SIZE, "%s-%s",
1076 dev->kobj.name, supply_name);
1077 if (size >= REG_STR_SIZE)
1078 goto attr_err;
1079
1080 regulator->supply_name = kstrdup(buf, GFP_KERNEL);
1081 if (regulator->supply_name == NULL)
1082 goto attr_err;
1083
1084 err = sysfs_create_link(&rdev->dev.kobj, &dev->kobj,
1085 buf);
1086 if (err) {
1087 rdev_warn(rdev, "could not add device link %s err %d\n",
1088 dev->kobj.name, err);
1089 goto link_name_err;
1090 }
1091 }
1092 mutex_unlock(&rdev->mutex);
1093 return regulator;
1094link_name_err:
1095 kfree(regulator->supply_name);
1096attr_err:
1097 device_remove_file(regulator->dev, ®ulator->dev_attr);
1098attr_name_err:
1099 kfree(regulator->dev_attr.attr.name);
1100overflow_err:
1101 list_del(®ulator->list);
1102 kfree(regulator);
1103 mutex_unlock(&rdev->mutex);
1104 return NULL;
1105}
1106
1107static int _regulator_get_enable_time(struct regulator_dev *rdev)
1108{
1109 if (!rdev->desc->ops->enable_time)
1110 return 0;
1111 return rdev->desc->ops->enable_time(rdev);
1112}
1113
1114/* Internal regulator request function */
1115static struct regulator *_regulator_get(struct device *dev, const char *id,
1116 int exclusive)
1117{
1118 struct regulator_dev *rdev;
1119 struct regulator_map *map;
1120 struct regulator *regulator = ERR_PTR(-ENODEV);
1121 const char *devname = NULL;
1122 int ret;
1123
1124 if (id == NULL) {
1125 pr_err("get() with no identifier\n");
1126 return regulator;
1127 }
1128
1129 if (dev)
1130 devname = dev_name(dev);
1131
1132 mutex_lock(®ulator_list_mutex);
1133
1134 list_for_each_entry(map, ®ulator_map_list, list) {
1135 /* If the mapping has a device set up it must match */
1136 if (map->dev_name &&
1137 (!devname || strcmp(map->dev_name, devname)))
1138 continue;
1139
1140 if (strcmp(map->supply, id) == 0) {
1141 rdev = map->regulator;
1142 goto found;
1143 }
1144 }
1145
1146 if (board_wants_dummy_regulator) {
1147 rdev = dummy_regulator_rdev;
1148 goto found;
1149 }
1150
1151#ifdef CONFIG_REGULATOR_DUMMY
1152 if (!devname)
1153 devname = "deviceless";
1154
1155 /* If the board didn't flag that it was fully constrained then
1156 * substitute in a dummy regulator so consumers can continue.
1157 */
1158 if (!has_full_constraints) {
1159 pr_warn("%s supply %s not found, using dummy regulator\n",
1160 devname, id);
1161 rdev = dummy_regulator_rdev;
1162 goto found;
1163 }
1164#endif
1165
1166 mutex_unlock(®ulator_list_mutex);
1167 return regulator;
1168
1169found:
1170 if (rdev->exclusive) {
1171 regulator = ERR_PTR(-EPERM);
1172 goto out;
1173 }
1174
1175 if (exclusive && rdev->open_count) {
1176 regulator = ERR_PTR(-EBUSY);
1177 goto out;
1178 }
1179
1180 if (!try_module_get(rdev->owner))
1181 goto out;
1182
1183 regulator = create_regulator(rdev, dev, id);
1184 if (regulator == NULL) {
1185 regulator = ERR_PTR(-ENOMEM);
1186 module_put(rdev->owner);
1187 }
1188
1189 rdev->open_count++;
1190 if (exclusive) {
1191 rdev->exclusive = 1;
1192
1193 ret = _regulator_is_enabled(rdev);
1194 if (ret > 0)
1195 rdev->use_count = 1;
1196 else
1197 rdev->use_count = 0;
1198 }
1199
1200out:
1201 mutex_unlock(®ulator_list_mutex);
1202
1203 return regulator;
1204}
1205
1206/**
1207 * regulator_get - lookup and obtain a reference to a regulator.
1208 * @dev: device for regulator "consumer"
1209 * @id: Supply name or regulator ID.
1210 *
1211 * Returns a struct regulator corresponding to the regulator producer,
1212 * or IS_ERR() condition containing errno.
1213 *
1214 * Use of supply names configured via regulator_set_device_supply() is
1215 * strongly encouraged. It is recommended that the supply name used
1216 * should match the name used for the supply and/or the relevant
1217 * device pins in the datasheet.
1218 */
1219struct regulator *regulator_get(struct device *dev, const char *id)
1220{
1221 return _regulator_get(dev, id, 0);
1222}
1223EXPORT_SYMBOL_GPL(regulator_get);
1224
1225/**
1226 * regulator_get_exclusive - obtain exclusive access to a regulator.
1227 * @dev: device for regulator "consumer"
1228 * @id: Supply name or regulator ID.
1229 *
1230 * Returns a struct regulator corresponding to the regulator producer,
1231 * or IS_ERR() condition containing errno. Other consumers will be
1232 * unable to obtain this reference is held and the use count for the
1233 * regulator will be initialised to reflect the current state of the
1234 * regulator.
1235 *
1236 * This is intended for use by consumers which cannot tolerate shared
1237 * use of the regulator such as those which need to force the
1238 * regulator off for correct operation of the hardware they are
1239 * controlling.
1240 *
1241 * Use of supply names configured via regulator_set_device_supply() is
1242 * strongly encouraged. It is recommended that the supply name used
1243 * should match the name used for the supply and/or the relevant
1244 * device pins in the datasheet.
1245 */
1246struct regulator *regulator_get_exclusive(struct device *dev, const char *id)
1247{
1248 return _regulator_get(dev, id, 1);
1249}
1250EXPORT_SYMBOL_GPL(regulator_get_exclusive);
1251
1252/**
1253 * regulator_put - "free" the regulator source
1254 * @regulator: regulator source
1255 *
1256 * Note: drivers must ensure that all regulator_enable calls made on this
1257 * regulator source are balanced by regulator_disable calls prior to calling
1258 * this function.
1259 */
1260void regulator_put(struct regulator *regulator)
1261{
1262 struct regulator_dev *rdev;
1263
1264 if (regulator == NULL || IS_ERR(regulator))
1265 return;
1266
1267 mutex_lock(®ulator_list_mutex);
1268 rdev = regulator->rdev;
1269
1270 /* remove any sysfs entries */
1271 if (regulator->dev) {
1272 sysfs_remove_link(&rdev->dev.kobj, regulator->supply_name);
1273 kfree(regulator->supply_name);
1274 device_remove_file(regulator->dev, ®ulator->dev_attr);
1275 kfree(regulator->dev_attr.attr.name);
1276 }
1277 list_del(®ulator->list);
1278 kfree(regulator);
1279
1280 rdev->open_count--;
1281 rdev->exclusive = 0;
1282
1283 module_put(rdev->owner);
1284 mutex_unlock(®ulator_list_mutex);
1285}
1286EXPORT_SYMBOL_GPL(regulator_put);
1287
1288static int _regulator_can_change_status(struct regulator_dev *rdev)
1289{
1290 if (!rdev->constraints)
1291 return 0;
1292
1293 if (rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_STATUS)
1294 return 1;
1295 else
1296 return 0;
1297}
1298
1299/* locks held by regulator_enable() */
1300static int _regulator_enable(struct regulator_dev *rdev)
1301{
1302 int ret, delay;
1303
1304 if (rdev->use_count == 0) {
1305 /* do we need to enable the supply regulator first */
1306 if (rdev->supply) {
1307 mutex_lock(&rdev->supply->mutex);
1308 ret = _regulator_enable(rdev->supply);
1309 mutex_unlock(&rdev->supply->mutex);
1310 if (ret < 0) {
1311 rdev_err(rdev, "failed to enable: %d\n", ret);
1312 return ret;
1313 }
1314 }
1315 }
1316
1317 /* check voltage and requested load before enabling */
1318 if (rdev->constraints &&
1319 (rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_DRMS))
1320 drms_uA_update(rdev);
1321
1322 if (rdev->use_count == 0) {
1323 /* The regulator may on if it's not switchable or left on */
1324 ret = _regulator_is_enabled(rdev);
1325 if (ret == -EINVAL || ret == 0) {
1326 if (!_regulator_can_change_status(rdev))
1327 return -EPERM;
1328
1329 if (!rdev->desc->ops->enable)
1330 return -EINVAL;
1331
1332 /* Query before enabling in case configuration
1333 * dependent. */
1334 ret = _regulator_get_enable_time(rdev);
1335 if (ret >= 0) {
1336 delay = ret;
1337 } else {
1338 rdev_warn(rdev, "enable_time() failed: %d\n",
1339 ret);
1340 delay = 0;
1341 }
1342
1343 trace_regulator_enable(rdev_get_name(rdev));
1344
1345 /* Allow the regulator to ramp; it would be useful
1346 * to extend this for bulk operations so that the
1347 * regulators can ramp together. */
1348 ret = rdev->desc->ops->enable(rdev);
1349 if (ret < 0)
1350 return ret;
1351
1352 trace_regulator_enable_delay(rdev_get_name(rdev));
1353
1354 if (delay >= 1000) {
1355 mdelay(delay / 1000);
1356 udelay(delay % 1000);
1357 } else if (delay) {
1358 udelay(delay);
1359 }
1360
1361 trace_regulator_enable_complete(rdev_get_name(rdev));
1362
1363 } else if (ret < 0) {
1364 rdev_err(rdev, "is_enabled() failed: %d\n", ret);
1365 return ret;
1366 }
1367 /* Fallthrough on positive return values - already enabled */
1368 }
1369
1370 rdev->use_count++;
1371
1372 return 0;
1373}
1374
1375/**
1376 * regulator_enable - enable regulator output
1377 * @regulator: regulator source
1378 *
1379 * Request that the regulator be enabled with the regulator output at
1380 * the predefined voltage or current value. Calls to regulator_enable()
1381 * must be balanced with calls to regulator_disable().
1382 *
1383 * NOTE: the output value can be set by other drivers, boot loader or may be
1384 * hardwired in the regulator.
1385 */
1386int regulator_enable(struct regulator *regulator)
1387{
1388 struct regulator_dev *rdev = regulator->rdev;
1389 int ret = 0;
1390
1391 mutex_lock(&rdev->mutex);
1392 ret = _regulator_enable(rdev);
1393 mutex_unlock(&rdev->mutex);
1394 return ret;
1395}
1396EXPORT_SYMBOL_GPL(regulator_enable);
1397
1398/* locks held by regulator_disable() */
1399static int _regulator_disable(struct regulator_dev *rdev,
1400 struct regulator_dev **supply_rdev_ptr)
1401{
1402 int ret = 0;
1403 *supply_rdev_ptr = NULL;
1404
1405 if (WARN(rdev->use_count <= 0,
1406 "unbalanced disables for %s\n", rdev_get_name(rdev)))
1407 return -EIO;
1408
1409 /* are we the last user and permitted to disable ? */
1410 if (rdev->use_count == 1 &&
1411 (rdev->constraints && !rdev->constraints->always_on)) {
1412
1413 /* we are last user */
1414 if (_regulator_can_change_status(rdev) &&
1415 rdev->desc->ops->disable) {
1416 trace_regulator_disable(rdev_get_name(rdev));
1417
1418 ret = rdev->desc->ops->disable(rdev);
1419 if (ret < 0) {
1420 rdev_err(rdev, "failed to disable\n");
1421 return ret;
1422 }
1423
1424 trace_regulator_disable_complete(rdev_get_name(rdev));
1425
1426 _notifier_call_chain(rdev, REGULATOR_EVENT_DISABLE,
1427 NULL);
1428 }
1429
1430 /* decrease our supplies ref count and disable if required */
1431 *supply_rdev_ptr = rdev->supply;
1432
1433 rdev->use_count = 0;
1434 } else if (rdev->use_count > 1) {
1435
1436 if (rdev->constraints &&
1437 (rdev->constraints->valid_ops_mask &
1438 REGULATOR_CHANGE_DRMS))
1439 drms_uA_update(rdev);
1440
1441 rdev->use_count--;
1442 }
1443 return ret;
1444}
1445
1446/**
1447 * regulator_disable - disable regulator output
1448 * @regulator: regulator source
1449 *
1450 * Disable the regulator output voltage or current. Calls to
1451 * regulator_enable() must be balanced with calls to
1452 * regulator_disable().
1453 *
1454 * NOTE: this will only disable the regulator output if no other consumer
1455 * devices have it enabled, the regulator device supports disabling and
1456 * machine constraints permit this operation.
1457 */
1458int regulator_disable(struct regulator *regulator)
1459{
1460 struct regulator_dev *rdev = regulator->rdev;
1461 struct regulator_dev *supply_rdev = NULL;
1462 int ret = 0;
1463
1464 mutex_lock(&rdev->mutex);
1465 ret = _regulator_disable(rdev, &supply_rdev);
1466 mutex_unlock(&rdev->mutex);
1467
1468 /* decrease our supplies ref count and disable if required */
1469 while (supply_rdev != NULL) {
1470 rdev = supply_rdev;
1471
1472 mutex_lock(&rdev->mutex);
1473 _regulator_disable(rdev, &supply_rdev);
1474 mutex_unlock(&rdev->mutex);
1475 }
1476
1477 return ret;
1478}
1479EXPORT_SYMBOL_GPL(regulator_disable);
1480
1481/* locks held by regulator_force_disable() */
1482static int _regulator_force_disable(struct regulator_dev *rdev,
1483 struct regulator_dev **supply_rdev_ptr)
1484{
1485 int ret = 0;
1486
1487 /* force disable */
1488 if (rdev->desc->ops->disable) {
1489 /* ah well, who wants to live forever... */
1490 ret = rdev->desc->ops->disable(rdev);
1491 if (ret < 0) {
1492 rdev_err(rdev, "failed to force disable\n");
1493 return ret;
1494 }
1495 /* notify other consumers that power has been forced off */
1496 _notifier_call_chain(rdev, REGULATOR_EVENT_FORCE_DISABLE |
1497 REGULATOR_EVENT_DISABLE, NULL);
1498 }
1499
1500 /* decrease our supplies ref count and disable if required */
1501 *supply_rdev_ptr = rdev->supply;
1502
1503 rdev->use_count = 0;
1504 return ret;
1505}
1506
1507/**
1508 * regulator_force_disable - force disable regulator output
1509 * @regulator: regulator source
1510 *
1511 * Forcibly disable the regulator output voltage or current.
1512 * NOTE: this *will* disable the regulator output even if other consumer
1513 * devices have it enabled. This should be used for situations when device
1514 * damage will likely occur if the regulator is not disabled (e.g. over temp).
1515 */
1516int regulator_force_disable(struct regulator *regulator)
1517{
1518 struct regulator_dev *rdev = regulator->rdev;
1519 struct regulator_dev *supply_rdev = NULL;
1520 int ret;
1521
1522 mutex_lock(&rdev->mutex);
1523 regulator->uA_load = 0;
1524 ret = _regulator_force_disable(rdev, &supply_rdev);
1525 mutex_unlock(&rdev->mutex);
1526
1527 if (supply_rdev)
1528 regulator_disable(get_device_regulator(rdev_get_dev(supply_rdev)));
1529
1530 return ret;
1531}
1532EXPORT_SYMBOL_GPL(regulator_force_disable);
1533
1534static int _regulator_is_enabled(struct regulator_dev *rdev)
1535{
1536 /* If we don't know then assume that the regulator is always on */
1537 if (!rdev->desc->ops->is_enabled)
1538 return 1;
1539
1540 return rdev->desc->ops->is_enabled(rdev);
1541}
1542
1543/**
1544 * regulator_is_enabled - is the regulator output enabled
1545 * @regulator: regulator source
1546 *
1547 * Returns positive if the regulator driver backing the source/client
1548 * has requested that the device be enabled, zero if it hasn't, else a
1549 * negative errno code.
1550 *
1551 * Note that the device backing this regulator handle can have multiple
1552 * users, so it might be enabled even if regulator_enable() was never
1553 * called for this particular source.
1554 */
1555int regulator_is_enabled(struct regulator *regulator)
1556{
1557 int ret;
1558
1559 mutex_lock(®ulator->rdev->mutex);
1560 ret = _regulator_is_enabled(regulator->rdev);
1561 mutex_unlock(®ulator->rdev->mutex);
1562
1563 return ret;
1564}
1565EXPORT_SYMBOL_GPL(regulator_is_enabled);
1566
1567/**
1568 * regulator_count_voltages - count regulator_list_voltage() selectors
1569 * @regulator: regulator source
1570 *
1571 * Returns number of selectors, or negative errno. Selectors are
1572 * numbered starting at zero, and typically correspond to bitfields
1573 * in hardware registers.
1574 */
1575int regulator_count_voltages(struct regulator *regulator)
1576{
1577 struct regulator_dev *rdev = regulator->rdev;
1578
1579 return rdev->desc->n_voltages ? : -EINVAL;
1580}
1581EXPORT_SYMBOL_GPL(regulator_count_voltages);
1582
1583/**
1584 * regulator_list_voltage - enumerate supported voltages
1585 * @regulator: regulator source
1586 * @selector: identify voltage to list
1587 * Context: can sleep
1588 *
1589 * Returns a voltage that can be passed to @regulator_set_voltage(),
1590 * zero if this selector code can't be used on this system, or a
1591 * negative errno.
1592 */
1593int regulator_list_voltage(struct regulator *regulator, unsigned selector)
1594{
1595 struct regulator_dev *rdev = regulator->rdev;
1596 struct regulator_ops *ops = rdev->desc->ops;
1597 int ret;
1598
1599 if (!ops->list_voltage || selector >= rdev->desc->n_voltages)
1600 return -EINVAL;
1601
1602 mutex_lock(&rdev->mutex);
1603 ret = ops->list_voltage(rdev, selector);
1604 mutex_unlock(&rdev->mutex);
1605
1606 if (ret > 0) {
1607 if (ret < rdev->constraints->min_uV)
1608 ret = 0;
1609 else if (ret > rdev->constraints->max_uV)
1610 ret = 0;
1611 }
1612
1613 return ret;
1614}
1615EXPORT_SYMBOL_GPL(regulator_list_voltage);
1616
1617/**
1618 * regulator_is_supported_voltage - check if a voltage range can be supported
1619 *
1620 * @regulator: Regulator to check.
1621 * @min_uV: Minimum required voltage in uV.
1622 * @max_uV: Maximum required voltage in uV.
1623 *
1624 * Returns a boolean or a negative error code.
1625 */
1626int regulator_is_supported_voltage(struct regulator *regulator,
1627 int min_uV, int max_uV)
1628{
1629 int i, voltages, ret;
1630
1631 ret = regulator_count_voltages(regulator);
1632 if (ret < 0)
1633 return ret;
1634 voltages = ret;
1635
1636 for (i = 0; i < voltages; i++) {
1637 ret = regulator_list_voltage(regulator, i);
1638
1639 if (ret >= min_uV && ret <= max_uV)
1640 return 1;
1641 }
1642
1643 return 0;
1644}
1645
1646static int _regulator_do_set_voltage(struct regulator_dev *rdev,
1647 int min_uV, int max_uV)
1648{
1649 int ret;
1650 int delay = 0;
1651 unsigned int selector;
1652
1653 trace_regulator_set_voltage(rdev_get_name(rdev), min_uV, max_uV);
1654
1655 min_uV += rdev->constraints->uV_offset;
1656 max_uV += rdev->constraints->uV_offset;
1657
1658 if (rdev->desc->ops->set_voltage) {
1659 ret = rdev->desc->ops->set_voltage(rdev, min_uV, max_uV,
1660 &selector);
1661
1662 if (rdev->desc->ops->list_voltage)
1663 selector = rdev->desc->ops->list_voltage(rdev,
1664 selector);
1665 else
1666 selector = -1;
1667 } else if (rdev->desc->ops->set_voltage_sel) {
1668 int best_val = INT_MAX;
1669 int i;
1670
1671 selector = 0;
1672
1673 /* Find the smallest voltage that falls within the specified
1674 * range.
1675 */
1676 for (i = 0; i < rdev->desc->n_voltages; i++) {
1677 ret = rdev->desc->ops->list_voltage(rdev, i);
1678 if (ret < 0)
1679 continue;
1680
1681 if (ret < best_val && ret >= min_uV && ret <= max_uV) {
1682 best_val = ret;
1683 selector = i;
1684 }
1685 }
1686
1687 /*
1688 * If we can't obtain the old selector there is not enough
1689 * info to call set_voltage_time_sel().
1690 */
1691 if (rdev->desc->ops->set_voltage_time_sel &&
1692 rdev->desc->ops->get_voltage_sel) {
1693 unsigned int old_selector = 0;
1694
1695 ret = rdev->desc->ops->get_voltage_sel(rdev);
1696 if (ret < 0)
1697 return ret;
1698 old_selector = ret;
1699 delay = rdev->desc->ops->set_voltage_time_sel(rdev,
1700 old_selector, selector);
1701 }
1702
1703 if (best_val != INT_MAX) {
1704 ret = rdev->desc->ops->set_voltage_sel(rdev, selector);
1705 selector = best_val;
1706 } else {
1707 ret = -EINVAL;
1708 }
1709 } else {
1710 ret = -EINVAL;
1711 }
1712
1713 /* Insert any necessary delays */
1714 if (delay >= 1000) {
1715 mdelay(delay / 1000);
1716 udelay(delay % 1000);
1717 } else if (delay) {
1718 udelay(delay);
1719 }
1720
1721 if (ret == 0)
1722 _notifier_call_chain(rdev, REGULATOR_EVENT_VOLTAGE_CHANGE,
1723 NULL);
1724
1725 trace_regulator_set_voltage_complete(rdev_get_name(rdev), selector);
1726
1727 return ret;
1728}
1729
1730/**
1731 * regulator_set_voltage - set regulator output voltage
1732 * @regulator: regulator source
1733 * @min_uV: Minimum required voltage in uV
1734 * @max_uV: Maximum acceptable voltage in uV
1735 *
1736 * Sets a voltage regulator to the desired output voltage. This can be set
1737 * during any regulator state. IOW, regulator can be disabled or enabled.
1738 *
1739 * If the regulator is enabled then the voltage will change to the new value
1740 * immediately otherwise if the regulator is disabled the regulator will
1741 * output at the new voltage when enabled.
1742 *
1743 * NOTE: If the regulator is shared between several devices then the lowest
1744 * request voltage that meets the system constraints will be used.
1745 * Regulator system constraints must be set for this regulator before
1746 * calling this function otherwise this call will fail.
1747 */
1748int regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV)
1749{
1750 struct regulator_dev *rdev = regulator->rdev;
1751 int ret = 0;
1752
1753 mutex_lock(&rdev->mutex);
1754
1755 /* If we're setting the same range as last time the change
1756 * should be a noop (some cpufreq implementations use the same
1757 * voltage for multiple frequencies, for example).
1758 */
1759 if (regulator->min_uV == min_uV && regulator->max_uV == max_uV)
1760 goto out;
1761
1762 /* sanity check */
1763 if (!rdev->desc->ops->set_voltage &&
1764 !rdev->desc->ops->set_voltage_sel) {
1765 ret = -EINVAL;
1766 goto out;
1767 }
1768
1769 /* constraints check */
1770 ret = regulator_check_voltage(rdev, &min_uV, &max_uV);
1771 if (ret < 0)
1772 goto out;
1773 regulator->min_uV = min_uV;
1774 regulator->max_uV = max_uV;
1775
1776 ret = regulator_check_consumers(rdev, &min_uV, &max_uV);
1777 if (ret < 0)
1778 goto out;
1779
1780 ret = _regulator_do_set_voltage(rdev, min_uV, max_uV);
1781
1782out:
1783 mutex_unlock(&rdev->mutex);
1784 return ret;
1785}
1786EXPORT_SYMBOL_GPL(regulator_set_voltage);
1787
1788/**
1789 * regulator_set_voltage_time - get raise/fall time
1790 * @regulator: regulator source
1791 * @old_uV: starting voltage in microvolts
1792 * @new_uV: target voltage in microvolts
1793 *
1794 * Provided with the starting and ending voltage, this function attempts to
1795 * calculate the time in microseconds required to rise or fall to this new
1796 * voltage.
1797 */
1798int regulator_set_voltage_time(struct regulator *regulator,
1799 int old_uV, int new_uV)
1800{
1801 struct regulator_dev *rdev = regulator->rdev;
1802 struct regulator_ops *ops = rdev->desc->ops;
1803 int old_sel = -1;
1804 int new_sel = -1;
1805 int voltage;
1806 int i;
1807
1808 /* Currently requires operations to do this */
1809 if (!ops->list_voltage || !ops->set_voltage_time_sel
1810 || !rdev->desc->n_voltages)
1811 return -EINVAL;
1812
1813 for (i = 0; i < rdev->desc->n_voltages; i++) {
1814 /* We only look for exact voltage matches here */
1815 voltage = regulator_list_voltage(regulator, i);
1816 if (voltage < 0)
1817 return -EINVAL;
1818 if (voltage == 0)
1819 continue;
1820 if (voltage == old_uV)
1821 old_sel = i;
1822 if (voltage == new_uV)
1823 new_sel = i;
1824 }
1825
1826 if (old_sel < 0 || new_sel < 0)
1827 return -EINVAL;
1828
1829 return ops->set_voltage_time_sel(rdev, old_sel, new_sel);
1830}
1831EXPORT_SYMBOL_GPL(regulator_set_voltage_time);
1832
1833/**
1834 * regulator_sync_voltage - re-apply last regulator output voltage
1835 * @regulator: regulator source
1836 *
1837 * Re-apply the last configured voltage. This is intended to be used
1838 * where some external control source the consumer is cooperating with
1839 * has caused the configured voltage to change.
1840 */
1841int regulator_sync_voltage(struct regulator *regulator)
1842{
1843 struct regulator_dev *rdev = regulator->rdev;
1844 int ret, min_uV, max_uV;
1845
1846 mutex_lock(&rdev->mutex);
1847
1848 if (!rdev->desc->ops->set_voltage &&
1849 !rdev->desc->ops->set_voltage_sel) {
1850 ret = -EINVAL;
1851 goto out;
1852 }
1853
1854 /* This is only going to work if we've had a voltage configured. */
1855 if (!regulator->min_uV && !regulator->max_uV) {
1856 ret = -EINVAL;
1857 goto out;
1858 }
1859
1860 min_uV = regulator->min_uV;
1861 max_uV = regulator->max_uV;
1862
1863 /* This should be a paranoia check... */
1864 ret = regulator_check_voltage(rdev, &min_uV, &max_uV);
1865 if (ret < 0)
1866 goto out;
1867
1868 ret = regulator_check_consumers(rdev, &min_uV, &max_uV);
1869 if (ret < 0)
1870 goto out;
1871
1872 ret = _regulator_do_set_voltage(rdev, min_uV, max_uV);
1873
1874out:
1875 mutex_unlock(&rdev->mutex);
1876 return ret;
1877}
1878EXPORT_SYMBOL_GPL(regulator_sync_voltage);
1879
1880static int _regulator_get_voltage(struct regulator_dev *rdev)
1881{
1882 int sel, ret;
1883
1884 if (rdev->desc->ops->get_voltage_sel) {
1885 sel = rdev->desc->ops->get_voltage_sel(rdev);
1886 if (sel < 0)
1887 return sel;
1888 ret = rdev->desc->ops->list_voltage(rdev, sel);
1889 } else if (rdev->desc->ops->get_voltage) {
1890 ret = rdev->desc->ops->get_voltage(rdev);
1891 } else {
1892 return -EINVAL;
1893 }
1894
1895 if (ret < 0)
1896 return ret;
1897 return ret - rdev->constraints->uV_offset;
1898}
1899
1900/**
1901 * regulator_get_voltage - get regulator output voltage
1902 * @regulator: regulator source
1903 *
1904 * This r…
Large files files are truncated, but you can click here to view the full file