Merge branch 'regulator-5.5' into regulator-linus
[muen/linux.git] / drivers / regulator / core.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 //
3 // core.c  --  Voltage/Current Regulator framework.
4 //
5 // Copyright 2007, 2008 Wolfson Microelectronics PLC.
6 // Copyright 2008 SlimLogic Ltd.
7 //
8 // Author: Liam Girdwood <lrg@slimlogic.co.uk>
9
10 #include <linux/kernel.h>
11 #include <linux/init.h>
12 #include <linux/debugfs.h>
13 #include <linux/device.h>
14 #include <linux/slab.h>
15 #include <linux/async.h>
16 #include <linux/err.h>
17 #include <linux/mutex.h>
18 #include <linux/suspend.h>
19 #include <linux/delay.h>
20 #include <linux/gpio/consumer.h>
21 #include <linux/of.h>
22 #include <linux/regmap.h>
23 #include <linux/regulator/of_regulator.h>
24 #include <linux/regulator/consumer.h>
25 #include <linux/regulator/coupler.h>
26 #include <linux/regulator/driver.h>
27 #include <linux/regulator/machine.h>
28 #include <linux/module.h>
29
30 #define CREATE_TRACE_POINTS
31 #include <trace/events/regulator.h>
32
33 #include "dummy.h"
34 #include "internal.h"
35
36 #define rdev_crit(rdev, fmt, ...)                                       \
37         pr_crit("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
38 #define rdev_err(rdev, fmt, ...)                                        \
39         pr_err("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
40 #define rdev_warn(rdev, fmt, ...)                                       \
41         pr_warn("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
42 #define rdev_info(rdev, fmt, ...)                                       \
43         pr_info("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
44 #define rdev_dbg(rdev, fmt, ...)                                        \
45         pr_debug("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
46
47 static DEFINE_WW_CLASS(regulator_ww_class);
48 static DEFINE_MUTEX(regulator_nesting_mutex);
49 static DEFINE_MUTEX(regulator_list_mutex);
50 static LIST_HEAD(regulator_map_list);
51 static LIST_HEAD(regulator_ena_gpio_list);
52 static LIST_HEAD(regulator_supply_alias_list);
53 static LIST_HEAD(regulator_coupler_list);
54 static bool has_full_constraints;
55
56 static struct dentry *debugfs_root;
57
58 /*
59  * struct regulator_map
60  *
61  * Used to provide symbolic supply names to devices.
62  */
63 struct regulator_map {
64         struct list_head list;
65         const char *dev_name;   /* The dev_name() for the consumer */
66         const char *supply;
67         struct regulator_dev *regulator;
68 };
69
70 /*
71  * struct regulator_enable_gpio
72  *
73  * Management for shared enable GPIO pin
74  */
75 struct regulator_enable_gpio {
76         struct list_head list;
77         struct gpio_desc *gpiod;
78         u32 enable_count;       /* a number of enabled shared GPIO */
79         u32 request_count;      /* a number of requested shared GPIO */
80 };
81
82 /*
83  * struct regulator_supply_alias
84  *
85  * Used to map lookups for a supply onto an alternative device.
86  */
87 struct regulator_supply_alias {
88         struct list_head list;
89         struct device *src_dev;
90         const char *src_supply;
91         struct device *alias_dev;
92         const char *alias_supply;
93 };
94
95 static int _regulator_is_enabled(struct regulator_dev *rdev);
96 static int _regulator_disable(struct regulator *regulator);
97 static int _regulator_get_current_limit(struct regulator_dev *rdev);
98 static unsigned int _regulator_get_mode(struct regulator_dev *rdev);
99 static int _notifier_call_chain(struct regulator_dev *rdev,
100                                   unsigned long event, void *data);
101 static int _regulator_do_set_voltage(struct regulator_dev *rdev,
102                                      int min_uV, int max_uV);
103 static int regulator_balance_voltage(struct regulator_dev *rdev,
104                                      suspend_state_t state);
105 static struct regulator *create_regulator(struct regulator_dev *rdev,
106                                           struct device *dev,
107                                           const char *supply_name);
108 static void _regulator_put(struct regulator *regulator);
109
110 const char *rdev_get_name(struct regulator_dev *rdev)
111 {
112         if (rdev->constraints && rdev->constraints->name)
113                 return rdev->constraints->name;
114         else if (rdev->desc->name)
115                 return rdev->desc->name;
116         else
117                 return "";
118 }
119
120 static bool have_full_constraints(void)
121 {
122         return has_full_constraints || of_have_populated_dt();
123 }
124
125 static bool regulator_ops_is_valid(struct regulator_dev *rdev, int ops)
126 {
127         if (!rdev->constraints) {
128                 rdev_err(rdev, "no constraints\n");
129                 return false;
130         }
131
132         if (rdev->constraints->valid_ops_mask & ops)
133                 return true;
134
135         return false;
136 }
137
138 /**
139  * regulator_lock_nested - lock a single regulator
140  * @rdev:               regulator source
141  * @ww_ctx:             w/w mutex acquire context
142  *
143  * This function can be called many times by one task on
144  * a single regulator and its mutex will be locked only
145  * once. If a task, which is calling this function is other
146  * than the one, which initially locked the mutex, it will
147  * wait on mutex.
148  */
149 static inline int regulator_lock_nested(struct regulator_dev *rdev,
150                                         struct ww_acquire_ctx *ww_ctx)
151 {
152         bool lock = false;
153         int ret = 0;
154
155         mutex_lock(&regulator_nesting_mutex);
156
157         if (ww_ctx || !ww_mutex_trylock(&rdev->mutex)) {
158                 if (rdev->mutex_owner == current)
159                         rdev->ref_cnt++;
160                 else
161                         lock = true;
162
163                 if (lock) {
164                         mutex_unlock(&regulator_nesting_mutex);
165                         ret = ww_mutex_lock(&rdev->mutex, ww_ctx);
166                         mutex_lock(&regulator_nesting_mutex);
167                 }
168         } else {
169                 lock = true;
170         }
171
172         if (lock && ret != -EDEADLK) {
173                 rdev->ref_cnt++;
174                 rdev->mutex_owner = current;
175         }
176
177         mutex_unlock(&regulator_nesting_mutex);
178
179         return ret;
180 }
181
182 /**
183  * regulator_lock - lock a single regulator
184  * @rdev:               regulator source
185  *
186  * This function can be called many times by one task on
187  * a single regulator and its mutex will be locked only
188  * once. If a task, which is calling this function is other
189  * than the one, which initially locked the mutex, it will
190  * wait on mutex.
191  */
192 void regulator_lock(struct regulator_dev *rdev)
193 {
194         regulator_lock_nested(rdev, NULL);
195 }
196 EXPORT_SYMBOL_GPL(regulator_lock);
197
198 /**
199  * regulator_unlock - unlock a single regulator
200  * @rdev:               regulator_source
201  *
202  * This function unlocks the mutex when the
203  * reference counter reaches 0.
204  */
205 void regulator_unlock(struct regulator_dev *rdev)
206 {
207         mutex_lock(&regulator_nesting_mutex);
208
209         if (--rdev->ref_cnt == 0) {
210                 rdev->mutex_owner = NULL;
211                 ww_mutex_unlock(&rdev->mutex);
212         }
213
214         WARN_ON_ONCE(rdev->ref_cnt < 0);
215
216         mutex_unlock(&regulator_nesting_mutex);
217 }
218 EXPORT_SYMBOL_GPL(regulator_unlock);
219
220 static bool regulator_supply_is_couple(struct regulator_dev *rdev)
221 {
222         struct regulator_dev *c_rdev;
223         int i;
224
225         for (i = 1; i < rdev->coupling_desc.n_coupled; i++) {
226                 c_rdev = rdev->coupling_desc.coupled_rdevs[i];
227
228                 if (rdev->supply->rdev == c_rdev)
229                         return true;
230         }
231
232         return false;
233 }
234
235 static void regulator_unlock_recursive(struct regulator_dev *rdev,
236                                        unsigned int n_coupled)
237 {
238         struct regulator_dev *c_rdev;
239         int i;
240
241         for (i = n_coupled; i > 0; i--) {
242                 c_rdev = rdev->coupling_desc.coupled_rdevs[i - 1];
243
244                 if (!c_rdev)
245                         continue;
246
247                 if (c_rdev->supply && !regulator_supply_is_couple(c_rdev))
248                         regulator_unlock_recursive(
249                                         c_rdev->supply->rdev,
250                                         c_rdev->coupling_desc.n_coupled);
251
252                 regulator_unlock(c_rdev);
253         }
254 }
255
256 static int regulator_lock_recursive(struct regulator_dev *rdev,
257                                     struct regulator_dev **new_contended_rdev,
258                                     struct regulator_dev **old_contended_rdev,
259                                     struct ww_acquire_ctx *ww_ctx)
260 {
261         struct regulator_dev *c_rdev;
262         int i, err;
263
264         for (i = 0; i < rdev->coupling_desc.n_coupled; i++) {
265                 c_rdev = rdev->coupling_desc.coupled_rdevs[i];
266
267                 if (!c_rdev)
268                         continue;
269
270                 if (c_rdev != *old_contended_rdev) {
271                         err = regulator_lock_nested(c_rdev, ww_ctx);
272                         if (err) {
273                                 if (err == -EDEADLK) {
274                                         *new_contended_rdev = c_rdev;
275                                         goto err_unlock;
276                                 }
277
278                                 /* shouldn't happen */
279                                 WARN_ON_ONCE(err != -EALREADY);
280                         }
281                 } else {
282                         *old_contended_rdev = NULL;
283                 }
284
285                 if (c_rdev->supply && !regulator_supply_is_couple(c_rdev)) {
286                         err = regulator_lock_recursive(c_rdev->supply->rdev,
287                                                        new_contended_rdev,
288                                                        old_contended_rdev,
289                                                        ww_ctx);
290                         if (err) {
291                                 regulator_unlock(c_rdev);
292                                 goto err_unlock;
293                         }
294                 }
295         }
296
297         return 0;
298
299 err_unlock:
300         regulator_unlock_recursive(rdev, i);
301
302         return err;
303 }
304
305 /**
306  * regulator_unlock_dependent - unlock regulator's suppliers and coupled
307  *                              regulators
308  * @rdev:                       regulator source
309  * @ww_ctx:                     w/w mutex acquire context
310  *
311  * Unlock all regulators related with rdev by coupling or supplying.
312  */
313 static void regulator_unlock_dependent(struct regulator_dev *rdev,
314                                        struct ww_acquire_ctx *ww_ctx)
315 {
316         regulator_unlock_recursive(rdev, rdev->coupling_desc.n_coupled);
317         ww_acquire_fini(ww_ctx);
318 }
319
320 /**
321  * regulator_lock_dependent - lock regulator's suppliers and coupled regulators
322  * @rdev:                       regulator source
323  * @ww_ctx:                     w/w mutex acquire context
324  *
325  * This function as a wrapper on regulator_lock_recursive(), which locks
326  * all regulators related with rdev by coupling or supplying.
327  */
328 static void regulator_lock_dependent(struct regulator_dev *rdev,
329                                      struct ww_acquire_ctx *ww_ctx)
330 {
331         struct regulator_dev *new_contended_rdev = NULL;
332         struct regulator_dev *old_contended_rdev = NULL;
333         int err;
334
335         mutex_lock(&regulator_list_mutex);
336
337         ww_acquire_init(ww_ctx, &regulator_ww_class);
338
339         do {
340                 if (new_contended_rdev) {
341                         ww_mutex_lock_slow(&new_contended_rdev->mutex, ww_ctx);
342                         old_contended_rdev = new_contended_rdev;
343                         old_contended_rdev->ref_cnt++;
344                 }
345
346                 err = regulator_lock_recursive(rdev,
347                                                &new_contended_rdev,
348                                                &old_contended_rdev,
349                                                ww_ctx);
350
351                 if (old_contended_rdev)
352                         regulator_unlock(old_contended_rdev);
353
354         } while (err == -EDEADLK);
355
356         ww_acquire_done(ww_ctx);
357
358         mutex_unlock(&regulator_list_mutex);
359 }
360
361 /**
362  * of_get_child_regulator - get a child regulator device node
363  * based on supply name
364  * @parent: Parent device node
365  * @prop_name: Combination regulator supply name and "-supply"
366  *
367  * Traverse all child nodes.
368  * Extract the child regulator device node corresponding to the supply name.
369  * returns the device node corresponding to the regulator if found, else
370  * returns NULL.
371  */
372 static struct device_node *of_get_child_regulator(struct device_node *parent,
373                                                   const char *prop_name)
374 {
375         struct device_node *regnode = NULL;
376         struct device_node *child = NULL;
377
378         for_each_child_of_node(parent, child) {
379                 regnode = of_parse_phandle(child, prop_name, 0);
380
381                 if (!regnode) {
382                         regnode = of_get_child_regulator(child, prop_name);
383                         if (regnode)
384                                 goto err_node_put;
385                 } else {
386                         goto err_node_put;
387                 }
388         }
389         return NULL;
390
391 err_node_put:
392         of_node_put(child);
393         return regnode;
394 }
395
396 /**
397  * of_get_regulator - get a regulator device node based on supply name
398  * @dev: Device pointer for the consumer (of regulator) device
399  * @supply: regulator supply name
400  *
401  * Extract the regulator device node corresponding to the supply name.
402  * returns the device node corresponding to the regulator if found, else
403  * returns NULL.
404  */
405 static struct device_node *of_get_regulator(struct device *dev, const char *supply)
406 {
407         struct device_node *regnode = NULL;
408         char prop_name[32]; /* 32 is max size of property name */
409
410         dev_dbg(dev, "Looking up %s-supply from device tree\n", supply);
411
412         snprintf(prop_name, 32, "%s-supply", supply);
413         regnode = of_parse_phandle(dev->of_node, prop_name, 0);
414
415         if (!regnode) {
416                 regnode = of_get_child_regulator(dev->of_node, prop_name);
417                 if (regnode)
418                         return regnode;
419
420                 dev_dbg(dev, "Looking up %s property in node %pOF failed\n",
421                                 prop_name, dev->of_node);
422                 return NULL;
423         }
424         return regnode;
425 }
426
427 /* Platform voltage constraint check */
428 int regulator_check_voltage(struct regulator_dev *rdev,
429                             int *min_uV, int *max_uV)
430 {
431         BUG_ON(*min_uV > *max_uV);
432
433         if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_VOLTAGE)) {
434                 rdev_err(rdev, "voltage operation not allowed\n");
435                 return -EPERM;
436         }
437
438         if (*max_uV > rdev->constraints->max_uV)
439                 *max_uV = rdev->constraints->max_uV;
440         if (*min_uV < rdev->constraints->min_uV)
441                 *min_uV = rdev->constraints->min_uV;
442
443         if (*min_uV > *max_uV) {
444                 rdev_err(rdev, "unsupportable voltage range: %d-%duV\n",
445                          *min_uV, *max_uV);
446                 return -EINVAL;
447         }
448
449         return 0;
450 }
451
452 /* return 0 if the state is valid */
453 static int regulator_check_states(suspend_state_t state)
454 {
455         return (state > PM_SUSPEND_MAX || state == PM_SUSPEND_TO_IDLE);
456 }
457
458 /* Make sure we select a voltage that suits the needs of all
459  * regulator consumers
460  */
461 int regulator_check_consumers(struct regulator_dev *rdev,
462                               int *min_uV, int *max_uV,
463                               suspend_state_t state)
464 {
465         struct regulator *regulator;
466         struct regulator_voltage *voltage;
467
468         list_for_each_entry(regulator, &rdev->consumer_list, list) {
469                 voltage = &regulator->voltage[state];
470                 /*
471                  * Assume consumers that didn't say anything are OK
472                  * with anything in the constraint range.
473                  */
474                 if (!voltage->min_uV && !voltage->max_uV)
475                         continue;
476
477                 if (*max_uV > voltage->max_uV)
478                         *max_uV = voltage->max_uV;
479                 if (*min_uV < voltage->min_uV)
480                         *min_uV = voltage->min_uV;
481         }
482
483         if (*min_uV > *max_uV) {
484                 rdev_err(rdev, "Restricting voltage, %u-%uuV\n",
485                         *min_uV, *max_uV);
486                 return -EINVAL;
487         }
488
489         return 0;
490 }
491
492 /* current constraint check */
493 static int regulator_check_current_limit(struct regulator_dev *rdev,
494                                         int *min_uA, int *max_uA)
495 {
496         BUG_ON(*min_uA > *max_uA);
497
498         if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_CURRENT)) {
499                 rdev_err(rdev, "current operation not allowed\n");
500                 return -EPERM;
501         }
502
503         if (*max_uA > rdev->constraints->max_uA)
504                 *max_uA = rdev->constraints->max_uA;
505         if (*min_uA < rdev->constraints->min_uA)
506                 *min_uA = rdev->constraints->min_uA;
507
508         if (*min_uA > *max_uA) {
509                 rdev_err(rdev, "unsupportable current range: %d-%duA\n",
510                          *min_uA, *max_uA);
511                 return -EINVAL;
512         }
513
514         return 0;
515 }
516
517 /* operating mode constraint check */
518 static int regulator_mode_constrain(struct regulator_dev *rdev,
519                                     unsigned int *mode)
520 {
521         switch (*mode) {
522         case REGULATOR_MODE_FAST:
523         case REGULATOR_MODE_NORMAL:
524         case REGULATOR_MODE_IDLE:
525         case REGULATOR_MODE_STANDBY:
526                 break;
527         default:
528                 rdev_err(rdev, "invalid mode %x specified\n", *mode);
529                 return -EINVAL;
530         }
531
532         if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_MODE)) {
533                 rdev_err(rdev, "mode operation not allowed\n");
534                 return -EPERM;
535         }
536
537         /* The modes are bitmasks, the most power hungry modes having
538          * the lowest values. If the requested mode isn't supported
539          * try higher modes. */
540         while (*mode) {
541                 if (rdev->constraints->valid_modes_mask & *mode)
542                         return 0;
543                 *mode /= 2;
544         }
545
546         return -EINVAL;
547 }
548
549 static inline struct regulator_state *
550 regulator_get_suspend_state(struct regulator_dev *rdev, suspend_state_t state)
551 {
552         if (rdev->constraints == NULL)
553                 return NULL;
554
555         switch (state) {
556         case PM_SUSPEND_STANDBY:
557                 return &rdev->constraints->state_standby;
558         case PM_SUSPEND_MEM:
559                 return &rdev->constraints->state_mem;
560         case PM_SUSPEND_MAX:
561                 return &rdev->constraints->state_disk;
562         default:
563                 return NULL;
564         }
565 }
566
567 static ssize_t regulator_uV_show(struct device *dev,
568                                 struct device_attribute *attr, char *buf)
569 {
570         struct regulator_dev *rdev = dev_get_drvdata(dev);
571         int uV;
572
573         regulator_lock(rdev);
574         uV = regulator_get_voltage_rdev(rdev);
575         regulator_unlock(rdev);
576
577         if (uV < 0)
578                 return uV;
579         return sprintf(buf, "%d\n", uV);
580 }
581 static DEVICE_ATTR(microvolts, 0444, regulator_uV_show, NULL);
582
583 static ssize_t regulator_uA_show(struct device *dev,
584                                 struct device_attribute *attr, char *buf)
585 {
586         struct regulator_dev *rdev = dev_get_drvdata(dev);
587
588         return sprintf(buf, "%d\n", _regulator_get_current_limit(rdev));
589 }
590 static DEVICE_ATTR(microamps, 0444, regulator_uA_show, NULL);
591
592 static ssize_t name_show(struct device *dev, struct device_attribute *attr,
593                          char *buf)
594 {
595         struct regulator_dev *rdev = dev_get_drvdata(dev);
596
597         return sprintf(buf, "%s\n", rdev_get_name(rdev));
598 }
599 static DEVICE_ATTR_RO(name);
600
601 static const char *regulator_opmode_to_str(int mode)
602 {
603         switch (mode) {
604         case REGULATOR_MODE_FAST:
605                 return "fast";
606         case REGULATOR_MODE_NORMAL:
607                 return "normal";
608         case REGULATOR_MODE_IDLE:
609                 return "idle";
610         case REGULATOR_MODE_STANDBY:
611                 return "standby";
612         }
613         return "unknown";
614 }
615
616 static ssize_t regulator_print_opmode(char *buf, int mode)
617 {
618         return sprintf(buf, "%s\n", regulator_opmode_to_str(mode));
619 }
620
621 static ssize_t regulator_opmode_show(struct device *dev,
622                                     struct device_attribute *attr, char *buf)
623 {
624         struct regulator_dev *rdev = dev_get_drvdata(dev);
625
626         return regulator_print_opmode(buf, _regulator_get_mode(rdev));
627 }
628 static DEVICE_ATTR(opmode, 0444, regulator_opmode_show, NULL);
629
630 static ssize_t regulator_print_state(char *buf, int state)
631 {
632         if (state > 0)
633                 return sprintf(buf, "enabled\n");
634         else if (state == 0)
635                 return sprintf(buf, "disabled\n");
636         else
637                 return sprintf(buf, "unknown\n");
638 }
639
640 static ssize_t regulator_state_show(struct device *dev,
641                                    struct device_attribute *attr, char *buf)
642 {
643         struct regulator_dev *rdev = dev_get_drvdata(dev);
644         ssize_t ret;
645
646         regulator_lock(rdev);
647         ret = regulator_print_state(buf, _regulator_is_enabled(rdev));
648         regulator_unlock(rdev);
649
650         return ret;
651 }
652 static DEVICE_ATTR(state, 0444, regulator_state_show, NULL);
653
654 static ssize_t regulator_status_show(struct device *dev,
655                                    struct device_attribute *attr, char *buf)
656 {
657         struct regulator_dev *rdev = dev_get_drvdata(dev);
658         int status;
659         char *label;
660
661         status = rdev->desc->ops->get_status(rdev);
662         if (status < 0)
663                 return status;
664
665         switch (status) {
666         case REGULATOR_STATUS_OFF:
667                 label = "off";
668                 break;
669         case REGULATOR_STATUS_ON:
670                 label = "on";
671                 break;
672         case REGULATOR_STATUS_ERROR:
673                 label = "error";
674                 break;
675         case REGULATOR_STATUS_FAST:
676                 label = "fast";
677                 break;
678         case REGULATOR_STATUS_NORMAL:
679                 label = "normal";
680                 break;
681         case REGULATOR_STATUS_IDLE:
682                 label = "idle";
683                 break;
684         case REGULATOR_STATUS_STANDBY:
685                 label = "standby";
686                 break;
687         case REGULATOR_STATUS_BYPASS:
688                 label = "bypass";
689                 break;
690         case REGULATOR_STATUS_UNDEFINED:
691                 label = "undefined";
692                 break;
693         default:
694                 return -ERANGE;
695         }
696
697         return sprintf(buf, "%s\n", label);
698 }
699 static DEVICE_ATTR(status, 0444, regulator_status_show, NULL);
700
701 static ssize_t regulator_min_uA_show(struct device *dev,
702                                     struct device_attribute *attr, char *buf)
703 {
704         struct regulator_dev *rdev = dev_get_drvdata(dev);
705
706         if (!rdev->constraints)
707                 return sprintf(buf, "constraint not defined\n");
708
709         return sprintf(buf, "%d\n", rdev->constraints->min_uA);
710 }
711 static DEVICE_ATTR(min_microamps, 0444, regulator_min_uA_show, NULL);
712
713 static ssize_t regulator_max_uA_show(struct device *dev,
714                                     struct device_attribute *attr, char *buf)
715 {
716         struct regulator_dev *rdev = dev_get_drvdata(dev);
717
718         if (!rdev->constraints)
719                 return sprintf(buf, "constraint not defined\n");
720
721         return sprintf(buf, "%d\n", rdev->constraints->max_uA);
722 }
723 static DEVICE_ATTR(max_microamps, 0444, regulator_max_uA_show, NULL);
724
725 static ssize_t regulator_min_uV_show(struct device *dev,
726                                     struct device_attribute *attr, char *buf)
727 {
728         struct regulator_dev *rdev = dev_get_drvdata(dev);
729
730         if (!rdev->constraints)
731                 return sprintf(buf, "constraint not defined\n");
732
733         return sprintf(buf, "%d\n", rdev->constraints->min_uV);
734 }
735 static DEVICE_ATTR(min_microvolts, 0444, regulator_min_uV_show, NULL);
736
737 static ssize_t regulator_max_uV_show(struct device *dev,
738                                     struct device_attribute *attr, char *buf)
739 {
740         struct regulator_dev *rdev = dev_get_drvdata(dev);
741
742         if (!rdev->constraints)
743                 return sprintf(buf, "constraint not defined\n");
744
745         return sprintf(buf, "%d\n", rdev->constraints->max_uV);
746 }
747 static DEVICE_ATTR(max_microvolts, 0444, regulator_max_uV_show, NULL);
748
749 static ssize_t regulator_total_uA_show(struct device *dev,
750                                       struct device_attribute *attr, char *buf)
751 {
752         struct regulator_dev *rdev = dev_get_drvdata(dev);
753         struct regulator *regulator;
754         int uA = 0;
755
756         regulator_lock(rdev);
757         list_for_each_entry(regulator, &rdev->consumer_list, list) {
758                 if (regulator->enable_count)
759                         uA += regulator->uA_load;
760         }
761         regulator_unlock(rdev);
762         return sprintf(buf, "%d\n", uA);
763 }
764 static DEVICE_ATTR(requested_microamps, 0444, regulator_total_uA_show, NULL);
765
766 static ssize_t num_users_show(struct device *dev, struct device_attribute *attr,
767                               char *buf)
768 {
769         struct regulator_dev *rdev = dev_get_drvdata(dev);
770         return sprintf(buf, "%d\n", rdev->use_count);
771 }
772 static DEVICE_ATTR_RO(num_users);
773
774 static ssize_t type_show(struct device *dev, struct device_attribute *attr,
775                          char *buf)
776 {
777         struct regulator_dev *rdev = dev_get_drvdata(dev);
778
779         switch (rdev->desc->type) {
780         case REGULATOR_VOLTAGE:
781                 return sprintf(buf, "voltage\n");
782         case REGULATOR_CURRENT:
783                 return sprintf(buf, "current\n");
784         }
785         return sprintf(buf, "unknown\n");
786 }
787 static DEVICE_ATTR_RO(type);
788
789 static ssize_t regulator_suspend_mem_uV_show(struct device *dev,
790                                 struct device_attribute *attr, char *buf)
791 {
792         struct regulator_dev *rdev = dev_get_drvdata(dev);
793
794         return sprintf(buf, "%d\n", rdev->constraints->state_mem.uV);
795 }
796 static DEVICE_ATTR(suspend_mem_microvolts, 0444,
797                 regulator_suspend_mem_uV_show, NULL);
798
799 static ssize_t regulator_suspend_disk_uV_show(struct device *dev,
800                                 struct device_attribute *attr, char *buf)
801 {
802         struct regulator_dev *rdev = dev_get_drvdata(dev);
803
804         return sprintf(buf, "%d\n", rdev->constraints->state_disk.uV);
805 }
806 static DEVICE_ATTR(suspend_disk_microvolts, 0444,
807                 regulator_suspend_disk_uV_show, NULL);
808
809 static ssize_t regulator_suspend_standby_uV_show(struct device *dev,
810                                 struct device_attribute *attr, char *buf)
811 {
812         struct regulator_dev *rdev = dev_get_drvdata(dev);
813
814         return sprintf(buf, "%d\n", rdev->constraints->state_standby.uV);
815 }
816 static DEVICE_ATTR(suspend_standby_microvolts, 0444,
817                 regulator_suspend_standby_uV_show, NULL);
818
819 static ssize_t regulator_suspend_mem_mode_show(struct device *dev,
820                                 struct device_attribute *attr, char *buf)
821 {
822         struct regulator_dev *rdev = dev_get_drvdata(dev);
823
824         return regulator_print_opmode(buf,
825                 rdev->constraints->state_mem.mode);
826 }
827 static DEVICE_ATTR(suspend_mem_mode, 0444,
828                 regulator_suspend_mem_mode_show, NULL);
829
830 static ssize_t regulator_suspend_disk_mode_show(struct device *dev,
831                                 struct device_attribute *attr, char *buf)
832 {
833         struct regulator_dev *rdev = dev_get_drvdata(dev);
834
835         return regulator_print_opmode(buf,
836                 rdev->constraints->state_disk.mode);
837 }
838 static DEVICE_ATTR(suspend_disk_mode, 0444,
839                 regulator_suspend_disk_mode_show, NULL);
840
841 static ssize_t regulator_suspend_standby_mode_show(struct device *dev,
842                                 struct device_attribute *attr, char *buf)
843 {
844         struct regulator_dev *rdev = dev_get_drvdata(dev);
845
846         return regulator_print_opmode(buf,
847                 rdev->constraints->state_standby.mode);
848 }
849 static DEVICE_ATTR(suspend_standby_mode, 0444,
850                 regulator_suspend_standby_mode_show, NULL);
851
852 static ssize_t regulator_suspend_mem_state_show(struct device *dev,
853                                    struct device_attribute *attr, char *buf)
854 {
855         struct regulator_dev *rdev = dev_get_drvdata(dev);
856
857         return regulator_print_state(buf,
858                         rdev->constraints->state_mem.enabled);
859 }
860 static DEVICE_ATTR(suspend_mem_state, 0444,
861                 regulator_suspend_mem_state_show, NULL);
862
863 static ssize_t regulator_suspend_disk_state_show(struct device *dev,
864                                    struct device_attribute *attr, char *buf)
865 {
866         struct regulator_dev *rdev = dev_get_drvdata(dev);
867
868         return regulator_print_state(buf,
869                         rdev->constraints->state_disk.enabled);
870 }
871 static DEVICE_ATTR(suspend_disk_state, 0444,
872                 regulator_suspend_disk_state_show, NULL);
873
874 static ssize_t regulator_suspend_standby_state_show(struct device *dev,
875                                    struct device_attribute *attr, char *buf)
876 {
877         struct regulator_dev *rdev = dev_get_drvdata(dev);
878
879         return regulator_print_state(buf,
880                         rdev->constraints->state_standby.enabled);
881 }
882 static DEVICE_ATTR(suspend_standby_state, 0444,
883                 regulator_suspend_standby_state_show, NULL);
884
885 static ssize_t regulator_bypass_show(struct device *dev,
886                                      struct device_attribute *attr, char *buf)
887 {
888         struct regulator_dev *rdev = dev_get_drvdata(dev);
889         const char *report;
890         bool bypass;
891         int ret;
892
893         ret = rdev->desc->ops->get_bypass(rdev, &bypass);
894
895         if (ret != 0)
896                 report = "unknown";
897         else if (bypass)
898                 report = "enabled";
899         else
900                 report = "disabled";
901
902         return sprintf(buf, "%s\n", report);
903 }
904 static DEVICE_ATTR(bypass, 0444,
905                    regulator_bypass_show, NULL);
906
907 /* Calculate the new optimum regulator operating mode based on the new total
908  * consumer load. All locks held by caller */
909 static int drms_uA_update(struct regulator_dev *rdev)
910 {
911         struct regulator *sibling;
912         int current_uA = 0, output_uV, input_uV, err;
913         unsigned int mode;
914
915         /*
916          * first check to see if we can set modes at all, otherwise just
917          * tell the consumer everything is OK.
918          */
919         if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_DRMS)) {
920                 rdev_dbg(rdev, "DRMS operation not allowed\n");
921                 return 0;
922         }
923
924         if (!rdev->desc->ops->get_optimum_mode &&
925             !rdev->desc->ops->set_load)
926                 return 0;
927
928         if (!rdev->desc->ops->set_mode &&
929             !rdev->desc->ops->set_load)
930                 return -EINVAL;
931
932         /* calc total requested load */
933         list_for_each_entry(sibling, &rdev->consumer_list, list) {
934                 if (sibling->enable_count)
935                         current_uA += sibling->uA_load;
936         }
937
938         current_uA += rdev->constraints->system_load;
939
940         if (rdev->desc->ops->set_load) {
941                 /* set the optimum mode for our new total regulator load */
942                 err = rdev->desc->ops->set_load(rdev, current_uA);
943                 if (err < 0)
944                         rdev_err(rdev, "failed to set load %d\n", current_uA);
945         } else {
946                 /* get output voltage */
947                 output_uV = regulator_get_voltage_rdev(rdev);
948                 if (output_uV <= 0) {
949                         rdev_err(rdev, "invalid output voltage found\n");
950                         return -EINVAL;
951                 }
952
953                 /* get input voltage */
954                 input_uV = 0;
955                 if (rdev->supply)
956                         input_uV = regulator_get_voltage(rdev->supply);
957                 if (input_uV <= 0)
958                         input_uV = rdev->constraints->input_uV;
959                 if (input_uV <= 0) {
960                         rdev_err(rdev, "invalid input voltage found\n");
961                         return -EINVAL;
962                 }
963
964                 /* now get the optimum mode for our new total regulator load */
965                 mode = rdev->desc->ops->get_optimum_mode(rdev, input_uV,
966                                                          output_uV, current_uA);
967
968                 /* check the new mode is allowed */
969                 err = regulator_mode_constrain(rdev, &mode);
970                 if (err < 0) {
971                         rdev_err(rdev, "failed to get optimum mode @ %d uA %d -> %d uV\n",
972                                  current_uA, input_uV, output_uV);
973                         return err;
974                 }
975
976                 err = rdev->desc->ops->set_mode(rdev, mode);
977                 if (err < 0)
978                         rdev_err(rdev, "failed to set optimum mode %x\n", mode);
979         }
980
981         return err;
982 }
983
984 static int suspend_set_state(struct regulator_dev *rdev,
985                                     suspend_state_t state)
986 {
987         int ret = 0;
988         struct regulator_state *rstate;
989
990         rstate = regulator_get_suspend_state(rdev, state);
991         if (rstate == NULL)
992                 return 0;
993
994         /* If we have no suspend mode configuration don't set anything;
995          * only warn if the driver implements set_suspend_voltage or
996          * set_suspend_mode callback.
997          */
998         if (rstate->enabled != ENABLE_IN_SUSPEND &&
999             rstate->enabled != DISABLE_IN_SUSPEND) {
1000                 if (rdev->desc->ops->set_suspend_voltage ||
1001                     rdev->desc->ops->set_suspend_mode)
1002                         rdev_warn(rdev, "No configuration\n");
1003                 return 0;
1004         }
1005
1006         if (rstate->enabled == ENABLE_IN_SUSPEND &&
1007                 rdev->desc->ops->set_suspend_enable)
1008                 ret = rdev->desc->ops->set_suspend_enable(rdev);
1009         else if (rstate->enabled == DISABLE_IN_SUSPEND &&
1010                 rdev->desc->ops->set_suspend_disable)
1011                 ret = rdev->desc->ops->set_suspend_disable(rdev);
1012         else /* OK if set_suspend_enable or set_suspend_disable is NULL */
1013                 ret = 0;
1014
1015         if (ret < 0) {
1016                 rdev_err(rdev, "failed to enabled/disable\n");
1017                 return ret;
1018         }
1019
1020         if (rdev->desc->ops->set_suspend_voltage && rstate->uV > 0) {
1021                 ret = rdev->desc->ops->set_suspend_voltage(rdev, rstate->uV);
1022                 if (ret < 0) {
1023                         rdev_err(rdev, "failed to set voltage\n");
1024                         return ret;
1025                 }
1026         }
1027
1028         if (rdev->desc->ops->set_suspend_mode && rstate->mode > 0) {
1029                 ret = rdev->desc->ops->set_suspend_mode(rdev, rstate->mode);
1030                 if (ret < 0) {
1031                         rdev_err(rdev, "failed to set mode\n");
1032                         return ret;
1033                 }
1034         }
1035
1036         return ret;
1037 }
1038
1039 static void print_constraints(struct regulator_dev *rdev)
1040 {
1041         struct regulation_constraints *constraints = rdev->constraints;
1042         char buf[160] = "";
1043         size_t len = sizeof(buf) - 1;
1044         int count = 0;
1045         int ret;
1046
1047         if (constraints->min_uV && constraints->max_uV) {
1048                 if (constraints->min_uV == constraints->max_uV)
1049                         count += scnprintf(buf + count, len - count, "%d mV ",
1050                                            constraints->min_uV / 1000);
1051                 else
1052                         count += scnprintf(buf + count, len - count,
1053                                            "%d <--> %d mV ",
1054                                            constraints->min_uV / 1000,
1055                                            constraints->max_uV / 1000);
1056         }
1057
1058         if (!constraints->min_uV ||
1059             constraints->min_uV != constraints->max_uV) {
1060                 ret = regulator_get_voltage_rdev(rdev);
1061                 if (ret > 0)
1062                         count += scnprintf(buf + count, len - count,
1063                                            "at %d mV ", ret / 1000);
1064         }
1065
1066         if (constraints->uV_offset)
1067                 count += scnprintf(buf + count, len - count, "%dmV offset ",
1068                                    constraints->uV_offset / 1000);
1069
1070         if (constraints->min_uA && constraints->max_uA) {
1071                 if (constraints->min_uA == constraints->max_uA)
1072                         count += scnprintf(buf + count, len - count, "%d mA ",
1073                                            constraints->min_uA / 1000);
1074                 else
1075                         count += scnprintf(buf + count, len - count,
1076                                            "%d <--> %d mA ",
1077                                            constraints->min_uA / 1000,
1078                                            constraints->max_uA / 1000);
1079         }
1080
1081         if (!constraints->min_uA ||
1082             constraints->min_uA != constraints->max_uA) {
1083                 ret = _regulator_get_current_limit(rdev);
1084                 if (ret > 0)
1085                         count += scnprintf(buf + count, len - count,
1086                                            "at %d mA ", ret / 1000);
1087         }
1088
1089         if (constraints->valid_modes_mask & REGULATOR_MODE_FAST)
1090                 count += scnprintf(buf + count, len - count, "fast ");
1091         if (constraints->valid_modes_mask & REGULATOR_MODE_NORMAL)
1092                 count += scnprintf(buf + count, len - count, "normal ");
1093         if (constraints->valid_modes_mask & REGULATOR_MODE_IDLE)
1094                 count += scnprintf(buf + count, len - count, "idle ");
1095         if (constraints->valid_modes_mask & REGULATOR_MODE_STANDBY)
1096                 count += scnprintf(buf + count, len - count, "standby");
1097
1098         if (!count)
1099                 scnprintf(buf, len, "no parameters");
1100
1101         rdev_dbg(rdev, "%s\n", buf);
1102
1103         if ((constraints->min_uV != constraints->max_uV) &&
1104             !regulator_ops_is_valid(rdev, REGULATOR_CHANGE_VOLTAGE))
1105                 rdev_warn(rdev,
1106                           "Voltage range but no REGULATOR_CHANGE_VOLTAGE\n");
1107 }
1108
1109 static int machine_constraints_voltage(struct regulator_dev *rdev,
1110         struct regulation_constraints *constraints)
1111 {
1112         const struct regulator_ops *ops = rdev->desc->ops;
1113         int ret;
1114
1115         /* do we need to apply the constraint voltage */
1116         if (rdev->constraints->apply_uV &&
1117             rdev->constraints->min_uV && rdev->constraints->max_uV) {
1118                 int target_min, target_max;
1119                 int current_uV = regulator_get_voltage_rdev(rdev);
1120
1121                 if (current_uV == -ENOTRECOVERABLE) {
1122                         /* This regulator can't be read and must be initialized */
1123                         rdev_info(rdev, "Setting %d-%duV\n",
1124                                   rdev->constraints->min_uV,
1125                                   rdev->constraints->max_uV);
1126                         _regulator_do_set_voltage(rdev,
1127                                                   rdev->constraints->min_uV,
1128                                                   rdev->constraints->max_uV);
1129                         current_uV = regulator_get_voltage_rdev(rdev);
1130                 }
1131
1132                 if (current_uV < 0) {
1133                         rdev_err(rdev,
1134                                  "failed to get the current voltage(%d)\n",
1135                                  current_uV);
1136                         return current_uV;
1137                 }
1138
1139                 /*
1140                  * If we're below the minimum voltage move up to the
1141                  * minimum voltage, if we're above the maximum voltage
1142                  * then move down to the maximum.
1143                  */
1144                 target_min = current_uV;
1145                 target_max = current_uV;
1146
1147                 if (current_uV < rdev->constraints->min_uV) {
1148                         target_min = rdev->constraints->min_uV;
1149                         target_max = rdev->constraints->min_uV;
1150                 }
1151
1152                 if (current_uV > rdev->constraints->max_uV) {
1153                         target_min = rdev->constraints->max_uV;
1154                         target_max = rdev->constraints->max_uV;
1155                 }
1156
1157                 if (target_min != current_uV || target_max != current_uV) {
1158                         rdev_info(rdev, "Bringing %duV into %d-%duV\n",
1159                                   current_uV, target_min, target_max);
1160                         ret = _regulator_do_set_voltage(
1161                                 rdev, target_min, target_max);
1162                         if (ret < 0) {
1163                                 rdev_err(rdev,
1164                                         "failed to apply %d-%duV constraint(%d)\n",
1165                                         target_min, target_max, ret);
1166                                 return ret;
1167                         }
1168                 }
1169         }
1170
1171         /* constrain machine-level voltage specs to fit
1172          * the actual range supported by this regulator.
1173          */
1174         if (ops->list_voltage && rdev->desc->n_voltages) {
1175                 int     count = rdev->desc->n_voltages;
1176                 int     i;
1177                 int     min_uV = INT_MAX;
1178                 int     max_uV = INT_MIN;
1179                 int     cmin = constraints->min_uV;
1180                 int     cmax = constraints->max_uV;
1181
1182                 /* it's safe to autoconfigure fixed-voltage supplies
1183                    and the constraints are used by list_voltage. */
1184                 if (count == 1 && !cmin) {
1185                         cmin = 1;
1186                         cmax = INT_MAX;
1187                         constraints->min_uV = cmin;
1188                         constraints->max_uV = cmax;
1189                 }
1190
1191                 /* voltage constraints are optional */
1192                 if ((cmin == 0) && (cmax == 0))
1193                         return 0;
1194
1195                 /* else require explicit machine-level constraints */
1196                 if (cmin <= 0 || cmax <= 0 || cmax < cmin) {
1197                         rdev_err(rdev, "invalid voltage constraints\n");
1198                         return -EINVAL;
1199                 }
1200
1201                 /* no need to loop voltages if range is continuous */
1202                 if (rdev->desc->continuous_voltage_range)
1203                         return 0;
1204
1205                 /* initial: [cmin..cmax] valid, [min_uV..max_uV] not */
1206                 for (i = 0; i < count; i++) {
1207                         int     value;
1208
1209                         value = ops->list_voltage(rdev, i);
1210                         if (value <= 0)
1211                                 continue;
1212
1213                         /* maybe adjust [min_uV..max_uV] */
1214                         if (value >= cmin && value < min_uV)
1215                                 min_uV = value;
1216                         if (value <= cmax && value > max_uV)
1217                                 max_uV = value;
1218                 }
1219
1220                 /* final: [min_uV..max_uV] valid iff constraints valid */
1221                 if (max_uV < min_uV) {
1222                         rdev_err(rdev,
1223                                  "unsupportable voltage constraints %u-%uuV\n",
1224                                  min_uV, max_uV);
1225                         return -EINVAL;
1226                 }
1227
1228                 /* use regulator's subset of machine constraints */
1229                 if (constraints->min_uV < min_uV) {
1230                         rdev_dbg(rdev, "override min_uV, %d -> %d\n",
1231                                  constraints->min_uV, min_uV);
1232                         constraints->min_uV = min_uV;
1233                 }
1234                 if (constraints->max_uV > max_uV) {
1235                         rdev_dbg(rdev, "override max_uV, %d -> %d\n",
1236                                  constraints->max_uV, max_uV);
1237                         constraints->max_uV = max_uV;
1238                 }
1239         }
1240
1241         return 0;
1242 }
1243
1244 static int machine_constraints_current(struct regulator_dev *rdev,
1245         struct regulation_constraints *constraints)
1246 {
1247         const struct regulator_ops *ops = rdev->desc->ops;
1248         int ret;
1249
1250         if (!constraints->min_uA && !constraints->max_uA)
1251                 return 0;
1252
1253         if (constraints->min_uA > constraints->max_uA) {
1254                 rdev_err(rdev, "Invalid current constraints\n");
1255                 return -EINVAL;
1256         }
1257
1258         if (!ops->set_current_limit || !ops->get_current_limit) {
1259                 rdev_warn(rdev, "Operation of current configuration missing\n");
1260                 return 0;
1261         }
1262
1263         /* Set regulator current in constraints range */
1264         ret = ops->set_current_limit(rdev, constraints->min_uA,
1265                         constraints->max_uA);
1266         if (ret < 0) {
1267                 rdev_err(rdev, "Failed to set current constraint, %d\n", ret);
1268                 return ret;
1269         }
1270
1271         return 0;
1272 }
1273
1274 static int _regulator_do_enable(struct regulator_dev *rdev);
1275
1276 /**
1277  * set_machine_constraints - sets regulator constraints
1278  * @rdev: regulator source
1279  * @constraints: constraints to apply
1280  *
1281  * Allows platform initialisation code to define and constrain
1282  * regulator circuits e.g. valid voltage/current ranges, etc.  NOTE:
1283  * Constraints *must* be set by platform code in order for some
1284  * regulator operations to proceed i.e. set_voltage, set_current_limit,
1285  * set_mode.
1286  */
1287 static int set_machine_constraints(struct regulator_dev *rdev,
1288         const struct regulation_constraints *constraints)
1289 {
1290         int ret = 0;
1291         const struct regulator_ops *ops = rdev->desc->ops;
1292
1293         if (constraints)
1294                 rdev->constraints = kmemdup(constraints, sizeof(*constraints),
1295                                             GFP_KERNEL);
1296         else
1297                 rdev->constraints = kzalloc(sizeof(*constraints),
1298                                             GFP_KERNEL);
1299         if (!rdev->constraints)
1300                 return -ENOMEM;
1301
1302         ret = machine_constraints_voltage(rdev, rdev->constraints);
1303         if (ret != 0)
1304                 return ret;
1305
1306         ret = machine_constraints_current(rdev, rdev->constraints);
1307         if (ret != 0)
1308                 return ret;
1309
1310         if (rdev->constraints->ilim_uA && ops->set_input_current_limit) {
1311                 ret = ops->set_input_current_limit(rdev,
1312                                                    rdev->constraints->ilim_uA);
1313                 if (ret < 0) {
1314                         rdev_err(rdev, "failed to set input limit\n");
1315                         return ret;
1316                 }
1317         }
1318
1319         /* do we need to setup our suspend state */
1320         if (rdev->constraints->initial_state) {
1321                 ret = suspend_set_state(rdev, rdev->constraints->initial_state);
1322                 if (ret < 0) {
1323                         rdev_err(rdev, "failed to set suspend state\n");
1324                         return ret;
1325                 }
1326         }
1327
1328         if (rdev->constraints->initial_mode) {
1329                 if (!ops->set_mode) {
1330                         rdev_err(rdev, "no set_mode operation\n");
1331                         return -EINVAL;
1332                 }
1333
1334                 ret = ops->set_mode(rdev, rdev->constraints->initial_mode);
1335                 if (ret < 0) {
1336                         rdev_err(rdev, "failed to set initial mode: %d\n", ret);
1337                         return ret;
1338                 }
1339         } else if (rdev->constraints->system_load) {
1340                 /*
1341                  * We'll only apply the initial system load if an
1342                  * initial mode wasn't specified.
1343                  */
1344                 drms_uA_update(rdev);
1345         }
1346
1347         if ((rdev->constraints->ramp_delay || rdev->constraints->ramp_disable)
1348                 && ops->set_ramp_delay) {
1349                 ret = ops->set_ramp_delay(rdev, rdev->constraints->ramp_delay);
1350                 if (ret < 0) {
1351                         rdev_err(rdev, "failed to set ramp_delay\n");
1352                         return ret;
1353                 }
1354         }
1355
1356         if (rdev->constraints->pull_down && ops->set_pull_down) {
1357                 ret = ops->set_pull_down(rdev);
1358                 if (ret < 0) {
1359                         rdev_err(rdev, "failed to set pull down\n");
1360                         return ret;
1361                 }
1362         }
1363
1364         if (rdev->constraints->soft_start && ops->set_soft_start) {
1365                 ret = ops->set_soft_start(rdev);
1366                 if (ret < 0) {
1367                         rdev_err(rdev, "failed to set soft start\n");
1368                         return ret;
1369                 }
1370         }
1371
1372         if (rdev->constraints->over_current_protection
1373                 && ops->set_over_current_protection) {
1374                 ret = ops->set_over_current_protection(rdev);
1375                 if (ret < 0) {
1376                         rdev_err(rdev, "failed to set over current protection\n");
1377                         return ret;
1378                 }
1379         }
1380
1381         if (rdev->constraints->active_discharge && ops->set_active_discharge) {
1382                 bool ad_state = (rdev->constraints->active_discharge ==
1383                               REGULATOR_ACTIVE_DISCHARGE_ENABLE) ? true : false;
1384
1385                 ret = ops->set_active_discharge(rdev, ad_state);
1386                 if (ret < 0) {
1387                         rdev_err(rdev, "failed to set active discharge\n");
1388                         return ret;
1389                 }
1390         }
1391
1392         /* If the constraints say the regulator should be on at this point
1393          * and we have control then make sure it is enabled.
1394          */
1395         if (rdev->constraints->always_on || rdev->constraints->boot_on) {
1396                 if (rdev->supply) {
1397                         ret = regulator_enable(rdev->supply);
1398                         if (ret < 0) {
1399                                 _regulator_put(rdev->supply);
1400                                 rdev->supply = NULL;
1401                                 return ret;
1402                         }
1403                 }
1404
1405                 ret = _regulator_do_enable(rdev);
1406                 if (ret < 0 && ret != -EINVAL) {
1407                         rdev_err(rdev, "failed to enable\n");
1408                         return ret;
1409                 }
1410
1411                 if (rdev->constraints->always_on)
1412                         rdev->use_count++;
1413         }
1414
1415         print_constraints(rdev);
1416         return 0;
1417 }
1418
1419 /**
1420  * set_supply - set regulator supply regulator
1421  * @rdev: regulator name
1422  * @supply_rdev: supply regulator name
1423  *
1424  * Called by platform initialisation code to set the supply regulator for this
1425  * regulator. This ensures that a regulators supply will also be enabled by the
1426  * core if it's child is enabled.
1427  */
1428 static int set_supply(struct regulator_dev *rdev,
1429                       struct regulator_dev *supply_rdev)
1430 {
1431         int err;
1432
1433         rdev_info(rdev, "supplied by %s\n", rdev_get_name(supply_rdev));
1434
1435         if (!try_module_get(supply_rdev->owner))
1436                 return -ENODEV;
1437
1438         rdev->supply = create_regulator(supply_rdev, &rdev->dev, "SUPPLY");
1439         if (rdev->supply == NULL) {
1440                 err = -ENOMEM;
1441                 return err;
1442         }
1443         supply_rdev->open_count++;
1444
1445         return 0;
1446 }
1447
1448 /**
1449  * set_consumer_device_supply - Bind a regulator to a symbolic supply
1450  * @rdev:         regulator source
1451  * @consumer_dev_name: dev_name() string for device supply applies to
1452  * @supply:       symbolic name for supply
1453  *
1454  * Allows platform initialisation code to map physical regulator
1455  * sources to symbolic names for supplies for use by devices.  Devices
1456  * should use these symbolic names to request regulators, avoiding the
1457  * need to provide board-specific regulator names as platform data.
1458  */
1459 static int set_consumer_device_supply(struct regulator_dev *rdev,
1460                                       const char *consumer_dev_name,
1461                                       const char *supply)
1462 {
1463         struct regulator_map *node;
1464         int has_dev;
1465
1466         if (supply == NULL)
1467                 return -EINVAL;
1468
1469         if (consumer_dev_name != NULL)
1470                 has_dev = 1;
1471         else
1472                 has_dev = 0;
1473
1474         list_for_each_entry(node, &regulator_map_list, list) {
1475                 if (node->dev_name && consumer_dev_name) {
1476                         if (strcmp(node->dev_name, consumer_dev_name) != 0)
1477                                 continue;
1478                 } else if (node->dev_name || consumer_dev_name) {
1479                         continue;
1480                 }
1481
1482                 if (strcmp(node->supply, supply) != 0)
1483                         continue;
1484
1485                 pr_debug("%s: %s/%s is '%s' supply; fail %s/%s\n",
1486                          consumer_dev_name,
1487                          dev_name(&node->regulator->dev),
1488                          node->regulator->desc->name,
1489                          supply,
1490                          dev_name(&rdev->dev), rdev_get_name(rdev));
1491                 return -EBUSY;
1492         }
1493
1494         node = kzalloc(sizeof(struct regulator_map), GFP_KERNEL);
1495         if (node == NULL)
1496                 return -ENOMEM;
1497
1498         node->regulator = rdev;
1499         node->supply = supply;
1500
1501         if (has_dev) {
1502                 node->dev_name = kstrdup(consumer_dev_name, GFP_KERNEL);
1503                 if (node->dev_name == NULL) {
1504                         kfree(node);
1505                         return -ENOMEM;
1506                 }
1507         }
1508
1509         list_add(&node->list, &regulator_map_list);
1510         return 0;
1511 }
1512
1513 static void unset_regulator_supplies(struct regulator_dev *rdev)
1514 {
1515         struct regulator_map *node, *n;
1516
1517         list_for_each_entry_safe(node, n, &regulator_map_list, list) {
1518                 if (rdev == node->regulator) {
1519                         list_del(&node->list);
1520                         kfree(node->dev_name);
1521                         kfree(node);
1522                 }
1523         }
1524 }
1525
1526 #ifdef CONFIG_DEBUG_FS
1527 static ssize_t constraint_flags_read_file(struct file *file,
1528                                           char __user *user_buf,
1529                                           size_t count, loff_t *ppos)
1530 {
1531         const struct regulator *regulator = file->private_data;
1532         const struct regulation_constraints *c = regulator->rdev->constraints;
1533         char *buf;
1534         ssize_t ret;
1535
1536         if (!c)
1537                 return 0;
1538
1539         buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
1540         if (!buf)
1541                 return -ENOMEM;
1542
1543         ret = snprintf(buf, PAGE_SIZE,
1544                         "always_on: %u\n"
1545                         "boot_on: %u\n"
1546                         "apply_uV: %u\n"
1547                         "ramp_disable: %u\n"
1548                         "soft_start: %u\n"
1549                         "pull_down: %u\n"
1550                         "over_current_protection: %u\n",
1551                         c->always_on,
1552                         c->boot_on,
1553                         c->apply_uV,
1554                         c->ramp_disable,
1555                         c->soft_start,
1556                         c->pull_down,
1557                         c->over_current_protection);
1558
1559         ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
1560         kfree(buf);
1561
1562         return ret;
1563 }
1564
1565 #endif
1566
1567 static const struct file_operations constraint_flags_fops = {
1568 #ifdef CONFIG_DEBUG_FS
1569         .open = simple_open,
1570         .read = constraint_flags_read_file,
1571         .llseek = default_llseek,
1572 #endif
1573 };
1574
1575 #define REG_STR_SIZE    64
1576
1577 static struct regulator *create_regulator(struct regulator_dev *rdev,
1578                                           struct device *dev,
1579                                           const char *supply_name)
1580 {
1581         struct regulator *regulator;
1582         char buf[REG_STR_SIZE];
1583         int err, size;
1584
1585         regulator = kzalloc(sizeof(*regulator), GFP_KERNEL);
1586         if (regulator == NULL)
1587                 return NULL;
1588
1589         regulator_lock(rdev);
1590         regulator->rdev = rdev;
1591         list_add(&regulator->list, &rdev->consumer_list);
1592
1593         if (dev) {
1594                 regulator->dev = dev;
1595
1596                 /* Add a link to the device sysfs entry */
1597                 size = snprintf(buf, REG_STR_SIZE, "%s-%s",
1598                                 dev->kobj.name, supply_name);
1599                 if (size >= REG_STR_SIZE)
1600                         goto overflow_err;
1601
1602                 regulator->supply_name = kstrdup(buf, GFP_KERNEL);
1603                 if (regulator->supply_name == NULL)
1604                         goto overflow_err;
1605
1606                 err = sysfs_create_link_nowarn(&rdev->dev.kobj, &dev->kobj,
1607                                         buf);
1608                 if (err) {
1609                         rdev_dbg(rdev, "could not add device link %s err %d\n",
1610                                   dev->kobj.name, err);
1611                         /* non-fatal */
1612                 }
1613         } else {
1614                 regulator->supply_name = kstrdup_const(supply_name, GFP_KERNEL);
1615                 if (regulator->supply_name == NULL)
1616                         goto overflow_err;
1617         }
1618
1619         regulator->debugfs = debugfs_create_dir(regulator->supply_name,
1620                                                 rdev->debugfs);
1621         if (!regulator->debugfs) {
1622                 rdev_dbg(rdev, "Failed to create debugfs directory\n");
1623         } else {
1624                 debugfs_create_u32("uA_load", 0444, regulator->debugfs,
1625                                    &regulator->uA_load);
1626                 debugfs_create_u32("min_uV", 0444, regulator->debugfs,
1627                                    &regulator->voltage[PM_SUSPEND_ON].min_uV);
1628                 debugfs_create_u32("max_uV", 0444, regulator->debugfs,
1629                                    &regulator->voltage[PM_SUSPEND_ON].max_uV);
1630                 debugfs_create_file("constraint_flags", 0444,
1631                                     regulator->debugfs, regulator,
1632                                     &constraint_flags_fops);
1633         }
1634
1635         /*
1636          * Check now if the regulator is an always on regulator - if
1637          * it is then we don't need to do nearly so much work for
1638          * enable/disable calls.
1639          */
1640         if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_STATUS) &&
1641             _regulator_is_enabled(rdev))
1642                 regulator->always_on = true;
1643
1644         regulator_unlock(rdev);
1645         return regulator;
1646 overflow_err:
1647         list_del(&regulator->list);
1648         kfree(regulator);
1649         regulator_unlock(rdev);
1650         return NULL;
1651 }
1652
1653 static int _regulator_get_enable_time(struct regulator_dev *rdev)
1654 {
1655         if (rdev->constraints && rdev->constraints->enable_time)
1656                 return rdev->constraints->enable_time;
1657         if (rdev->desc->ops->enable_time)
1658                 return rdev->desc->ops->enable_time(rdev);
1659         return rdev->desc->enable_time;
1660 }
1661
1662 static struct regulator_supply_alias *regulator_find_supply_alias(
1663                 struct device *dev, const char *supply)
1664 {
1665         struct regulator_supply_alias *map;
1666
1667         list_for_each_entry(map, &regulator_supply_alias_list, list)
1668                 if (map->src_dev == dev && strcmp(map->src_supply, supply) == 0)
1669                         return map;
1670
1671         return NULL;
1672 }
1673
1674 static void regulator_supply_alias(struct device **dev, const char **supply)
1675 {
1676         struct regulator_supply_alias *map;
1677
1678         map = regulator_find_supply_alias(*dev, *supply);
1679         if (map) {
1680                 dev_dbg(*dev, "Mapping supply %s to %s,%s\n",
1681                                 *supply, map->alias_supply,
1682                                 dev_name(map->alias_dev));
1683                 *dev = map->alias_dev;
1684                 *supply = map->alias_supply;
1685         }
1686 }
1687
1688 static int regulator_match(struct device *dev, const void *data)
1689 {
1690         struct regulator_dev *r = dev_to_rdev(dev);
1691
1692         return strcmp(rdev_get_name(r), data) == 0;
1693 }
1694
1695 static struct regulator_dev *regulator_lookup_by_name(const char *name)
1696 {
1697         struct device *dev;
1698
1699         dev = class_find_device(&regulator_class, NULL, name, regulator_match);
1700
1701         return dev ? dev_to_rdev(dev) : NULL;
1702 }
1703
1704 /**
1705  * regulator_dev_lookup - lookup a regulator device.
1706  * @dev: device for regulator "consumer".
1707  * @supply: Supply name or regulator ID.
1708  *
1709  * If successful, returns a struct regulator_dev that corresponds to the name
1710  * @supply and with the embedded struct device refcount incremented by one.
1711  * The refcount must be dropped by calling put_device().
1712  * On failure one of the following ERR-PTR-encoded values is returned:
1713  * -ENODEV if lookup fails permanently, -EPROBE_DEFER if lookup could succeed
1714  * in the future.
1715  */
1716 static struct regulator_dev *regulator_dev_lookup(struct device *dev,
1717                                                   const char *supply)
1718 {
1719         struct regulator_dev *r = NULL;
1720         struct device_node *node;
1721         struct regulator_map *map;
1722         const char *devname = NULL;
1723
1724         regulator_supply_alias(&dev, &supply);
1725
1726         /* first do a dt based lookup */
1727         if (dev && dev->of_node) {
1728                 node = of_get_regulator(dev, supply);
1729                 if (node) {
1730                         r = of_find_regulator_by_node(node);
1731                         if (r)
1732                                 return r;
1733
1734                         /*
1735                          * We have a node, but there is no device.
1736                          * assume it has not registered yet.
1737                          */
1738                         return ERR_PTR(-EPROBE_DEFER);
1739                 }
1740         }
1741
1742         /* if not found, try doing it non-dt way */
1743         if (dev)
1744                 devname = dev_name(dev);
1745
1746         mutex_lock(&regulator_list_mutex);
1747         list_for_each_entry(map, &regulator_map_list, list) {
1748                 /* If the mapping has a device set up it must match */
1749                 if (map->dev_name &&
1750                     (!devname || strcmp(map->dev_name, devname)))
1751                         continue;
1752
1753                 if (strcmp(map->supply, supply) == 0 &&
1754                     get_device(&map->regulator->dev)) {
1755                         r = map->regulator;
1756                         break;
1757                 }
1758         }
1759         mutex_unlock(&regulator_list_mutex);
1760
1761         if (r)
1762                 return r;
1763
1764         r = regulator_lookup_by_name(supply);
1765         if (r)
1766                 return r;
1767
1768         return ERR_PTR(-ENODEV);
1769 }
1770
1771 static int regulator_resolve_supply(struct regulator_dev *rdev)
1772 {
1773         struct regulator_dev *r;
1774         struct device *dev = rdev->dev.parent;
1775         int ret;
1776
1777         /* No supply to resolve? */
1778         if (!rdev->supply_name)
1779                 return 0;
1780
1781         /* Supply already resolved? */
1782         if (rdev->supply)
1783                 return 0;
1784
1785         r = regulator_dev_lookup(dev, rdev->supply_name);
1786         if (IS_ERR(r)) {
1787                 ret = PTR_ERR(r);
1788
1789                 /* Did the lookup explicitly defer for us? */
1790                 if (ret == -EPROBE_DEFER)
1791                         return ret;
1792
1793                 if (have_full_constraints()) {
1794                         r = dummy_regulator_rdev;
1795                         get_device(&r->dev);
1796                 } else {
1797                         dev_err(dev, "Failed to resolve %s-supply for %s\n",
1798                                 rdev->supply_name, rdev->desc->name);
1799                         return -EPROBE_DEFER;
1800                 }
1801         }
1802
1803         /*
1804          * If the supply's parent device is not the same as the
1805          * regulator's parent device, then ensure the parent device
1806          * is bound before we resolve the supply, in case the parent
1807          * device get probe deferred and unregisters the supply.
1808          */
1809         if (r->dev.parent && r->dev.parent != rdev->dev.parent) {
1810                 if (!device_is_bound(r->dev.parent)) {
1811                         put_device(&r->dev);
1812                         return -EPROBE_DEFER;
1813                 }
1814         }
1815
1816         /* Recursively resolve the supply of the supply */
1817         ret = regulator_resolve_supply(r);
1818         if (ret < 0) {
1819                 put_device(&r->dev);
1820                 return ret;
1821         }
1822
1823         ret = set_supply(rdev, r);
1824         if (ret < 0) {
1825                 put_device(&r->dev);
1826                 return ret;
1827         }
1828
1829         /*
1830          * In set_machine_constraints() we may have turned this regulator on
1831          * but we couldn't propagate to the supply if it hadn't been resolved
1832          * yet.  Do it now.
1833          */
1834         if (rdev->use_count) {
1835                 ret = regulator_enable(rdev->supply);
1836                 if (ret < 0) {
1837                         _regulator_put(rdev->supply);
1838                         rdev->supply = NULL;
1839                         return ret;
1840                 }
1841         }
1842
1843         return 0;
1844 }
1845
1846 /* Internal regulator request function */
1847 struct regulator *_regulator_get(struct device *dev, const char *id,
1848                                  enum regulator_get_type get_type)
1849 {
1850         struct regulator_dev *rdev;
1851         struct regulator *regulator;
1852         const char *devname = dev ? dev_name(dev) : "deviceless";
1853         struct device_link *link;
1854         int ret;
1855
1856         if (get_type >= MAX_GET_TYPE) {
1857                 dev_err(dev, "invalid type %d in %s\n", get_type, __func__);
1858                 return ERR_PTR(-EINVAL);
1859         }
1860
1861         if (id == NULL) {
1862                 pr_err("get() with no identifier\n");
1863                 return ERR_PTR(-EINVAL);
1864         }
1865
1866         rdev = regulator_dev_lookup(dev, id);
1867         if (IS_ERR(rdev)) {
1868                 ret = PTR_ERR(rdev);
1869
1870                 /*
1871                  * If regulator_dev_lookup() fails with error other
1872                  * than -ENODEV our job here is done, we simply return it.
1873                  */
1874                 if (ret != -ENODEV)
1875                         return ERR_PTR(ret);
1876
1877                 if (!have_full_constraints()) {
1878                         dev_warn(dev,
1879                                  "incomplete constraints, dummy supplies not allowed\n");
1880                         return ERR_PTR(-ENODEV);
1881                 }
1882
1883                 switch (get_type) {
1884                 case NORMAL_GET:
1885                         /*
1886                          * Assume that a regulator is physically present and
1887                          * enabled, even if it isn't hooked up, and just
1888                          * provide a dummy.
1889                          */
1890                         dev_warn(dev,
1891                                  "%s supply %s not found, using dummy regulator\n",
1892                                  devname, id);
1893                         rdev = dummy_regulator_rdev;
1894                         get_device(&rdev->dev);
1895                         break;
1896
1897                 case EXCLUSIVE_GET:
1898                         dev_warn(dev,
1899                                  "dummy supplies not allowed for exclusive requests\n");
1900                         /* fall through */
1901
1902                 default:
1903                         return ERR_PTR(-ENODEV);
1904                 }
1905         }
1906
1907         if (rdev->exclusive) {
1908                 regulator = ERR_PTR(-EPERM);
1909                 put_device(&rdev->dev);
1910                 return regulator;
1911         }
1912
1913         if (get_type == EXCLUSIVE_GET && rdev->open_count) {
1914                 regulator = ERR_PTR(-EBUSY);
1915                 put_device(&rdev->dev);
1916                 return regulator;
1917         }
1918
1919         mutex_lock(&regulator_list_mutex);
1920         ret = (rdev->coupling_desc.n_resolved != rdev->coupling_desc.n_coupled);
1921         mutex_unlock(&regulator_list_mutex);
1922
1923         if (ret != 0) {
1924                 regulator = ERR_PTR(-EPROBE_DEFER);
1925                 put_device(&rdev->dev);
1926                 return regulator;
1927         }
1928
1929         ret = regulator_resolve_supply(rdev);
1930         if (ret < 0) {
1931                 regulator = ERR_PTR(ret);
1932                 put_device(&rdev->dev);
1933                 return regulator;
1934         }
1935
1936         if (!try_module_get(rdev->owner)) {
1937                 regulator = ERR_PTR(-EPROBE_DEFER);
1938                 put_device(&rdev->dev);
1939                 return regulator;
1940         }
1941
1942         regulator = create_regulator(rdev, dev, id);
1943         if (regulator == NULL) {
1944                 regulator = ERR_PTR(-ENOMEM);
1945                 module_put(rdev->owner);
1946                 put_device(&rdev->dev);
1947                 return regulator;
1948         }
1949
1950         rdev->open_count++;
1951         if (get_type == EXCLUSIVE_GET) {
1952                 rdev->exclusive = 1;
1953
1954                 ret = _regulator_is_enabled(rdev);
1955                 if (ret > 0)
1956                         rdev->use_count = 1;
1957                 else
1958                         rdev->use_count = 0;
1959         }
1960
1961         link = device_link_add(dev, &rdev->dev, DL_FLAG_STATELESS);
1962         if (!IS_ERR_OR_NULL(link))
1963                 regulator->device_link = true;
1964
1965         return regulator;
1966 }
1967
1968 /**
1969  * regulator_get - lookup and obtain a reference to a regulator.
1970  * @dev: device for regulator "consumer"
1971  * @id: Supply name or regulator ID.
1972  *
1973  * Returns a struct regulator corresponding to the regulator producer,
1974  * or IS_ERR() condition containing errno.
1975  *
1976  * Use of supply names configured via regulator_set_device_supply() is
1977  * strongly encouraged.  It is recommended that the supply name used
1978  * should match the name used for the supply and/or the relevant
1979  * device pins in the datasheet.
1980  */
1981 struct regulator *regulator_get(struct device *dev, const char *id)
1982 {
1983         return _regulator_get(dev, id, NORMAL_GET);
1984 }
1985 EXPORT_SYMBOL_GPL(regulator_get);
1986
1987 /**
1988  * regulator_get_exclusive - obtain exclusive access to a regulator.
1989  * @dev: device for regulator "consumer"
1990  * @id: Supply name or regulator ID.
1991  *
1992  * Returns a struct regulator corresponding to the regulator producer,
1993  * or IS_ERR() condition containing errno.  Other consumers will be
1994  * unable to obtain this regulator while this reference is held and the
1995  * use count for the regulator will be initialised to reflect the current
1996  * state of the regulator.
1997  *
1998  * This is intended for use by consumers which cannot tolerate shared
1999  * use of the regulator such as those which need to force the
2000  * regulator off for correct operation of the hardware they are
2001  * controlling.
2002  *
2003  * Use of supply names configured via regulator_set_device_supply() is
2004  * strongly encouraged.  It is recommended that the supply name used
2005  * should match the name used for the supply and/or the relevant
2006  * device pins in the datasheet.
2007  */
2008 struct regulator *regulator_get_exclusive(struct device *dev, const char *id)
2009 {
2010         return _regulator_get(dev, id, EXCLUSIVE_GET);
2011 }
2012 EXPORT_SYMBOL_GPL(regulator_get_exclusive);
2013
2014 /**
2015  * regulator_get_optional - obtain optional access to a regulator.
2016  * @dev: device for regulator "consumer"
2017  * @id: Supply name or regulator ID.
2018  *
2019  * Returns a struct regulator corresponding to the regulator producer,
2020  * or IS_ERR() condition containing errno.
2021  *
2022  * This is intended for use by consumers for devices which can have
2023  * some supplies unconnected in normal use, such as some MMC devices.
2024  * It can allow the regulator core to provide stub supplies for other
2025  * supplies requested using normal regulator_get() calls without
2026  * disrupting the operation of drivers that can handle absent
2027  * supplies.
2028  *
2029  * Use of supply names configured via regulator_set_device_supply() is
2030  * strongly encouraged.  It is recommended that the supply name used
2031  * should match the name used for the supply and/or the relevant
2032  * device pins in the datasheet.
2033  */
2034 struct regulator *regulator_get_optional(struct device *dev, const char *id)
2035 {
2036         return _regulator_get(dev, id, OPTIONAL_GET);
2037 }
2038 EXPORT_SYMBOL_GPL(regulator_get_optional);
2039
2040 /* regulator_list_mutex lock held by regulator_put() */
2041 static void _regulator_put(struct regulator *regulator)
2042 {
2043         struct regulator_dev *rdev;
2044
2045         if (IS_ERR_OR_NULL(regulator))
2046                 return;
2047
2048         lockdep_assert_held_once(&regulator_list_mutex);
2049
2050         /* Docs say you must disable before calling regulator_put() */
2051         WARN_ON(regulator->enable_count);
2052
2053         rdev = regulator->rdev;
2054
2055         debugfs_remove_recursive(regulator->debugfs);
2056
2057         if (regulator->dev) {
2058                 if (regulator->device_link)
2059                         device_link_remove(regulator->dev, &rdev->dev);
2060
2061                 /* remove any sysfs entries */
2062                 sysfs_remove_link(&rdev->dev.kobj, regulator->supply_name);
2063         }
2064
2065         regulator_lock(rdev);
2066         list_del(&regulator->list);
2067
2068         rdev->open_count--;
2069         rdev->exclusive = 0;
2070         regulator_unlock(rdev);
2071
2072         kfree_const(regulator->supply_name);
2073         kfree(regulator);
2074
2075         module_put(rdev->owner);
2076         put_device(&rdev->dev);
2077 }
2078
2079 /**
2080  * regulator_put - "free" the regulator source
2081  * @regulator: regulator source
2082  *
2083  * Note: drivers must ensure that all regulator_enable calls made on this
2084  * regulator source are balanced by regulator_disable calls prior to calling
2085  * this function.
2086  */
2087 void regulator_put(struct regulator *regulator)
2088 {
2089         mutex_lock(&regulator_list_mutex);
2090         _regulator_put(regulator);
2091         mutex_unlock(&regulator_list_mutex);
2092 }
2093 EXPORT_SYMBOL_GPL(regulator_put);
2094
2095 /**
2096  * regulator_register_supply_alias - Provide device alias for supply lookup
2097  *
2098  * @dev: device that will be given as the regulator "consumer"
2099  * @id: Supply name or regulator ID
2100  * @alias_dev: device that should be used to lookup the supply
2101  * @alias_id: Supply name or regulator ID that should be used to lookup the
2102  * supply
2103  *
2104  * All lookups for id on dev will instead be conducted for alias_id on
2105  * alias_dev.
2106  */
2107 int regulator_register_supply_alias(struct device *dev, const char *id,
2108                                     struct device *alias_dev,
2109                                     const char *alias_id)
2110 {
2111         struct regulator_supply_alias *map;
2112
2113         map = regulator_find_supply_alias(dev, id);
2114         if (map)
2115                 return -EEXIST;
2116
2117         map = kzalloc(sizeof(struct regulator_supply_alias), GFP_KERNEL);
2118         if (!map)
2119                 return -ENOMEM;
2120
2121         map->src_dev = dev;
2122         map->src_supply = id;
2123         map->alias_dev = alias_dev;
2124         map->alias_supply = alias_id;
2125
2126         list_add(&map->list, &regulator_supply_alias_list);
2127
2128         pr_info("Adding alias for supply %s,%s -> %s,%s\n",
2129                 id, dev_name(dev), alias_id, dev_name(alias_dev));
2130
2131         return 0;
2132 }
2133 EXPORT_SYMBOL_GPL(regulator_register_supply_alias);
2134
2135 /**
2136  * regulator_unregister_supply_alias - Remove device alias
2137  *
2138  * @dev: device that will be given as the regulator "consumer"
2139  * @id: Supply name or regulator ID
2140  *
2141  * Remove a lookup alias if one exists for id on dev.
2142  */
2143 void regulator_unregister_supply_alias(struct device *dev, const char *id)
2144 {
2145         struct regulator_supply_alias *map;
2146
2147         map = regulator_find_supply_alias(dev, id);
2148         if (map) {
2149                 list_del(&map->list);
2150                 kfree(map);
2151         }
2152 }
2153 EXPORT_SYMBOL_GPL(regulator_unregister_supply_alias);
2154
2155 /**
2156  * regulator_bulk_register_supply_alias - register multiple aliases
2157  *
2158  * @dev: device that will be given as the regulator "consumer"
2159  * @id: List of supply names or regulator IDs
2160  * @alias_dev: device that should be used to lookup the supply
2161  * @alias_id: List of supply names or regulator IDs that should be used to
2162  * lookup the supply
2163  * @num_id: Number of aliases to register
2164  *
2165  * @return 0 on success, an errno on failure.
2166  *
2167  * This helper function allows drivers to register several supply
2168  * aliases in one operation.  If any of the aliases cannot be
2169  * registered any aliases that were registered will be removed
2170  * before returning to the caller.
2171  */
2172 int regulator_bulk_register_supply_alias(struct device *dev,
2173                                          const char *const *id,
2174                                          struct device *alias_dev,
2175                                          const char *const *alias_id,
2176                                          int num_id)
2177 {
2178         int i;
2179         int ret;
2180
2181         for (i = 0; i < num_id; ++i) {
2182                 ret = regulator_register_supply_alias(dev, id[i], alias_dev,
2183                                                       alias_id[i]);
2184                 if (ret < 0)
2185                         goto err;
2186         }
2187
2188         return 0;
2189
2190 err:
2191         dev_err(dev,
2192                 "Failed to create supply alias %s,%s -> %s,%s\n",
2193                 id[i], dev_name(dev), alias_id[i], dev_name(alias_dev));
2194
2195         while (--i >= 0)
2196                 regulator_unregister_supply_alias(dev, id[i]);
2197
2198         return ret;
2199 }
2200 EXPORT_SYMBOL_GPL(regulator_bulk_register_supply_alias);
2201
2202 /**
2203  * regulator_bulk_unregister_supply_alias - unregister multiple aliases
2204  *
2205  * @dev: device that will be given as the regulator "consumer"
2206  * @id: List of supply names or regulator IDs
2207  * @num_id: Number of aliases to unregister
2208  *
2209  * This helper function allows drivers to unregister several supply
2210  * aliases in one operation.
2211  */
2212 void regulator_bulk_unregister_supply_alias(struct device *dev,
2213                                             const char *const *id,
2214                                             int num_id)
2215 {
2216         int i;
2217
2218         for (i = 0; i < num_id; ++i)
2219                 regulator_unregister_supply_alias(dev, id[i]);
2220 }
2221 EXPORT_SYMBOL_GPL(regulator_bulk_unregister_supply_alias);
2222
2223
2224 /* Manage enable GPIO list. Same GPIO pin can be shared among regulators */
2225 static int regulator_ena_gpio_request(struct regulator_dev *rdev,
2226                                 const struct regulator_config *config)
2227 {
2228         struct regulator_enable_gpio *pin;
2229         struct gpio_desc *gpiod;
2230
2231         gpiod = config->ena_gpiod;
2232
2233         list_for_each_entry(pin, &regulator_ena_gpio_list, list) {
2234                 if (pin->gpiod == gpiod) {
2235                         rdev_dbg(rdev, "GPIO is already used\n");
2236                         goto update_ena_gpio_to_rdev;
2237                 }
2238         }
2239
2240         pin = kzalloc(sizeof(struct regulator_enable_gpio), GFP_KERNEL);
2241         if (pin == NULL)
2242                 return -ENOMEM;
2243
2244         pin->gpiod = gpiod;
2245         list_add(&pin->list, &regulator_ena_gpio_list);
2246
2247 update_ena_gpio_to_rdev:
2248         pin->request_count++;
2249         rdev->ena_pin = pin;
2250         return 0;
2251 }
2252
2253 static void regulator_ena_gpio_free(struct regulator_dev *rdev)
2254 {
2255         struct regulator_enable_gpio *pin, *n;
2256
2257         if (!rdev->ena_pin)
2258                 return;
2259
2260         /* Free the GPIO only in case of no use */
2261         list_for_each_entry_safe(pin, n, &regulator_ena_gpio_list, list) {
2262                 if (pin->gpiod == rdev->ena_pin->gpiod) {
2263                         if (pin->request_count <= 1) {
2264                                 pin->request_count = 0;
2265                                 gpiod_put(pin->gpiod);
2266                                 list_del(&pin->list);
2267                                 kfree(pin);
2268                                 rdev->ena_pin = NULL;
2269                                 return;
2270                         } else {
2271                                 pin->request_count--;
2272                         }
2273                 }
2274         }
2275 }
2276
2277 /**
2278  * regulator_ena_gpio_ctrl - balance enable_count of each GPIO and actual GPIO pin control
2279  * @rdev: regulator_dev structure
2280  * @enable: enable GPIO at initial use?
2281  *
2282  * GPIO is enabled in case of initial use. (enable_count is 0)
2283  * GPIO is disabled when it is not shared any more. (enable_count <= 1)
2284  */
2285 static int regulator_ena_gpio_ctrl(struct regulator_dev *rdev, bool enable)
2286 {
2287         struct regulator_enable_gpio *pin = rdev->ena_pin;
2288
2289         if (!pin)
2290                 return -EINVAL;
2291
2292         if (enable) {
2293                 /* Enable GPIO at initial use */
2294                 if (pin->enable_count == 0)
2295                         gpiod_set_value_cansleep(pin->gpiod, 1);
2296
2297                 pin->enable_count++;
2298         } else {
2299                 if (pin->enable_count > 1) {
2300                         pin->enable_count--;
2301                         return 0;
2302                 }
2303
2304                 /* Disable GPIO if not used */
2305                 if (pin->enable_count <= 1) {
2306                         gpiod_set_value_cansleep(pin->gpiod, 0);
2307                         pin->enable_count = 0;
2308                 }
2309         }
2310
2311         return 0;
2312 }
2313
2314 /**
2315  * _regulator_enable_delay - a delay helper function
2316  * @delay: time to delay in microseconds
2317  *
2318  * Delay for the requested amount of time as per the guidelines in:
2319  *
2320  *     Documentation/timers/timers-howto.rst
2321  *
2322  * The assumption here is that regulators will never be enabled in
2323  * atomic context and therefore sleeping functions can be used.
2324  */
2325 static void _regulator_enable_delay(unsigned int delay)
2326 {
2327         unsigned int ms = delay / 1000;
2328         unsigned int us = delay % 1000;
2329
2330         if (ms > 0) {
2331                 /*
2332                  * For small enough values, handle super-millisecond
2333                  * delays in the usleep_range() call below.
2334                  */
2335                 if (ms < 20)
2336                         us += ms * 1000;
2337                 else
2338                         msleep(ms);
2339         }
2340
2341         /*
2342          * Give the scheduler some room to coalesce with any other
2343          * wakeup sources. For delays shorter than 10 us, don't even
2344          * bother setting up high-resolution timers and just busy-
2345          * loop.
2346          */
2347         if (us >= 10)
2348                 usleep_range(us, us + 100);
2349         else
2350                 udelay(us);
2351 }
2352
2353 static int _regulator_do_enable(struct regulator_dev *rdev)
2354 {
2355         int ret, delay;
2356
2357         /* Query before enabling in case configuration dependent.  */
2358         ret = _regulator_get_enable_time(rdev);
2359         if (ret >= 0) {
2360                 delay = ret;
2361         } else {
2362                 rdev_warn(rdev, "enable_time() failed: %d\n", ret);
2363                 delay = 0;
2364         }
2365
2366         trace_regulator_enable(rdev_get_name(rdev));
2367
2368         if (rdev->desc->off_on_delay) {
2369                 /* if needed, keep a distance of off_on_delay from last time
2370                  * this regulator was disabled.
2371                  */
2372                 unsigned long start_jiffy = jiffies;
2373                 unsigned long intended, max_delay, remaining;
2374
2375                 max_delay = usecs_to_jiffies(rdev->desc->off_on_delay);
2376                 intended = rdev->last_off_jiffy + max_delay;
2377
2378                 if (time_before(start_jiffy, intended)) {
2379                         /* calc remaining jiffies to deal with one-time
2380                          * timer wrapping.
2381                          * in case of multiple timer wrapping, either it can be
2382                          * detected by out-of-range remaining, or it cannot be
2383                          * detected and we get a penalty of
2384                          * _regulator_enable_delay().
2385                          */
2386                         remaining = intended - start_jiffy;
2387                         if (remaining <= max_delay)
2388                                 _regulator_enable_delay(
2389                                                 jiffies_to_usecs(remaining));
2390                 }
2391         }
2392
2393         if (rdev->ena_pin) {
2394                 if (!rdev->ena_gpio_state) {
2395                         ret = regulator_ena_gpio_ctrl(rdev, true);
2396                         if (ret < 0)
2397                                 return ret;
2398                         rdev->ena_gpio_state = 1;
2399                 }
2400         } else if (rdev->desc->ops->enable) {
2401                 ret = rdev->desc->ops->enable(rdev);
2402                 if (ret < 0)
2403                         return ret;
2404         } else {
2405                 return -EINVAL;
2406         }
2407
2408         /* Allow the regulator to ramp; it would be useful to extend
2409          * this for bulk operations so that the regulators can ramp
2410          * together.  */
2411         trace_regulator_enable_delay(rdev_get_name(rdev));
2412
2413         _regulator_enable_delay(delay);
2414
2415         trace_regulator_enable_complete(rdev_get_name(rdev));
2416
2417         return 0;
2418 }
2419
2420 /**
2421  * _regulator_handle_consumer_enable - handle that a consumer enabled
2422  * @regulator: regulator source
2423  *
2424  * Some things on a regulator consumer (like the contribution towards total
2425  * load on the regulator) only have an effect when the consumer wants the
2426  * regulator enabled.  Explained in example with two consumers of the same
2427  * regulator:
2428  *   consumer A: set_load(100);       => total load = 0
2429  *   consumer A: regulator_enable();  => total load = 100
2430  *   consumer B: set_load(1000);      => total load = 100
2431  *   consumer B: regulator_enable();  => total load = 1100
2432  *   consumer A: regulator_disable(); => total_load = 1000
2433  *
2434  * This function (together with _regulator_handle_consumer_disable) is
2435  * responsible for keeping track of the refcount for a given regulator consumer
2436  * and applying / unapplying these things.
2437  *
2438  * Returns 0 upon no error; -error upon error.
2439  */
2440 static int _regulator_handle_consumer_enable(struct regulator *regulator)
2441 {
2442         struct regulator_dev *rdev = regulator->rdev;
2443
2444         lockdep_assert_held_once(&rdev->mutex.base);
2445
2446         regulator->enable_count++;
2447         if (regulator->uA_load && regulator->enable_count == 1)
2448                 return drms_uA_update(rdev);
2449
2450         return 0;
2451 }
2452
2453 /**
2454  * _regulator_handle_consumer_disable - handle that a consumer disabled
2455  * @regulator: regulator source
2456  *
2457  * The opposite of _regulator_handle_consumer_enable().
2458  *
2459  * Returns 0 upon no error; -error upon error.
2460  */
2461 static int _regulator_handle_consumer_disable(struct regulator *regulator)
2462 {
2463         struct regulator_dev *rdev = regulator->rdev;
2464
2465         lockdep_assert_held_once(&rdev->mutex.base);
2466
2467         if (!regulator->enable_count) {
2468                 rdev_err(rdev, "Underflow of regulator enable count\n");
2469                 return -EINVAL;
2470         }
2471
2472         regulator->enable_count--;
2473         if (regulator->uA_load && regulator->enable_count == 0)
2474                 return drms_uA_update(rdev);
2475
2476         return 0;
2477 }
2478
2479 /* locks held by regulator_enable() */
2480 static int _regulator_enable(struct regulator *regulator)
2481 {
2482         struct regulator_dev *rdev = regulator->rdev;
2483         int ret;
2484
2485         lockdep_assert_held_once(&rdev->mutex.base);
2486
2487         if (rdev->use_count == 0 && rdev->supply) {
2488                 ret = _regulator_enable(rdev->supply);
2489                 if (ret < 0)
2490                         return ret;
2491         }
2492
2493         /* balance only if there are regulators coupled */
2494         if (rdev->coupling_desc.n_coupled > 1) {
2495                 ret = regulator_balance_voltage(rdev, PM_SUSPEND_ON);
2496                 if (ret < 0)
2497                         goto err_disable_supply;
2498         }
2499
2500         ret = _regulator_handle_consumer_enable(regulator);
2501         if (ret < 0)
2502                 goto err_disable_supply;
2503
2504         if (rdev->use_count == 0) {
2505                 /* The regulator may on if it's not switchable or left on */
2506                 ret = _regulator_is_enabled(rdev);
2507                 if (ret == -EINVAL || ret == 0) {
2508                         if (!regulator_ops_is_valid(rdev,
2509                                         REGULATOR_CHANGE_STATUS)) {
2510                                 ret = -EPERM;
2511                                 goto err_consumer_disable;
2512                         }
2513
2514                         ret = _regulator_do_enable(rdev);
2515                         if (ret < 0)
2516                                 goto err_consumer_disable;
2517
2518                         _notifier_call_chain(rdev, REGULATOR_EVENT_ENABLE,
2519                                              NULL);
2520                 } else if (ret < 0) {
2521                         rdev_err(rdev, "is_enabled() failed: %d\n", ret);
2522                         goto err_consumer_disable;
2523                 }
2524                 /* Fallthrough on positive return values - already enabled */
2525         }
2526
2527         rdev->use_count++;
2528
2529         return 0;
2530
2531 err_consumer_disable:
2532         _regulator_handle_consumer_disable(regulator);
2533
2534 err_disable_supply:
2535         if (rdev->use_count == 0 && rdev->supply)
2536                 _regulator_disable(rdev->supply);
2537
2538         return ret;
2539 }
2540
2541 /**
2542  * regulator_enable - enable regulator output
2543  * @regulator: regulator source
2544  *
2545  * Request that the regulator be enabled with the regulator output at
2546  * the predefined voltage or current value.  Calls to regulator_enable()
2547  * must be balanced with calls to regulator_disable().
2548  *
2549  * NOTE: the output value can be set by other drivers, boot loader or may be
2550  * hardwired in the regulator.
2551  */
2552 int regulator_enable(struct regulator *regulator)
2553 {
2554         struct regulator_dev *rdev = regulator->rdev;
2555         struct ww_acquire_ctx ww_ctx;
2556         int ret;
2557
2558         regulator_lock_dependent(rdev, &ww_ctx);
2559         ret = _regulator_enable(regulator);
2560         regulator_unlock_dependent(rdev, &ww_ctx);
2561
2562         return ret;
2563 }
2564 EXPORT_SYMBOL_GPL(regulator_enable);
2565
2566 static int _regulator_do_disable(struct regulator_dev *rdev)
2567 {
2568         int ret;
2569
2570         trace_regulator_disable(rdev_get_name(rdev));
2571
2572         if (rdev->ena_pin) {
2573                 if (rdev->ena_gpio_state) {
2574                         ret = regulator_ena_gpio_ctrl(rdev, false);
2575                         if (ret < 0)
2576                                 return ret;
2577                         rdev->ena_gpio_state = 0;
2578                 }
2579
2580         } else if (rdev->desc->ops->disable) {
2581                 ret = rdev->desc->ops->disable(rdev);
2582                 if (ret != 0)
2583                         return ret;
2584         }
2585
2586         /* cares about last_off_jiffy only if off_on_delay is required by
2587          * device.
2588          */
2589         if (rdev->desc->off_on_delay)
2590                 rdev->last_off_jiffy = jiffies;
2591
2592         trace_regulator_disable_complete(rdev_get_name(rdev));
2593
2594         return 0;
2595 }
2596
2597 /* locks held by regulator_disable() */
2598 static int _regulator_disable(struct regulator *regulator)
2599 {
2600         struct regulator_dev *rdev = regulator->rdev;
2601         int ret = 0;
2602
2603         lockdep_assert_held_once(&rdev->mutex.base);
2604
2605         if (WARN(rdev->use_count <= 0,
2606                  "unbalanced disables for %s\n", rdev_get_name(rdev)))
2607                 return -EIO;
2608
2609         /* are we the last user and permitted to disable ? */
2610         if (rdev->use_count == 1 &&
2611             (rdev->constraints && !rdev->constraints->always_on)) {
2612
2613                 /* we are last user */
2614                 if (regulator_ops_is_valid(rdev, REGULATOR_CHANGE_STATUS)) {
2615                         ret = _notifier_call_chain(rdev,
2616                                                    REGULATOR_EVENT_PRE_DISABLE,
2617                                                    NULL);
2618                         if (ret & NOTIFY_STOP_MASK)
2619                                 return -EINVAL;
2620
2621                         ret = _regulator_do_disable(rdev);
2622                         if (ret < 0) {
2623                                 rdev_err(rdev, "failed to disable\n");
2624                                 _notifier_call_chain(rdev,
2625                                                 REGULATOR_EVENT_ABORT_DISABLE,
2626                                                 NULL);
2627                                 return ret;
2628                         }
2629                         _notifier_call_chain(rdev, REGULATOR_EVENT_DISABLE,
2630                                         NULL);
2631                 }
2632
2633                 rdev->use_count = 0;
2634         } else if (rdev->use_count > 1) {
2635                 rdev->use_count--;
2636         }
2637
2638         if (ret == 0)
2639                 ret = _regulator_handle_consumer_disable(regulator);
2640
2641         if (ret == 0 && rdev->coupling_desc.n_coupled > 1)
2642                 ret = regulator_balance_voltage(rdev, PM_SUSPEND_ON);
2643
2644         if (ret == 0 && rdev->use_count == 0 && rdev->supply)
2645                 ret = _regulator_disable(rdev->supply);
2646
2647         return ret;
2648 }
2649
2650 /**
2651  * regulator_disable - disable regulator output
2652  * @regulator: regulator source
2653  *
2654  * Disable the regulator output voltage or current.  Calls to
2655  * regulator_enable() must be balanced with calls to
2656  * regulator_disable().
2657  *
2658  * NOTE: this will only disable the regulator output if no other consumer
2659  * devices have it enabled, the regulator device supports disabling and
2660  * machine constraints permit this operation.
2661  */
2662 int regulator_disable(struct regulator *regulator)
2663 {
2664         struct regulator_dev *rdev = regulator->rdev;
2665         struct ww_acquire_ctx ww_ctx;
2666         int ret;
2667
2668         regulator_lock_dependent(rdev, &ww_ctx);
2669         ret = _regulator_disable(regulator);
2670         regulator_unlock_dependent(rdev, &ww_ctx);
2671
2672         return ret;
2673 }
2674 EXPORT_SYMBOL_GPL(regulator_disable);
2675
2676 /* locks held by regulator_force_disable() */
2677 static int _regulator_force_disable(struct regulator_dev *rdev)
2678 {
2679         int ret = 0;
2680
2681         lockdep_assert_held_once(&rdev->mutex.base);
2682
2683         ret = _notifier_call_chain(rdev, REGULATOR_EVENT_FORCE_DISABLE |
2684                         REGULATOR_EVENT_PRE_DISABLE, NULL);
2685         if (ret & NOTIFY_STOP_MASK)
2686                 return -EINVAL;
2687
2688         ret = _regulator_do_disable(rdev);
2689         if (ret < 0) {
2690                 rdev_err(rdev, "failed to force disable\n");
2691                 _notifier_call_chain(rdev, REGULATOR_EVENT_FORCE_DISABLE |
2692                                 REGULATOR_EVENT_ABORT_DISABLE, NULL);
2693                 return ret;
2694         }
2695
2696         _notifier_call_chain(rdev, REGULATOR_EVENT_FORCE_DISABLE |
2697                         REGULATOR_EVENT_DISABLE, NULL);
2698
2699         return 0;
2700 }
2701
2702 /**
2703  * regulator_force_disable - force disable regulator output
2704  * @regulator: regulator source
2705  *
2706  * Forcibly disable the regulator output voltage or current.
2707  * NOTE: this *will* disable the regulator output even if other consumer
2708  * devices have it enabled. This should be used for situations when device
2709  * damage will likely occur if the regulator is not disabled (e.g. over temp).
2710  */
2711 int regulator_force_disable(struct regulator *regulator)
2712 {
2713         struct regulator_dev *rdev = regulator->rdev;
2714         struct ww_acquire_ctx ww_ctx;
2715         int ret;
2716
2717         regulator_lock_dependent(rdev, &ww_ctx);
2718
2719         ret = _regulator_force_disable(regulator->rdev);
2720
2721         if (rdev->coupling_desc.n_coupled > 1)
2722                 regulator_balance_voltage(rdev, PM_SUSPEND_ON);
2723
2724         if (regulator->uA_load) {
2725                 regulator->uA_load = 0;
2726                 ret = drms_uA_update(rdev);
2727         }
2728
2729         if (rdev->use_count != 0 && rdev->supply)
2730                 _regulator_disable(rdev->supply);
2731
2732         regulator_unlock_dependent(rdev, &ww_ctx);
2733
2734         return ret;
2735 }
2736 EXPORT_SYMBOL_GPL(regulator_force_disable);
2737
2738 static void regulator_disable_work(struct work_struct *work)
2739 {
2740         struct regulator_dev *rdev = container_of(work, struct regulator_dev,
2741                                                   disable_work.work);
2742         struct ww_acquire_ctx ww_ctx;
2743         int count, i, ret;
2744         struct regulator *regulator;
2745         int total_count = 0;
2746
2747         regulator_lock_dependent(rdev, &ww_ctx);
2748
2749         /*
2750          * Workqueue functions queue the new work instance while the previous
2751          * work instance is being processed. Cancel the queued work instance
2752          * as the work instance under processing does the job of the queued
2753          * work instance.
2754          */
2755         cancel_delayed_work(&rdev->disable_work);
2756
2757         list_for_each_entry(regulator, &rdev->consumer_list, list) {
2758                 count = regulator->deferred_disables;
2759
2760                 if (!count)
2761                         continue;
2762
2763                 total_count += count;
2764                 regulator->deferred_disables = 0;
2765
2766                 for (i = 0; i < count; i++) {
2767                         ret = _regulator_disable(regulator);
2768                         if (ret != 0)
2769                                 rdev_err(rdev, "Deferred disable failed: %d\n", ret);
2770                 }
2771         }
2772         WARN_ON(!total_count);
2773
2774         if (rdev->coupling_desc.n_coupled > 1)
2775                 regulator_balance_voltage(rdev, PM_SUSPEND_ON);
2776
2777         regulator_unlock_dependent(rdev, &ww_ctx);
2778 }
2779
2780 /**
2781  * regulator_disable_deferred - disable regulator output with delay
2782  * @regulator: regulator source
2783  * @ms: milliseconds until the regulator is disabled
2784  *
2785  * Execute regulator_disable() on the regulator after a delay.  This
2786  * is intended for use with devices that require some time to quiesce.
2787  *
2788  * NOTE: this will only disable the regulator output if no other consumer
2789  * devices have it enabled, the regulator device supports disabling and
2790  * machine constraints permit this operation.
2791  */
2792 int regulator_disable_deferred(struct regulator *regulator, int ms)
2793 {
2794         struct regulator_dev *rdev = regulator->rdev;
2795
2796         if (!ms)
2797                 return regulator_disable(regulator);
2798
2799         regulator_lock(rdev);
2800         regulator->deferred_disables++;
2801         mod_delayed_work(system_power_efficient_wq, &rdev->disable_work,
2802                          msecs_to_jiffies(ms));
2803         regulator_unlock(rdev);
2804
2805         return 0;
2806 }
2807 EXPORT_SYMBOL_GPL(regulator_disable_deferred);
2808
2809 static int _regulator_is_enabled(struct regulator_dev *rdev)
2810 {
2811         /* A GPIO control always takes precedence */
2812         if (rdev->ena_pin)
2813                 return rdev->ena_gpio_state;
2814
2815         /* If we don't know then assume that the regulator is always on */
2816         if (!rdev->desc->ops->is_enabled)
2817                 return 1;
2818
2819         return rdev->desc->ops->is_enabled(rdev);
2820 }
2821
2822 static int _regulator_list_voltage(struct regulator_dev *rdev,
2823                                    unsigned selector, int lock)
2824 {
2825         const struct regulator_ops *ops = rdev->desc->ops;
2826         int ret;
2827
2828         if (rdev->desc->fixed_uV && rdev->desc->n_voltages == 1 && !selector)
2829                 return rdev->desc->fixed_uV;
2830
2831         if (ops->list_voltage) {
2832                 if (selector >= rdev->desc->n_voltages)
2833                         return -EINVAL;
2834                 if (lock)
2835                         regulator_lock(rdev);
2836                 ret = ops->list_voltage(rdev, selector);
2837                 if (lock)
2838                         regulator_unlock(rdev);
2839         } else if (rdev->is_switch && rdev->supply) {
2840                 ret = _regulator_list_voltage(rdev->supply->rdev,
2841                                               selector, lock);
2842         } else {
2843                 return -EINVAL;
2844         }
2845
2846         if (ret > 0) {
2847                 if (ret < rdev->constraints->min_uV)
2848                         ret = 0;
2849                 else if (ret > rdev->constraints->max_uV)
2850                         ret = 0;
2851         }
2852
2853         return ret;
2854 }
2855
2856 /**
2857  * regulator_is_enabled - is the regulator output enabled
2858  * @regulator: regulator source
2859  *
2860  * Returns positive if the regulator driver backing the source/client
2861  * has requested that the device be enabled, zero if it hasn't, else a
2862  * negative errno code.
2863  *
2864  * Note that the device backing this regulator handle can have multiple
2865  * users, so it might be enabled even if regulator_enable() was never
2866  * called for this particular source.
2867  */
2868 int regulator_is_enabled(struct regulator *regulator)
2869 {
2870         int ret;
2871
2872         if (regulator->always_on)
2873                 return 1;
2874
2875         regulator_lock(regulator->rdev);
2876         ret = _regulator_is_enabled(regulator->rdev);
2877         regulator_unlock(regulator->rdev);
2878
2879         return ret;
2880 }
2881 EXPORT_SYMBOL_GPL(regulator_is_enabled);
2882
2883 /**
2884  * regulator_count_voltages - count regulator_list_voltage() selectors
2885  * @regulator: regulator source
2886  *
2887  * Returns number of selectors, or negative errno.  Selectors are
2888  * numbered starting at zero, and typically correspond to bitfields
2889  * in hardware registers.
2890  */
2891 int regulator_count_voltages(struct regulator *regulator)
2892 {
2893         struct regulator_dev    *rdev = regulator->rdev;
2894
2895         if (rdev->desc->n_voltages)
2896                 return rdev->desc->n_voltages;
2897
2898         if (!rdev->is_switch || !rdev->supply)
2899                 return -EINVAL;
2900
2901         return regulator_count_voltages(rdev->supply);
2902 }
2903 EXPORT_SYMBOL_GPL(regulator_count_voltages);
2904
2905 /**
2906  * regulator_list_voltage - enumerate supported voltages
2907  * @regulator: regulator source
2908  * @selector: identify voltage to list
2909  * Context: can sleep
2910  *
2911  * Returns a voltage that can be passed to @regulator_set_voltage(),
2912  * zero if this selector code can't be used on this system, or a
2913  * negative errno.
2914  */
2915 int regulator_list_voltage(struct regulator *regulator, unsigned selector)
2916 {
2917         return _regulator_list_voltage(regulator->rdev, selector, 1);
2918 }
2919 EXPORT_SYMBOL_GPL(regulator_list_voltage);
2920
2921 /**
2922  * regulator_get_regmap - get the regulator's register map
2923  * @regulator: regulator source
2924  *
2925  * Returns the register map for the given regulator, or an ERR_PTR value
2926  * if the regulator doesn't use regmap.
2927  */
2928 struct regmap *regulator_get_regmap(struct regulator *regulator)
2929 {
2930         struct regmap *map = regulator->rdev->regmap;
2931
2932         return map ? map : ERR_PTR(-EOPNOTSUPP);
2933 }
2934
2935 /**
2936  * regulator_get_hardware_vsel_register - get the HW voltage selector register
2937  * @regulator: regulator source
2938  * @vsel_reg: voltage selector register, output parameter
2939  * @vsel_mask: mask for voltage selector bitfield, output parameter
2940  *
2941  * Returns the hardware register offset and bitmask used for setting the
2942  * regulator voltage. This might be useful when configuring voltage-scaling
2943  * hardware or firmware that can make I2C requests behind the kernel's back,
2944  * for example.
2945  *
2946  * On success, the output parameters @vsel_reg and @vsel_mask are filled in
2947  * and 0 is returned, otherwise a negative errno is returned.
2948  */
2949 int regulator_get_hardware_vsel_register(struct regulator *regulator,
2950                                          unsigned *vsel_reg,
2951                                          unsigned *vsel_mask)
2952 {
2953         struct regulator_dev *rdev = regulator->rdev;
2954         const struct regulator_ops *ops = rdev->desc->ops;
2955
2956         if (ops->set_voltage_sel != regulator_set_voltage_sel_regmap)
2957                 return -EOPNOTSUPP;
2958
2959         *vsel_reg = rdev->desc->vsel_reg;
2960         *vsel_mask = rdev->desc->vsel_mask;
2961
2962          return 0;
2963 }
2964 EXPORT_SYMBOL_GPL(regulator_get_hardware_vsel_register);
2965
2966 /**
2967  * regulator_list_hardware_vsel - get the HW-specific register value for a selector
2968  * @regulator: regulator source
2969  * @selector: identify voltage to list
2970  *
2971  * Converts the selector to a hardware-specific voltage selector that can be
2972  * directly written to the regulator registers. The address of the voltage
2973  * register can be determined by calling @regulator_get_hardware_vsel_register.
2974  *
2975  * On error a negative errno is returned.
2976  */
2977 int regulator_list_hardware_vsel(struct regulator *regulator,
2978                                  unsigned selector)
2979 {
2980         struct regulator_dev *rdev = regulator->rdev;
2981         const struct regulator_ops *ops = rdev->desc->ops;
2982
2983         if (selector >= rdev->desc->n_voltages)
2984                 return -EINVAL;
2985         if (ops->set_voltage_sel != regulator_set_voltage_sel_regmap)
2986                 return -EOPNOTSUPP;
2987
2988         return selector;
2989 }
2990 EXPORT_SYMBOL_GPL(regulator_list_hardware_vsel);
2991
2992 /**
2993  * regulator_get_linear_step - return the voltage step size between VSEL values
2994  * @regulator: regulator source
2995  *
2996  * Returns the voltage step size between VSEL values for linear
2997  * regulators, or return 0 if the regulator isn't a linear regulator.
2998  */
2999 unsigned int regulator_get_linear_step(struct regulator *regulator)
3000 {
3001         struct regulator_dev *rdev = regulator->rdev;
3002
3003         return rdev->desc->uV_step;
3004 }
3005 EXPORT_SYMBOL_GPL(regulator_get_linear_step);
3006
3007 /**
3008  * regulator_is_supported_voltage - check if a voltage range can be supported
3009  *
3010  * @regulator: Regulator to check.
3011  * @min_uV: Minimum required voltage in uV.
3012  * @max_uV: Maximum required voltage in uV.
3013  *
3014  * Returns a boolean.
3015  */
3016 int regulator_is_supported_voltage(struct regulator *regulator,
3017                                    int min_uV, int max_uV)
3018 {
3019         struct regulator_dev *rdev = regulator->rdev;
3020         int i, voltages, ret;
3021
3022         /* If we can't change voltage check the current voltage */
3023         if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_VOLTAGE)) {
3024                 ret = regulator_get_voltage(regulator);
3025                 if (ret >= 0)
3026                         return min_uV <= ret && ret <= max_uV;
3027                 else
3028                         return ret;
3029         }
3030
3031         /* Any voltage within constrains range is fine? */
3032         if (rdev->desc->continuous_voltage_range)
3033                 return min_uV >= rdev->constraints->min_uV &&
3034                                 max_uV <= rdev->constraints->max_uV;
3035
3036         ret = regulator_count_voltages(regulator);
3037         if (ret < 0)
3038                 return 0;
3039         voltages = ret;
3040
3041         for (i = 0; i < voltages; i++) {
3042                 ret = regulator_list_voltage(regulator, i);
3043
3044                 if (ret >= min_uV && ret <= max_uV)
3045                         return 1;
3046         }
3047
3048         return 0;
3049 }
3050 EXPORT_SYMBOL_GPL(regulator_is_supported_voltage);
3051
3052 static int regulator_map_voltage(struct regulator_dev *rdev, int min_uV,
3053                                  int max_uV)
3054 {
3055         const struct regulator_desc *desc = rdev->desc;
3056
3057         if (desc->ops->map_voltage)
3058                 return desc->ops->map_voltage(rdev, min_uV, max_uV);
3059
3060         if (desc->ops->list_voltage == regulator_list_voltage_linear)
3061                 return regulator_map_voltage_linear(rdev, min_uV, max_uV);
3062
3063         if (desc->ops->list_voltage == regulator_list_voltage_linear_range)
3064                 return regulator_map_voltage_linear_range(rdev, min_uV, max_uV);
3065
3066         if (desc->ops->list_voltage ==
3067                 regulator_list_voltage_pickable_linear_range)
3068                 return regulator_map_voltage_pickable_linear_range(rdev,
3069                                                         min_uV, max_uV);
3070
3071         return regulator_map_voltage_iterate(rdev, min_uV, max_uV);
3072 }
3073
3074 static int _regulator_call_set_voltage(struct regulator_dev *rdev,
3075                                        int min_uV, int max_uV,
3076                                        unsigned *selector)
3077 {
3078         struct pre_voltage_change_data data;
3079         int ret;
3080
3081         data.old_uV = regulator_get_voltage_rdev(rdev);
3082         data.min_uV = min_uV;
3083         data.max_uV = max_uV;
3084         ret = _notifier_call_chain(rdev, REGULATOR_EVENT_PRE_VOLTAGE_CHANGE,
3085                                    &data);
3086         if (ret & NOTIFY_STOP_MASK)
3087                 return -EINVAL;
3088
3089         ret = rdev->desc->ops->set_voltage(rdev, min_uV, max_uV, selector);
3090         if (ret >= 0)
3091                 return ret;
3092
3093         _notifier_call_chain(rdev, REGULATOR_EVENT_ABORT_VOLTAGE_CHANGE,
3094                              (void *)data.old_uV);
3095
3096         return ret;
3097 }
3098
3099 static int _regulator_call_set_voltage_sel(struct regulator_dev *rdev,
3100                                            int uV, unsigned selector)
3101 {
3102         struct pre_voltage_change_data data;
3103         int ret;
3104
3105         data.old_uV = regulator_get_voltage_rdev(rdev);
3106         data.min_uV = uV;
3107         data.max_uV = uV;
3108         ret = _notifier_call_chain(rdev, REGULATOR_EVENT_PRE_VOLTAGE_CHANGE,
3109                                    &data);
3110         if (ret & NOTIFY_STOP_MASK)
3111                 return -EINVAL;
3112
3113         ret = rdev->desc->ops->set_voltage_sel(rdev, selector);
3114         if (ret >= 0)
3115                 return ret;
3116
3117         _notifier_call_chain(rdev, REGULATOR_EVENT_ABORT_VOLTAGE_CHANGE,
3118                              (void *)data.old_uV);
3119
3120         return ret;
3121 }
3122
3123 static int _regulator_set_voltage_sel_step(struct regulator_dev *rdev,
3124                                            int uV, int new_selector)
3125 {
3126         const struct regulator_ops *ops = rdev->desc->ops;
3127         int diff, old_sel, curr_sel, ret;
3128
3129         /* Stepping is only needed if the regulator is enabled. */
3130         if (!_regulator_is_enabled(rdev))
3131                 goto final_set;
3132
3133         if (!ops->get_voltage_sel)
3134                 return -EINVAL;
3135
3136         old_sel = ops->get_voltage_sel(rdev);
3137         if (old_sel < 0)
3138                 return old_sel;
3139
3140         diff = new_selector - old_sel;
3141         if (diff == 0)
3142                 return 0; /* No change needed. */
3143
3144         if (diff > 0) {
3145                 /* Stepping up. */
3146                 for (curr_sel = old_sel + rdev->desc->vsel_step;
3147                      curr_sel < new_selector;
3148                      curr_sel += rdev->desc->vsel_step) {
3149                         /*
3150                          * Call the callback directly instead of using
3151                          * _regulator_call_set_voltage_sel() as we don't
3152                          * want to notify anyone yet. Same in the branch
3153                          * below.
3154                          */
3155                         ret = ops->set_voltage_sel(rdev, curr_sel);
3156                         if (ret)
3157                                 goto try_revert;
3158                 }
3159         } else {
3160                 /* Stepping down. */
3161                 for (curr_sel = old_sel - rdev->desc->vsel_step;
3162                      curr_sel > new_selector;
3163                      curr_sel -= rdev->desc->vsel_step) {
3164                         ret = ops->set_voltage_sel(rdev, curr_sel);
3165                         if (ret)
3166                                 goto try_revert;
3167                 }
3168         }
3169
3170 final_set:
3171         /* The final selector will trigger the notifiers. */
3172         return _regulator_call_set_voltage_sel(rdev, uV, new_selector);
3173
3174 try_revert:
3175         /*
3176          * At least try to return to the previous voltage if setting a new
3177          * one failed.
3178          */
3179         (void)ops->set_voltage_sel(rdev, old_sel);
3180         return ret;
3181 }
3182
3183 static int _regulator_set_voltage_time(struct regulator_dev *rdev,
3184                                        int old_uV, int new_uV)
3185 {
3186         unsigned int ramp_delay = 0;
3187
3188         if (rdev->constraints->ramp_delay)
3189                 ramp_delay = rdev->constraints->ramp_delay;
3190         else if (rdev->desc->ramp_delay)
3191                 ramp_delay = rdev->desc->ramp_delay;
3192         else if (rdev->constraints->settling_time)
3193                 return rdev->constraints->settling_time;
3194         else if (rdev->constraints->settling_time_up &&
3195                  (new_uV > old_uV))
3196                 return rdev->constraints->settling_time_up;
3197         else if (rdev->constraints->settling_time_down &&
3198                  (new_uV < old_uV))
3199                 return rdev->constraints->settling_time_down;
3200
3201         if (ramp_delay == 0) {
3202                 rdev_dbg(rdev, "ramp_delay not set\n");
3203                 return 0;
3204         }
3205
3206         return DIV_ROUND_UP(abs(new_uV - old_uV), ramp_delay);
3207 }
3208
3209 static int _regulator_do_set_voltage(struct regulator_dev *rdev,
3210                                      int min_uV, int max_uV)
3211 {
3212         int ret;
3213         int delay = 0;
3214         int best_val = 0;
3215         unsigned int selector;
3216         int old_selector = -1;
3217         const struct regulator_ops *ops = rdev->desc->ops;
3218         int old_uV = regulator_get_voltage_rdev(rdev);
3219
3220         trace_regulator_set_voltage(rdev_get_name(rdev), min_uV, max_uV);
3221
3222         min_uV += rdev->constraints->uV_offset;
3223         max_uV += rdev->constraints->uV_offset;
3224
3225         /*
3226          * If we can't obtain the old selector there is not enough
3227          * info to call set_voltage_time_sel().
3228          */
3229         if (_regulator_is_enabled(rdev) &&
3230             ops->set_voltage_time_sel && ops->get_voltage_sel) {
3231                 old_selector = ops->get_voltage_sel(rdev);
3232                 if (old_selector < 0)
3233                         return old_selector;
3234         }
3235
3236         if (ops->set_voltage) {
3237                 ret = _regulator_call_set_voltage(rdev, min_uV, max_uV,
3238                                                   &selector);
3239
3240                 if (ret >= 0) {
3241                         if (ops->list_voltage)
3242                                 best_val = ops->list_voltage(rdev,
3243                                                              selector);
3244                         else
3245                                 best_val = regulator_get_voltage_rdev(rdev);
3246                 }
3247
3248         } else if (ops->set_voltage_sel) {
3249                 ret = regulator_map_voltage(rdev, min_uV, max_uV);
3250                 if (ret >= 0) {
3251                         best_val = ops->list_voltage(rdev, ret);
3252                         if (min_uV <= best_val && max_uV >= best_val) {
3253                                 selector = ret;
3254                                 if (old_selector == selector)
3255                                         ret = 0;
3256                                 else if (rdev->desc->vsel_step)
3257                                         ret = _regulator_set_voltage_sel_step(
3258                                                 rdev, best_val, selector);
3259                                 else
3260                                         ret = _regulator_call_set_voltage_sel(
3261                                                 rdev, best_val, selector);
3262                         } else {
3263                                 ret = -EINVAL;
3264                         }
3265                 }
3266         } else {
3267                 ret = -EINVAL;
3268         }
3269
3270         if (ret)
3271                 goto out;
3272
3273         if (ops->set_voltage_time_sel) {
3274                 /*
3275                  * Call set_voltage_time_sel if successfully obtained
3276                  * old_selector
3277                  */
3278                 if (old_selector >= 0 && old_selector != selector)
3279                         delay = ops->set_voltage_time_sel(rdev, old_selector,
3280                                                           selector);
3281         } else {
3282                 if (old_uV != best_val) {
3283                         if (ops->set_voltage_time)
3284                                 delay = ops->set_voltage_time(rdev, old_uV,
3285                                                               best_val);
3286                         else
3287                                 delay = _regulator_set_voltage_time(rdev,
3288                                                                     old_uV,
3289                                                                     best_val);
3290                 }
3291         }
3292
3293         if (delay < 0) {
3294                 rdev_warn(rdev, "failed to get delay: %d\n", delay);
3295                 delay = 0;
3296         }
3297
3298         /* Insert any necessary delays */
3299         if (delay >= 1000) {
3300                 mdelay(delay / 1000);
3301                 udelay(delay % 1000);
3302         } else if (delay) {
3303                 udelay(delay);
3304         }
3305
3306         if (best_val >= 0) {
3307                 unsigned long data = best_val;
3308
3309                 _notifier_call_chain(rdev, REGULATOR_EVENT_VOLTAGE_CHANGE,
3310                                      (void *)data);
3311         }
3312
3313 out:
3314         trace_regulator_set_voltage_complete(rdev_get_name(rdev), best_val);
3315
3316         return ret;
3317 }
3318
3319 static int _regulator_do_set_suspend_voltage(struct regulator_dev *rdev,
3320                                   int min_uV, int max_uV, suspend_state_t state)
3321 {
3322         struct regulator_state *rstate;
3323         int uV, sel;
3324
3325         rstate = regulator_get_suspend_state(rdev, state);
3326         if (rstate == NULL)
3327                 return -EINVAL;
3328
3329         if (min_uV < rstate->min_uV)
3330                 min_uV = rstate->min_uV;
3331         if (max_uV > rstate->max_uV)
3332                 max_uV = rstate->max_uV;
3333
3334         sel = regulator_map_voltage(rdev, min_uV, max_uV);
3335         if (sel < 0)
3336                 return sel;
3337
3338         uV = rdev->desc->ops->list_voltage(rdev, sel);
3339         if (uV >= min_uV && uV <= max_uV)
3340                 rstate->uV = uV;
3341
3342         return 0;
3343 }
3344
3345 static int regulator_set_voltage_unlocked(struct regulator *regulator,
3346                                           int min_uV, int max_uV,
3347                                           suspend_state_t state)
3348 {
3349         struct regulator_dev *rdev = regulator->rdev;
3350         struct regulator_voltage *voltage = &regulator->voltage[state];
3351         int ret = 0;
3352         int old_min_uV, old_max_uV;
3353         int current_uV;
3354
3355         /* If we're setting the same range as last time the change
3356          * should be a noop (some cpufreq implementations use the same
3357          * voltage for multiple frequencies, for example).
3358          */
3359         if (voltage->min_uV == min_uV && voltage->max_uV == max_uV)
3360                 goto out;
3361
3362         /* If we're trying to set a range that overlaps the current voltage,
3363          * return successfully even though the regulator does not support
3364          * changing the voltage.
3365          */
3366         if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_VOLTAGE)) {
3367                 current_uV = regulator_get_voltage_rdev(rdev);
3368                 if (min_uV <= current_uV && current_uV <= max_uV) {
3369                         voltage->min_uV = min_uV;
3370                         voltage->max_uV = max_uV;
3371                         goto out;
3372                 }
3373         }
3374
3375         /* sanity check */
3376         if (!rdev->desc->ops->set_voltage &&
3377             !rdev->desc->ops->set_voltage_sel) {
3378                 ret = -EINVAL;
3379                 goto out;
3380         }
3381
3382         /* constraints check */
3383         ret = regulator_check_voltage(rdev, &min_uV, &max_uV);
3384         if (ret < 0)
3385                 goto out;
3386
3387         /* restore original values in case of error */
3388         old_min_uV = voltage->min_uV;
3389         old_max_uV = voltage->max_uV;
3390         voltage->min_uV = min_uV;
3391         voltage->max_uV = max_uV;
3392
3393         /* for not coupled regulators this will just set the voltage */
3394         ret = regulator_balance_vo