Branch data Line data Source code
1 : : /*
2 : : * core.c -- Voltage/Current Regulator framework.
3 : : *
4 : : * Copyright 2007, 2008 Wolfson Microelectronics PLC.
5 : : * Copyright 2008 SlimLogic Ltd.
6 : : *
7 : : * Author: Liam Girdwood <lrg@slimlogic.co.uk>
8 : : *
9 : : * This program is free software; you can redistribute it and/or modify it
10 : : * under the terms of the GNU General Public License as published by the
11 : : * Free Software Foundation; either version 2 of the License, or (at your
12 : : * option) any later version.
13 : : *
14 : : */
15 : :
16 : : #include <linux/kernel.h>
17 : : #include <linux/init.h>
18 : : #include <linux/debugfs.h>
19 : : #include <linux/device.h>
20 : : #include <linux/slab.h>
21 : : #include <linux/async.h>
22 : : #include <linux/err.h>
23 : : #include <linux/mutex.h>
24 : : #include <linux/suspend.h>
25 : : #include <linux/delay.h>
26 : : #include <linux/gpio.h>
27 : : #include <linux/of.h>
28 : : #include <linux/regmap.h>
29 : : #include <linux/regulator/of_regulator.h>
30 : : #include <linux/regulator/consumer.h>
31 : : #include <linux/regulator/driver.h>
32 : : #include <linux/regulator/machine.h>
33 : : #include <linux/module.h>
34 : :
35 : : #define CREATE_TRACE_POINTS
36 : : #include <trace/events/regulator.h>
37 : :
38 : : #include "dummy.h"
39 : : #include "internal.h"
40 : :
41 : : #define rdev_crit(rdev, fmt, ...) \
42 : : pr_crit("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
43 : : #define rdev_err(rdev, fmt, ...) \
44 : : pr_err("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
45 : : #define rdev_warn(rdev, fmt, ...) \
46 : : pr_warn("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
47 : : #define rdev_info(rdev, fmt, ...) \
48 : : pr_info("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
49 : : #define rdev_dbg(rdev, fmt, ...) \
50 : : pr_debug("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
51 : :
52 : : static DEFINE_MUTEX(regulator_list_mutex);
53 : : static LIST_HEAD(regulator_list);
54 : : static LIST_HEAD(regulator_map_list);
55 : : static LIST_HEAD(regulator_ena_gpio_list);
56 : : static LIST_HEAD(regulator_supply_alias_list);
57 : : static bool has_full_constraints;
58 : :
59 : : static struct dentry *debugfs_root;
60 : :
61 : : /*
62 : : * struct regulator_map
63 : : *
64 : : * Used to provide symbolic supply names to devices.
65 : : */
66 : : struct regulator_map {
67 : : struct list_head list;
68 : : const char *dev_name; /* The dev_name() for the consumer */
69 : : const char *supply;
70 : : struct regulator_dev *regulator;
71 : : };
72 : :
73 : : /*
74 : : * struct regulator_enable_gpio
75 : : *
76 : : * Management for shared enable GPIO pin
77 : : */
78 : : struct regulator_enable_gpio {
79 : : struct list_head list;
80 : : int gpio;
81 : : u32 enable_count; /* a number of enabled shared GPIO */
82 : : u32 request_count; /* a number of requested shared GPIO */
83 : : unsigned int ena_gpio_invert:1;
84 : : };
85 : :
86 : : /*
87 : : * struct regulator_supply_alias
88 : : *
89 : : * Used to map lookups for a supply onto an alternative device.
90 : : */
91 : : struct regulator_supply_alias {
92 : : struct list_head list;
93 : : struct device *src_dev;
94 : : const char *src_supply;
95 : : struct device *alias_dev;
96 : : const char *alias_supply;
97 : : };
98 : :
99 : : static int _regulator_is_enabled(struct regulator_dev *rdev);
100 : : static int _regulator_disable(struct regulator_dev *rdev);
101 : : static int _regulator_get_voltage(struct regulator_dev *rdev);
102 : : static int _regulator_get_current_limit(struct regulator_dev *rdev);
103 : : static unsigned int _regulator_get_mode(struct regulator_dev *rdev);
104 : : static void _notifier_call_chain(struct regulator_dev *rdev,
105 : : unsigned long event, void *data);
106 : : static int _regulator_do_set_voltage(struct regulator_dev *rdev,
107 : : int min_uV, int max_uV);
108 : : static struct regulator *create_regulator(struct regulator_dev *rdev,
109 : : struct device *dev,
110 : : const char *supply_name);
111 : :
112 : : static const char *rdev_get_name(struct regulator_dev *rdev)
113 : : {
114 [ # # ][ # # ]: 0 : if (rdev->constraints && rdev->constraints->name)
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
[ # # # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
115 : : return rdev->constraints->name;
116 [ # # ][ # # ]: 0 : else if (rdev->desc->name)
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
117 : : return rdev->desc->name;
118 : : else
119 : : return "";
120 : : }
121 : :
122 : : static bool have_full_constraints(void)
123 : : {
124 [ # # ][ # # ]: 0 : return has_full_constraints || of_have_populated_dt();
[ # # ][ # # ]
[ # # ][ # # ]
125 : : }
126 : :
127 : : /**
128 : : * of_get_regulator - get a regulator device node based on supply name
129 : : * @dev: Device pointer for the consumer (of regulator) device
130 : : * @supply: regulator supply name
131 : : *
132 : : * Extract the regulator device node corresponding to the supply name.
133 : : * returns the device node corresponding to the regulator if found, else
134 : : * returns NULL.
135 : : */
136 : 0 : static struct device_node *of_get_regulator(struct device *dev, const char *supply)
137 : : {
138 : : struct device_node *regnode = NULL;
139 : : char prop_name[32]; /* 32 is max size of property name */
140 : :
141 : : dev_dbg(dev, "Looking up %s-supply from device tree\n", supply);
142 : :
143 : 0 : snprintf(prop_name, 32, "%s-supply", supply);
144 : 0 : regnode = of_parse_phandle(dev->of_node, prop_name, 0);
145 : :
146 [ # # ]: 0 : if (!regnode) {
147 : : dev_dbg(dev, "Looking up %s property in node %s failed",
148 : : prop_name, dev->of_node->full_name);
149 : : return NULL;
150 : : }
151 : : return regnode;
152 : : }
153 : :
154 : : static int _regulator_can_change_status(struct regulator_dev *rdev)
155 : : {
156 [ # # ][ # # ]: 0 : if (!rdev->constraints)
[ # # ]
157 : : return 0;
158 : :
159 [ # # ][ # # ]: 0 : if (rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_STATUS)
[ # # ]
160 : : return 1;
161 : : else
162 : : return 0;
163 : : }
164 : :
165 : : /* Platform voltage constraint check */
166 : 0 : static int regulator_check_voltage(struct regulator_dev *rdev,
167 : : int *min_uV, int *max_uV)
168 : : {
169 [ # # ]: 0 : BUG_ON(*min_uV > *max_uV);
170 : :
171 [ # # ]: 0 : if (!rdev->constraints) {
172 : 0 : rdev_err(rdev, "no constraints\n");
173 : 0 : return -ENODEV;
174 : : }
175 [ # # ]: 0 : if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) {
176 : 0 : rdev_err(rdev, "operation not allowed\n");
177 : 0 : return -EPERM;
178 : : }
179 : :
180 [ # # ]: 0 : if (*max_uV > rdev->constraints->max_uV)
181 : 0 : *max_uV = rdev->constraints->max_uV;
182 [ # # ]: 0 : if (*min_uV < rdev->constraints->min_uV)
183 : 0 : *min_uV = rdev->constraints->min_uV;
184 : :
185 [ # # ]: 0 : if (*min_uV > *max_uV) {
186 : 0 : rdev_err(rdev, "unsupportable voltage range: %d-%duV\n",
187 : : *min_uV, *max_uV);
188 : 0 : return -EINVAL;
189 : : }
190 : :
191 : : return 0;
192 : : }
193 : :
194 : : /* Make sure we select a voltage that suits the needs of all
195 : : * regulator consumers
196 : : */
197 : 0 : static int regulator_check_consumers(struct regulator_dev *rdev,
198 : : int *min_uV, int *max_uV)
199 : : {
200 : : struct regulator *regulator;
201 : :
202 [ # # ]: 0 : list_for_each_entry(regulator, &rdev->consumer_list, list) {
203 : : /*
204 : : * Assume consumers that didn't say anything are OK
205 : : * with anything in the constraint range.
206 : : */
207 [ # # ][ # # ]: 0 : if (!regulator->min_uV && !regulator->max_uV)
208 : 0 : continue;
209 : :
210 [ # # ]: 0 : if (*max_uV > regulator->max_uV)
211 : 0 : *max_uV = regulator->max_uV;
212 [ # # ]: 0 : if (*min_uV < regulator->min_uV)
213 : 0 : *min_uV = regulator->min_uV;
214 : : }
215 : :
216 [ # # ]: 0 : if (*min_uV > *max_uV) {
217 : 0 : rdev_err(rdev, "Restricting voltage, %u-%uuV\n",
218 : : *min_uV, *max_uV);
219 : 0 : return -EINVAL;
220 : : }
221 : :
222 : : return 0;
223 : : }
224 : :
225 : : /* current constraint check */
226 : 0 : static int regulator_check_current_limit(struct regulator_dev *rdev,
227 : : int *min_uA, int *max_uA)
228 : : {
229 [ # # ]: 0 : BUG_ON(*min_uA > *max_uA);
230 : :
231 [ # # ]: 0 : if (!rdev->constraints) {
232 : 0 : rdev_err(rdev, "no constraints\n");
233 : 0 : return -ENODEV;
234 : : }
235 [ # # ]: 0 : if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_CURRENT)) {
236 : 0 : rdev_err(rdev, "operation not allowed\n");
237 : 0 : return -EPERM;
238 : : }
239 : :
240 [ # # ]: 0 : if (*max_uA > rdev->constraints->max_uA)
241 : 0 : *max_uA = rdev->constraints->max_uA;
242 [ # # ]: 0 : if (*min_uA < rdev->constraints->min_uA)
243 : 0 : *min_uA = rdev->constraints->min_uA;
244 : :
245 [ # # ]: 0 : if (*min_uA > *max_uA) {
246 : 0 : rdev_err(rdev, "unsupportable current range: %d-%duA\n",
247 : : *min_uA, *max_uA);
248 : 0 : return -EINVAL;
249 : : }
250 : :
251 : : return 0;
252 : : }
253 : :
254 : : /* operating mode constraint check */
255 : 0 : static int regulator_mode_constrain(struct regulator_dev *rdev, int *mode)
256 : : {
257 [ # # ][ # # ]: 0 : switch (*mode) {
258 : : case REGULATOR_MODE_FAST:
259 : : case REGULATOR_MODE_NORMAL:
260 : : case REGULATOR_MODE_IDLE:
261 : : case REGULATOR_MODE_STANDBY:
262 : : break;
263 : : default:
264 : 0 : rdev_err(rdev, "invalid mode %x specified\n", *mode);
265 : 0 : return -EINVAL;
266 : : }
267 : :
268 [ # # ]: 0 : if (!rdev->constraints) {
269 : 0 : rdev_err(rdev, "no constraints\n");
270 : 0 : return -ENODEV;
271 : : }
272 [ # # ]: 0 : if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_MODE)) {
273 : 0 : rdev_err(rdev, "operation not allowed\n");
274 : 0 : return -EPERM;
275 : : }
276 : :
277 : : /* The modes are bitmasks, the most power hungry modes having
278 : : * the lowest values. If the requested mode isn't supported
279 : : * try higher modes. */
280 [ # # ]: 0 : while (*mode) {
281 [ # # ]: 0 : if (rdev->constraints->valid_modes_mask & *mode)
282 : : return 0;
283 : 0 : *mode /= 2;
284 : : }
285 : :
286 : : return -EINVAL;
287 : : }
288 : :
289 : : /* dynamic regulator mode switching constraint check */
290 : 0 : static int regulator_check_drms(struct regulator_dev *rdev)
291 : : {
292 [ # # ]: 0 : if (!rdev->constraints) {
293 : 0 : rdev_err(rdev, "no constraints\n");
294 : 0 : return -ENODEV;
295 : : }
296 [ # # ]: 0 : if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_DRMS)) {
297 : 0 : rdev_err(rdev, "operation not allowed\n");
298 : 0 : return -EPERM;
299 : : }
300 : : return 0;
301 : : }
302 : :
303 : 0 : static ssize_t regulator_uV_show(struct device *dev,
304 : : struct device_attribute *attr, char *buf)
305 : : {
306 : 0 : struct regulator_dev *rdev = dev_get_drvdata(dev);
307 : : ssize_t ret;
308 : :
309 : 0 : mutex_lock(&rdev->mutex);
310 : 0 : ret = sprintf(buf, "%d\n", _regulator_get_voltage(rdev));
311 : 0 : mutex_unlock(&rdev->mutex);
312 : :
313 : 0 : return ret;
314 : : }
315 : : static DEVICE_ATTR(microvolts, 0444, regulator_uV_show, NULL);
316 : :
317 : 0 : static ssize_t regulator_uA_show(struct device *dev,
318 : : struct device_attribute *attr, char *buf)
319 : : {
320 : 0 : struct regulator_dev *rdev = dev_get_drvdata(dev);
321 : :
322 : 0 : return sprintf(buf, "%d\n", _regulator_get_current_limit(rdev));
323 : : }
324 : : static DEVICE_ATTR(microamps, 0444, regulator_uA_show, NULL);
325 : :
326 : 0 : static ssize_t name_show(struct device *dev, struct device_attribute *attr,
327 : : char *buf)
328 : : {
329 : 0 : struct regulator_dev *rdev = dev_get_drvdata(dev);
330 : :
331 : 0 : return sprintf(buf, "%s\n", rdev_get_name(rdev));
332 : : }
333 : : static DEVICE_ATTR_RO(name);
334 : :
335 : 0 : static ssize_t regulator_print_opmode(char *buf, int mode)
336 : : {
337 [ # # # # : 0 : switch (mode) {
# ]
338 : : case REGULATOR_MODE_FAST:
339 : 0 : return sprintf(buf, "fast\n");
340 : : case REGULATOR_MODE_NORMAL:
341 : 0 : return sprintf(buf, "normal\n");
342 : : case REGULATOR_MODE_IDLE:
343 : 0 : return sprintf(buf, "idle\n");
344 : : case REGULATOR_MODE_STANDBY:
345 : 0 : return sprintf(buf, "standby\n");
346 : : }
347 : 0 : return sprintf(buf, "unknown\n");
348 : : }
349 : :
350 : 0 : static ssize_t regulator_opmode_show(struct device *dev,
351 : : struct device_attribute *attr, char *buf)
352 : : {
353 : 0 : struct regulator_dev *rdev = dev_get_drvdata(dev);
354 : :
355 : 0 : return regulator_print_opmode(buf, _regulator_get_mode(rdev));
356 : : }
357 : : static DEVICE_ATTR(opmode, 0444, regulator_opmode_show, NULL);
358 : :
359 : 0 : static ssize_t regulator_print_state(char *buf, int state)
360 : : {
361 [ # # ]: 0 : if (state > 0)
362 : 0 : return sprintf(buf, "enabled\n");
363 [ # # ]: 0 : else if (state == 0)
364 : 0 : return sprintf(buf, "disabled\n");
365 : : else
366 : 0 : return sprintf(buf, "unknown\n");
367 : : }
368 : :
369 : 0 : static ssize_t regulator_state_show(struct device *dev,
370 : : struct device_attribute *attr, char *buf)
371 : : {
372 : 0 : struct regulator_dev *rdev = dev_get_drvdata(dev);
373 : : ssize_t ret;
374 : :
375 : 0 : mutex_lock(&rdev->mutex);
376 : 0 : ret = regulator_print_state(buf, _regulator_is_enabled(rdev));
377 : 0 : mutex_unlock(&rdev->mutex);
378 : :
379 : 0 : return ret;
380 : : }
381 : : static DEVICE_ATTR(state, 0444, regulator_state_show, NULL);
382 : :
383 : 0 : static ssize_t regulator_status_show(struct device *dev,
384 : : struct device_attribute *attr, char *buf)
385 : : {
386 : 0 : struct regulator_dev *rdev = dev_get_drvdata(dev);
387 : : int status;
388 : : char *label;
389 : :
390 : 0 : status = rdev->desc->ops->get_status(rdev);
391 [ # # ]: 0 : if (status < 0)
392 : : return status;
393 : :
394 [ # # # # : 0 : switch (status) {
# # # # #
# ]
395 : : case REGULATOR_STATUS_OFF:
396 : : label = "off";
397 : : break;
398 : : case REGULATOR_STATUS_ON:
399 : : label = "on";
400 : 0 : break;
401 : : case REGULATOR_STATUS_ERROR:
402 : : label = "error";
403 : 0 : break;
404 : : case REGULATOR_STATUS_FAST:
405 : : label = "fast";
406 : 0 : break;
407 : : case REGULATOR_STATUS_NORMAL:
408 : : label = "normal";
409 : 0 : break;
410 : : case REGULATOR_STATUS_IDLE:
411 : : label = "idle";
412 : 0 : break;
413 : : case REGULATOR_STATUS_STANDBY:
414 : : label = "standby";
415 : 0 : break;
416 : : case REGULATOR_STATUS_BYPASS:
417 : : label = "bypass";
418 : 0 : break;
419 : : case REGULATOR_STATUS_UNDEFINED:
420 : : label = "undefined";
421 : 0 : break;
422 : : default:
423 : : return -ERANGE;
424 : : }
425 : :
426 : 0 : return sprintf(buf, "%s\n", label);
427 : : }
428 : : static DEVICE_ATTR(status, 0444, regulator_status_show, NULL);
429 : :
430 : 0 : static ssize_t regulator_min_uA_show(struct device *dev,
431 : : struct device_attribute *attr, char *buf)
432 : : {
433 : 0 : struct regulator_dev *rdev = dev_get_drvdata(dev);
434 : :
435 [ # # ]: 0 : if (!rdev->constraints)
436 : 0 : return sprintf(buf, "constraint not defined\n");
437 : :
438 : 0 : return sprintf(buf, "%d\n", rdev->constraints->min_uA);
439 : : }
440 : : static DEVICE_ATTR(min_microamps, 0444, regulator_min_uA_show, NULL);
441 : :
442 : 0 : static ssize_t regulator_max_uA_show(struct device *dev,
443 : : struct device_attribute *attr, char *buf)
444 : : {
445 : 0 : struct regulator_dev *rdev = dev_get_drvdata(dev);
446 : :
447 [ # # ]: 0 : if (!rdev->constraints)
448 : 0 : return sprintf(buf, "constraint not defined\n");
449 : :
450 : 0 : return sprintf(buf, "%d\n", rdev->constraints->max_uA);
451 : : }
452 : : static DEVICE_ATTR(max_microamps, 0444, regulator_max_uA_show, NULL);
453 : :
454 : 0 : static ssize_t regulator_min_uV_show(struct device *dev,
455 : : struct device_attribute *attr, char *buf)
456 : : {
457 : 0 : struct regulator_dev *rdev = dev_get_drvdata(dev);
458 : :
459 [ # # ]: 0 : if (!rdev->constraints)
460 : 0 : return sprintf(buf, "constraint not defined\n");
461 : :
462 : 0 : return sprintf(buf, "%d\n", rdev->constraints->min_uV);
463 : : }
464 : : static DEVICE_ATTR(min_microvolts, 0444, regulator_min_uV_show, NULL);
465 : :
466 : 0 : static ssize_t regulator_max_uV_show(struct device *dev,
467 : : struct device_attribute *attr, char *buf)
468 : : {
469 : 0 : struct regulator_dev *rdev = dev_get_drvdata(dev);
470 : :
471 [ # # ]: 0 : if (!rdev->constraints)
472 : 0 : return sprintf(buf, "constraint not defined\n");
473 : :
474 : 0 : return sprintf(buf, "%d\n", rdev->constraints->max_uV);
475 : : }
476 : : static DEVICE_ATTR(max_microvolts, 0444, regulator_max_uV_show, NULL);
477 : :
478 : 0 : static ssize_t regulator_total_uA_show(struct device *dev,
479 : : struct device_attribute *attr, char *buf)
480 : : {
481 : 0 : struct regulator_dev *rdev = dev_get_drvdata(dev);
482 : : struct regulator *regulator;
483 : : int uA = 0;
484 : :
485 : 0 : mutex_lock(&rdev->mutex);
486 [ # # ]: 0 : list_for_each_entry(regulator, &rdev->consumer_list, list)
487 : 0 : uA += regulator->uA_load;
488 : 0 : mutex_unlock(&rdev->mutex);
489 : 0 : return sprintf(buf, "%d\n", uA);
490 : : }
491 : : static DEVICE_ATTR(requested_microamps, 0444, regulator_total_uA_show, NULL);
492 : :
493 : 0 : static ssize_t num_users_show(struct device *dev, struct device_attribute *attr,
494 : : char *buf)
495 : : {
496 : 0 : struct regulator_dev *rdev = dev_get_drvdata(dev);
497 : 0 : return sprintf(buf, "%d\n", rdev->use_count);
498 : : }
499 : : static DEVICE_ATTR_RO(num_users);
500 : :
501 : 0 : static ssize_t type_show(struct device *dev, struct device_attribute *attr,
502 : : char *buf)
503 : : {
504 : 0 : struct regulator_dev *rdev = dev_get_drvdata(dev);
505 : :
506 [ # # # ]: 0 : switch (rdev->desc->type) {
507 : : case REGULATOR_VOLTAGE:
508 : 0 : return sprintf(buf, "voltage\n");
509 : : case REGULATOR_CURRENT:
510 : 0 : return sprintf(buf, "current\n");
511 : : }
512 : 0 : return sprintf(buf, "unknown\n");
513 : : }
514 : : static DEVICE_ATTR_RO(type);
515 : :
516 : 0 : static ssize_t regulator_suspend_mem_uV_show(struct device *dev,
517 : : struct device_attribute *attr, char *buf)
518 : : {
519 : 0 : struct regulator_dev *rdev = dev_get_drvdata(dev);
520 : :
521 : 0 : return sprintf(buf, "%d\n", rdev->constraints->state_mem.uV);
522 : : }
523 : : static DEVICE_ATTR(suspend_mem_microvolts, 0444,
524 : : regulator_suspend_mem_uV_show, NULL);
525 : :
526 : 0 : static ssize_t regulator_suspend_disk_uV_show(struct device *dev,
527 : : struct device_attribute *attr, char *buf)
528 : : {
529 : 0 : struct regulator_dev *rdev = dev_get_drvdata(dev);
530 : :
531 : 0 : return sprintf(buf, "%d\n", rdev->constraints->state_disk.uV);
532 : : }
533 : : static DEVICE_ATTR(suspend_disk_microvolts, 0444,
534 : : regulator_suspend_disk_uV_show, NULL);
535 : :
536 : 0 : static ssize_t regulator_suspend_standby_uV_show(struct device *dev,
537 : : struct device_attribute *attr, char *buf)
538 : : {
539 : 0 : struct regulator_dev *rdev = dev_get_drvdata(dev);
540 : :
541 : 0 : return sprintf(buf, "%d\n", rdev->constraints->state_standby.uV);
542 : : }
543 : : static DEVICE_ATTR(suspend_standby_microvolts, 0444,
544 : : regulator_suspend_standby_uV_show, NULL);
545 : :
546 : 0 : static ssize_t regulator_suspend_mem_mode_show(struct device *dev,
547 : : struct device_attribute *attr, char *buf)
548 : : {
549 : 0 : struct regulator_dev *rdev = dev_get_drvdata(dev);
550 : :
551 : 0 : return regulator_print_opmode(buf,
552 : 0 : rdev->constraints->state_mem.mode);
553 : : }
554 : : static DEVICE_ATTR(suspend_mem_mode, 0444,
555 : : regulator_suspend_mem_mode_show, NULL);
556 : :
557 : 0 : static ssize_t regulator_suspend_disk_mode_show(struct device *dev,
558 : : struct device_attribute *attr, char *buf)
559 : : {
560 : 0 : struct regulator_dev *rdev = dev_get_drvdata(dev);
561 : :
562 : 0 : return regulator_print_opmode(buf,
563 : 0 : rdev->constraints->state_disk.mode);
564 : : }
565 : : static DEVICE_ATTR(suspend_disk_mode, 0444,
566 : : regulator_suspend_disk_mode_show, NULL);
567 : :
568 : 0 : static ssize_t regulator_suspend_standby_mode_show(struct device *dev,
569 : : struct device_attribute *attr, char *buf)
570 : : {
571 : 0 : struct regulator_dev *rdev = dev_get_drvdata(dev);
572 : :
573 : 0 : return regulator_print_opmode(buf,
574 : 0 : rdev->constraints->state_standby.mode);
575 : : }
576 : : static DEVICE_ATTR(suspend_standby_mode, 0444,
577 : : regulator_suspend_standby_mode_show, NULL);
578 : :
579 : 0 : static ssize_t regulator_suspend_mem_state_show(struct device *dev,
580 : : struct device_attribute *attr, char *buf)
581 : : {
582 : 0 : struct regulator_dev *rdev = dev_get_drvdata(dev);
583 : :
584 : 0 : return regulator_print_state(buf,
585 : 0 : rdev->constraints->state_mem.enabled);
586 : : }
587 : : static DEVICE_ATTR(suspend_mem_state, 0444,
588 : : regulator_suspend_mem_state_show, NULL);
589 : :
590 : 0 : static ssize_t regulator_suspend_disk_state_show(struct device *dev,
591 : : struct device_attribute *attr, char *buf)
592 : : {
593 : 0 : struct regulator_dev *rdev = dev_get_drvdata(dev);
594 : :
595 : 0 : return regulator_print_state(buf,
596 : 0 : rdev->constraints->state_disk.enabled);
597 : : }
598 : : static DEVICE_ATTR(suspend_disk_state, 0444,
599 : : regulator_suspend_disk_state_show, NULL);
600 : :
601 : 0 : static ssize_t regulator_suspend_standby_state_show(struct device *dev,
602 : : struct device_attribute *attr, char *buf)
603 : : {
604 : 0 : struct regulator_dev *rdev = dev_get_drvdata(dev);
605 : :
606 : 0 : return regulator_print_state(buf,
607 : 0 : rdev->constraints->state_standby.enabled);
608 : : }
609 : : static DEVICE_ATTR(suspend_standby_state, 0444,
610 : : regulator_suspend_standby_state_show, NULL);
611 : :
612 : 0 : static ssize_t regulator_bypass_show(struct device *dev,
613 : : struct device_attribute *attr, char *buf)
614 : : {
615 : 0 : struct regulator_dev *rdev = dev_get_drvdata(dev);
616 : : const char *report;
617 : : bool bypass;
618 : : int ret;
619 : :
620 : 0 : ret = rdev->desc->ops->get_bypass(rdev, &bypass);
621 : :
622 [ # # ]: 0 : if (ret != 0)
623 : : report = "unknown";
624 [ # # ]: 0 : else if (bypass)
625 : : report = "enabled";
626 : : else
627 : : report = "disabled";
628 : :
629 : 0 : return sprintf(buf, "%s\n", report);
630 : : }
631 : : static DEVICE_ATTR(bypass, 0444,
632 : : regulator_bypass_show, NULL);
633 : :
634 : : /*
635 : : * These are the only attributes are present for all regulators.
636 : : * Other attributes are a function of regulator functionality.
637 : : */
638 : : static struct attribute *regulator_dev_attrs[] = {
639 : : &dev_attr_name.attr,
640 : : &dev_attr_num_users.attr,
641 : : &dev_attr_type.attr,
642 : : NULL,
643 : : };
644 : : ATTRIBUTE_GROUPS(regulator_dev);
645 : :
646 : 0 : static void regulator_dev_release(struct device *dev)
647 : : {
648 : 0 : struct regulator_dev *rdev = dev_get_drvdata(dev);
649 : 0 : kfree(rdev);
650 : 0 : }
651 : :
652 : : static struct class regulator_class = {
653 : : .name = "regulator",
654 : : .dev_release = regulator_dev_release,
655 : : .dev_groups = regulator_dev_groups,
656 : : };
657 : :
658 : : /* Calculate the new optimum regulator operating mode based on the new total
659 : : * consumer load. All locks held by caller */
660 : 0 : static void drms_uA_update(struct regulator_dev *rdev)
661 : : {
662 : : struct regulator *sibling;
663 : : int current_uA = 0, output_uV, input_uV, err;
664 : : unsigned int mode;
665 : :
666 : 0 : err = regulator_check_drms(rdev);
667 [ # # ][ # # ]: 0 : if (err < 0 || !rdev->desc->ops->get_optimum_mode ||
[ # # ]
668 [ # # ]: 0 : (!rdev->desc->ops->get_voltage &&
669 [ # # ]: 0 : !rdev->desc->ops->get_voltage_sel) ||
670 : 0 : !rdev->desc->ops->set_mode)
671 : 0 : return;
672 : :
673 : : /* get output voltage */
674 : 0 : output_uV = _regulator_get_voltage(rdev);
675 [ # # ]: 0 : if (output_uV <= 0)
676 : : return;
677 : :
678 : : /* get input voltage */
679 : : input_uV = 0;
680 [ # # ]: 0 : if (rdev->supply)
681 : 0 : input_uV = regulator_get_voltage(rdev->supply);
682 [ # # ]: 0 : if (input_uV <= 0)
683 : 0 : input_uV = rdev->constraints->input_uV;
684 [ # # ]: 0 : if (input_uV <= 0)
685 : : return;
686 : :
687 : : /* calc total requested load */
688 [ # # ]: 0 : list_for_each_entry(sibling, &rdev->consumer_list, list)
689 : 0 : current_uA += sibling->uA_load;
690 : :
691 : : /* now get the optimum mode for our new total regulator load */
692 : 0 : mode = rdev->desc->ops->get_optimum_mode(rdev, input_uV,
693 : : output_uV, current_uA);
694 : :
695 : : /* check the new mode is allowed */
696 : 0 : err = regulator_mode_constrain(rdev, &mode);
697 [ # # ]: 0 : if (err == 0)
698 : 0 : rdev->desc->ops->set_mode(rdev, mode);
699 : : }
700 : :
701 : 0 : static int suspend_set_state(struct regulator_dev *rdev,
702 : : struct regulator_state *rstate)
703 : : {
704 : : int ret = 0;
705 : :
706 : : /* If we have no suspend mode configration don't set anything;
707 : : * only warn if the driver implements set_suspend_voltage or
708 : : * set_suspend_mode callback.
709 : : */
710 [ # # ][ # # ]: 0 : if (!rstate->enabled && !rstate->disabled) {
711 [ # # ][ # # ]: 0 : if (rdev->desc->ops->set_suspend_voltage ||
712 : 0 : rdev->desc->ops->set_suspend_mode)
713 : 0 : rdev_warn(rdev, "No configuration\n");
714 : : return 0;
715 : : }
716 : :
717 [ # # ][ # # ]: 0 : if (rstate->enabled && rstate->disabled) {
718 : 0 : rdev_err(rdev, "invalid configuration\n");
719 : 0 : return -EINVAL;
720 : : }
721 : :
722 [ # # ][ # # ]: 0 : if (rstate->enabled && rdev->desc->ops->set_suspend_enable)
723 : 0 : ret = rdev->desc->ops->set_suspend_enable(rdev);
724 [ # # ][ # # ]: 0 : else if (rstate->disabled && rdev->desc->ops->set_suspend_disable)
725 : 0 : ret = rdev->desc->ops->set_suspend_disable(rdev);
726 : : else /* OK if set_suspend_enable or set_suspend_disable is NULL */
727 : : ret = 0;
728 : :
729 [ # # ]: 0 : if (ret < 0) {
730 : 0 : rdev_err(rdev, "failed to enabled/disable\n");
731 : 0 : return ret;
732 : : }
733 : :
734 [ # # ][ # # ]: 0 : if (rdev->desc->ops->set_suspend_voltage && rstate->uV > 0) {
735 : 0 : ret = rdev->desc->ops->set_suspend_voltage(rdev, rstate->uV);
736 [ # # ]: 0 : if (ret < 0) {
737 : 0 : rdev_err(rdev, "failed to set voltage\n");
738 : 0 : return ret;
739 : : }
740 : : }
741 : :
742 [ # # ][ # # ]: 0 : if (rdev->desc->ops->set_suspend_mode && rstate->mode > 0) {
743 : 0 : ret = rdev->desc->ops->set_suspend_mode(rdev, rstate->mode);
744 [ # # ]: 0 : if (ret < 0) {
745 : 0 : rdev_err(rdev, "failed to set mode\n");
746 : 0 : return ret;
747 : : }
748 : : }
749 : 0 : return ret;
750 : : }
751 : :
752 : : /* locks held by caller */
753 : 0 : static int suspend_prepare(struct regulator_dev *rdev, suspend_state_t state)
754 : : {
755 [ # # ]: 0 : if (!rdev->constraints)
756 : : return -EINVAL;
757 : :
758 [ # # # # ]: 0 : switch (state) {
759 : : case PM_SUSPEND_STANDBY:
760 : 0 : return suspend_set_state(rdev,
761 : : &rdev->constraints->state_standby);
762 : : case PM_SUSPEND_MEM:
763 : 0 : return suspend_set_state(rdev,
764 : : &rdev->constraints->state_mem);
765 : : case PM_SUSPEND_MAX:
766 : 0 : return suspend_set_state(rdev,
767 : : &rdev->constraints->state_disk);
768 : : default:
769 : : return -EINVAL;
770 : : }
771 : : }
772 : :
773 : 0 : static void print_constraints(struct regulator_dev *rdev)
774 : : {
775 : 0 : struct regulation_constraints *constraints = rdev->constraints;
776 : 0 : char buf[80] = "";
777 : : int count = 0;
778 : : int ret;
779 : :
780 [ # # ][ # # ]: 0 : if (constraints->min_uV && constraints->max_uV) {
781 [ # # ]: 0 : if (constraints->min_uV == constraints->max_uV)
782 : 0 : count += sprintf(buf + count, "%d mV ",
783 : : constraints->min_uV / 1000);
784 : : else
785 : 0 : count += sprintf(buf + count, "%d <--> %d mV ",
786 : : constraints->min_uV / 1000,
787 : : constraints->max_uV / 1000);
788 : : }
789 : :
790 [ # # ][ # # ]: 0 : if (!constraints->min_uV ||
791 : 0 : constraints->min_uV != constraints->max_uV) {
792 : 0 : ret = _regulator_get_voltage(rdev);
793 [ # # ]: 0 : if (ret > 0)
794 : 0 : count += sprintf(buf + count, "at %d mV ", ret / 1000);
795 : : }
796 : :
797 [ # # ]: 0 : if (constraints->uV_offset)
798 : 0 : count += sprintf(buf, "%dmV offset ",
799 : : constraints->uV_offset / 1000);
800 : :
801 [ # # ][ # # ]: 0 : if (constraints->min_uA && constraints->max_uA) {
802 [ # # ]: 0 : if (constraints->min_uA == constraints->max_uA)
803 : 0 : count += sprintf(buf + count, "%d mA ",
804 : : constraints->min_uA / 1000);
805 : : else
806 : 0 : count += sprintf(buf + count, "%d <--> %d mA ",
807 : : constraints->min_uA / 1000,
808 : : constraints->max_uA / 1000);
809 : : }
810 : :
811 [ # # ][ # # ]: 0 : if (!constraints->min_uA ||
812 : 0 : constraints->min_uA != constraints->max_uA) {
813 : 0 : ret = _regulator_get_current_limit(rdev);
814 [ # # ]: 0 : if (ret > 0)
815 : 0 : count += sprintf(buf + count, "at %d mA ", ret / 1000);
816 : : }
817 : :
818 [ # # ]: 0 : if (constraints->valid_modes_mask & REGULATOR_MODE_FAST)
819 : 0 : count += sprintf(buf + count, "fast ");
820 [ # # ]: 0 : if (constraints->valid_modes_mask & REGULATOR_MODE_NORMAL)
821 : 0 : count += sprintf(buf + count, "normal ");
822 [ # # ]: 0 : if (constraints->valid_modes_mask & REGULATOR_MODE_IDLE)
823 : 0 : count += sprintf(buf + count, "idle ");
824 [ # # ]: 0 : if (constraints->valid_modes_mask & REGULATOR_MODE_STANDBY)
825 : 0 : count += sprintf(buf + count, "standby");
826 : :
827 [ # # ]: 0 : if (!count)
828 : 0 : sprintf(buf, "no parameters");
829 : :
830 : 0 : rdev_info(rdev, "%s\n", buf);
831 : :
832 [ # # ][ # # ]: 0 : if ((constraints->min_uV != constraints->max_uV) &&
833 : 0 : !(constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE))
834 : 0 : rdev_warn(rdev,
835 : : "Voltage range but no REGULATOR_CHANGE_VOLTAGE\n");
836 : 0 : }
837 : :
838 : 0 : static int machine_constraints_voltage(struct regulator_dev *rdev,
839 : : struct regulation_constraints *constraints)
840 : : {
841 : 0 : struct regulator_ops *ops = rdev->desc->ops;
842 : : int ret;
843 : :
844 : : /* do we need to apply the constraint voltage */
845 [ # # ][ # # ]: 0 : if (rdev->constraints->apply_uV &&
846 : 0 : rdev->constraints->min_uV == rdev->constraints->max_uV) {
847 : 0 : ret = _regulator_do_set_voltage(rdev,
848 : : rdev->constraints->min_uV,
849 : : rdev->constraints->max_uV);
850 [ # # ]: 0 : if (ret < 0) {
851 : 0 : rdev_err(rdev, "failed to apply %duV constraint\n",
852 : : rdev->constraints->min_uV);
853 : : return ret;
854 : : }
855 : : }
856 : :
857 : : /* constrain machine-level voltage specs to fit
858 : : * the actual range supported by this regulator.
859 : : */
860 [ # # ][ # # ]: 0 : if (ops->list_voltage && rdev->desc->n_voltages) {
861 : 0 : int count = rdev->desc->n_voltages;
862 : : int i;
863 : : int min_uV = INT_MAX;
864 : : int max_uV = INT_MIN;
865 : 0 : int cmin = constraints->min_uV;
866 : 0 : int cmax = constraints->max_uV;
867 : :
868 : : /* it's safe to autoconfigure fixed-voltage supplies
869 : : and the constraints are used by list_voltage. */
870 [ # # ]: 0 : if (count == 1 && !cmin) {
871 : : cmin = 1;
872 : : cmax = INT_MAX;
873 : 0 : constraints->min_uV = cmin;
874 : 0 : constraints->max_uV = cmax;
875 : : }
876 : :
877 : : /* voltage constraints are optional */
878 [ # # ]: 0 : if ((cmin == 0) && (cmax == 0))
879 : : return 0;
880 : :
881 : : /* else require explicit machine-level constraints */
882 [ # # ][ # # ]: 0 : if (cmin <= 0 || cmax <= 0 || cmax < cmin) {
883 : 0 : rdev_err(rdev, "invalid voltage constraints\n");
884 : : return -EINVAL;
885 : : }
886 : :
887 : : /* initial: [cmin..cmax] valid, [min_uV..max_uV] not */
888 [ # # ]: 0 : for (i = 0; i < count; i++) {
889 : : int value;
890 : :
891 : 0 : value = ops->list_voltage(rdev, i);
892 [ # # ]: 0 : if (value <= 0)
893 : 0 : continue;
894 : :
895 : : /* maybe adjust [min_uV..max_uV] */
896 [ # # ]: 0 : if (value >= cmin && value < min_uV)
897 : : min_uV = value;
898 [ # # ]: 0 : if (value <= cmax && value > max_uV)
899 : : max_uV = value;
900 : : }
901 : :
902 : : /* final: [min_uV..max_uV] valid iff constraints valid */
903 [ # # ]: 0 : if (max_uV < min_uV) {
904 : 0 : rdev_err(rdev,
905 : : "unsupportable voltage constraints %u-%uuV\n",
906 : : min_uV, max_uV);
907 : : return -EINVAL;
908 : : }
909 : :
910 : : /* use regulator's subset of machine constraints */
911 [ # # ]: 0 : if (constraints->min_uV < min_uV) {
912 : : rdev_dbg(rdev, "override min_uV, %d -> %d\n",
913 : : constraints->min_uV, min_uV);
914 : 0 : constraints->min_uV = min_uV;
915 : : }
916 [ # # ]: 0 : if (constraints->max_uV > max_uV) {
917 : : rdev_dbg(rdev, "override max_uV, %d -> %d\n",
918 : : constraints->max_uV, max_uV);
919 : 0 : constraints->max_uV = max_uV;
920 : : }
921 : : }
922 : :
923 : : return 0;
924 : : }
925 : :
926 : 0 : static int machine_constraints_current(struct regulator_dev *rdev,
927 : : struct regulation_constraints *constraints)
928 : : {
929 : 0 : struct regulator_ops *ops = rdev->desc->ops;
930 : : int ret;
931 : :
932 [ # # ][ # # ]: 0 : if (!constraints->min_uA && !constraints->max_uA)
933 : : return 0;
934 : :
935 [ # # ]: 0 : if (constraints->min_uA > constraints->max_uA) {
936 : 0 : rdev_err(rdev, "Invalid current constraints\n");
937 : : return -EINVAL;
938 : : }
939 : :
940 [ # # ][ # # ]: 0 : if (!ops->set_current_limit || !ops->get_current_limit) {
941 : 0 : rdev_warn(rdev, "Operation of current configuration missing\n");
942 : : return 0;
943 : : }
944 : :
945 : : /* Set regulator current in constraints range */
946 : 0 : ret = ops->set_current_limit(rdev, constraints->min_uA,
947 : : constraints->max_uA);
948 [ # # ]: 0 : if (ret < 0) {
949 : 0 : rdev_err(rdev, "Failed to set current constraint, %d\n", ret);
950 : : return ret;
951 : : }
952 : :
953 : : return 0;
954 : : }
955 : :
956 : : /**
957 : : * set_machine_constraints - sets regulator constraints
958 : : * @rdev: regulator source
959 : : * @constraints: constraints to apply
960 : : *
961 : : * Allows platform initialisation code to define and constrain
962 : : * regulator circuits e.g. valid voltage/current ranges, etc. NOTE:
963 : : * Constraints *must* be set by platform code in order for some
964 : : * regulator operations to proceed i.e. set_voltage, set_current_limit,
965 : : * set_mode.
966 : : */
967 : 0 : static int set_machine_constraints(struct regulator_dev *rdev,
968 : : const struct regulation_constraints *constraints)
969 : : {
970 : : int ret = 0;
971 : 0 : struct regulator_ops *ops = rdev->desc->ops;
972 : :
973 [ # # ]: 0 : if (constraints)
974 : 0 : rdev->constraints = kmemdup(constraints, sizeof(*constraints),
975 : : GFP_KERNEL);
976 : : else
977 : 0 : rdev->constraints = kzalloc(sizeof(*constraints),
978 : : GFP_KERNEL);
979 [ # # ]: 0 : if (!rdev->constraints)
980 : : return -ENOMEM;
981 : :
982 : 0 : ret = machine_constraints_voltage(rdev, rdev->constraints);
983 [ # # ]: 0 : if (ret != 0)
984 : : goto out;
985 : :
986 : 0 : ret = machine_constraints_current(rdev, rdev->constraints);
987 [ # # ]: 0 : if (ret != 0)
988 : : goto out;
989 : :
990 : : /* do we need to setup our suspend state */
991 [ # # ]: 0 : if (rdev->constraints->initial_state) {
992 : 0 : ret = suspend_prepare(rdev, rdev->constraints->initial_state);
993 [ # # ]: 0 : if (ret < 0) {
994 : 0 : rdev_err(rdev, "failed to set suspend state\n");
995 : 0 : goto out;
996 : : }
997 : : }
998 : :
999 [ # # ]: 0 : if (rdev->constraints->initial_mode) {
1000 [ # # ]: 0 : if (!ops->set_mode) {
1001 : 0 : rdev_err(rdev, "no set_mode operation\n");
1002 : : ret = -EINVAL;
1003 : 0 : goto out;
1004 : : }
1005 : :
1006 : 0 : ret = ops->set_mode(rdev, rdev->constraints->initial_mode);
1007 [ # # ]: 0 : if (ret < 0) {
1008 : 0 : rdev_err(rdev, "failed to set initial mode: %d\n", ret);
1009 : 0 : goto out;
1010 : : }
1011 : : }
1012 : :
1013 : : /* If the constraints say the regulator should be on at this point
1014 : : * and we have control then make sure it is enabled.
1015 : : */
1016 [ # # ][ # # ]: 0 : if ((rdev->constraints->always_on || rdev->constraints->boot_on) &&
1017 : 0 : ops->enable) {
1018 : 0 : ret = ops->enable(rdev);
1019 [ # # ]: 0 : if (ret < 0) {
1020 : 0 : rdev_err(rdev, "failed to enable\n");
1021 : 0 : goto out;
1022 : : }
1023 : : }
1024 : :
1025 [ # # ][ # # ]: 0 : if ((rdev->constraints->ramp_delay || rdev->constraints->ramp_disable)
1026 [ # # ]: 0 : && ops->set_ramp_delay) {
1027 : 0 : ret = ops->set_ramp_delay(rdev, rdev->constraints->ramp_delay);
1028 [ # # ]: 0 : if (ret < 0) {
1029 : 0 : rdev_err(rdev, "failed to set ramp_delay\n");
1030 : 0 : goto out;
1031 : : }
1032 : : }
1033 : :
1034 : 0 : print_constraints(rdev);
1035 : 0 : return 0;
1036 : : out:
1037 : 0 : kfree(rdev->constraints);
1038 : 0 : rdev->constraints = NULL;
1039 : 0 : return ret;
1040 : : }
1041 : :
1042 : : /**
1043 : : * set_supply - set regulator supply regulator
1044 : : * @rdev: regulator name
1045 : : * @supply_rdev: supply regulator name
1046 : : *
1047 : : * Called by platform initialisation code to set the supply regulator for this
1048 : : * regulator. This ensures that a regulators supply will also be enabled by the
1049 : : * core if it's child is enabled.
1050 : : */
1051 : 0 : static int set_supply(struct regulator_dev *rdev,
1052 : 0 : struct regulator_dev *supply_rdev)
1053 : : {
1054 : : int err;
1055 : :
1056 : 0 : rdev_info(rdev, "supplied by %s\n", rdev_get_name(supply_rdev));
1057 : :
1058 : 0 : rdev->supply = create_regulator(supply_rdev, &rdev->dev, "SUPPLY");
1059 [ # # ]: 0 : if (rdev->supply == NULL) {
1060 : : err = -ENOMEM;
1061 : : return err;
1062 : : }
1063 : 0 : supply_rdev->open_count++;
1064 : :
1065 : 0 : return 0;
1066 : : }
1067 : :
1068 : : /**
1069 : : * set_consumer_device_supply - Bind a regulator to a symbolic supply
1070 : : * @rdev: regulator source
1071 : : * @consumer_dev_name: dev_name() string for device supply applies to
1072 : : * @supply: symbolic name for supply
1073 : : *
1074 : : * Allows platform initialisation code to map physical regulator
1075 : : * sources to symbolic names for supplies for use by devices. Devices
1076 : : * should use these symbolic names to request regulators, avoiding the
1077 : : * need to provide board-specific regulator names as platform data.
1078 : : */
1079 : 0 : static int set_consumer_device_supply(struct regulator_dev *rdev,
1080 : : const char *consumer_dev_name,
1081 : : const char *supply)
1082 : : {
1083 : : struct regulator_map *node;
1084 : : int has_dev;
1085 : :
1086 [ # # ]: 0 : if (supply == NULL)
1087 : : return -EINVAL;
1088 : :
1089 [ # # ]: 0 : if (consumer_dev_name != NULL)
1090 : : has_dev = 1;
1091 : : else
1092 : : has_dev = 0;
1093 : :
1094 [ # # ]: 0 : list_for_each_entry(node, ®ulator_map_list, list) {
1095 [ # # ][ # # ]: 0 : if (node->dev_name && consumer_dev_name) {
1096 [ # # ]: 0 : if (strcmp(node->dev_name, consumer_dev_name) != 0)
1097 : 0 : continue;
1098 [ # # ][ # # ]: 0 : } else if (node->dev_name || consumer_dev_name) {
1099 : 0 : continue;
1100 : : }
1101 : :
1102 [ # # ]: 0 : if (strcmp(node->supply, supply) != 0)
1103 : 0 : continue;
1104 : :
1105 : : pr_debug("%s: %s/%s is '%s' supply; fail %s/%s\n",
1106 : : consumer_dev_name,
1107 : : dev_name(&node->regulator->dev),
1108 : : node->regulator->desc->name,
1109 : : supply,
1110 : : dev_name(&rdev->dev), rdev_get_name(rdev));
1111 : : return -EBUSY;
1112 : : }
1113 : :
1114 : : node = kzalloc(sizeof(struct regulator_map), GFP_KERNEL);
1115 [ # # ]: 0 : if (node == NULL)
1116 : : return -ENOMEM;
1117 : :
1118 : 0 : node->regulator = rdev;
1119 : 0 : node->supply = supply;
1120 : :
1121 [ # # ]: 0 : if (has_dev) {
1122 : 0 : node->dev_name = kstrdup(consumer_dev_name, GFP_KERNEL);
1123 [ # # ]: 0 : if (node->dev_name == NULL) {
1124 : 0 : kfree(node);
1125 : 0 : return -ENOMEM;
1126 : : }
1127 : : }
1128 : :
1129 : 0 : list_add(&node->list, ®ulator_map_list);
1130 : 0 : return 0;
1131 : : }
1132 : :
1133 : 0 : static void unset_regulator_supplies(struct regulator_dev *rdev)
1134 : : {
1135 : : struct regulator_map *node, *n;
1136 : :
1137 [ # # ]: 0 : list_for_each_entry_safe(node, n, ®ulator_map_list, list) {
1138 [ # # ]: 0 : if (rdev == node->regulator) {
1139 : : list_del(&node->list);
1140 : 0 : kfree(node->dev_name);
1141 : 0 : kfree(node);
1142 : : }
1143 : : }
1144 : 0 : }
1145 : :
1146 : : #define REG_STR_SIZE 64
1147 : :
1148 : 0 : static struct regulator *create_regulator(struct regulator_dev *rdev,
1149 : : struct device *dev,
1150 : : const char *supply_name)
1151 : : {
1152 : : struct regulator *regulator;
1153 : : char buf[REG_STR_SIZE];
1154 : : int err, size;
1155 : :
1156 : : regulator = kzalloc(sizeof(*regulator), GFP_KERNEL);
1157 [ # # ]: 0 : if (regulator == NULL)
1158 : : return NULL;
1159 : :
1160 : 0 : mutex_lock(&rdev->mutex);
1161 : 0 : regulator->rdev = rdev;
1162 : 0 : list_add(®ulator->list, &rdev->consumer_list);
1163 : :
1164 [ # # ]: 0 : if (dev) {
1165 : 0 : regulator->dev = dev;
1166 : :
1167 : : /* Add a link to the device sysfs entry */
1168 : 0 : size = scnprintf(buf, REG_STR_SIZE, "%s-%s",
1169 : : dev->kobj.name, supply_name);
1170 [ # # ]: 0 : if (size >= REG_STR_SIZE)
1171 : : goto overflow_err;
1172 : :
1173 : 0 : regulator->supply_name = kstrdup(buf, GFP_KERNEL);
1174 [ # # ]: 0 : if (regulator->supply_name == NULL)
1175 : : goto overflow_err;
1176 : :
1177 : 0 : err = sysfs_create_link(&rdev->dev.kobj, &dev->kobj,
1178 : : buf);
1179 [ # # ]: 0 : if (err) {
1180 : 0 : rdev_warn(rdev, "could not add device link %s err %d\n",
1181 : : dev->kobj.name, err);
1182 : : /* non-fatal */
1183 : : }
1184 : : } else {
1185 : 0 : regulator->supply_name = kstrdup(supply_name, GFP_KERNEL);
1186 [ # # ]: 0 : if (regulator->supply_name == NULL)
1187 : : goto overflow_err;
1188 : : }
1189 : :
1190 : 0 : regulator->debugfs = debugfs_create_dir(regulator->supply_name,
1191 : : rdev->debugfs);
1192 [ # # ]: 0 : if (!regulator->debugfs) {
1193 : 0 : rdev_warn(rdev, "Failed to create debugfs directory\n");
1194 : : } else {
1195 : 0 : debugfs_create_u32("uA_load", 0444, regulator->debugfs,
1196 : 0 : ®ulator->uA_load);
1197 : 0 : debugfs_create_u32("min_uV", 0444, regulator->debugfs,
1198 : 0 : ®ulator->min_uV);
1199 : 0 : debugfs_create_u32("max_uV", 0444, regulator->debugfs,
1200 : 0 : ®ulator->max_uV);
1201 : : }
1202 : :
1203 : : /*
1204 : : * Check now if the regulator is an always on regulator - if
1205 : : * it is then we don't need to do nearly so much work for
1206 : : * enable/disable calls.
1207 : : */
1208 [ # # ][ # # ]: 0 : if (!_regulator_can_change_status(rdev) &&
1209 : : _regulator_is_enabled(rdev))
1210 : 0 : regulator->always_on = true;
1211 : :
1212 : 0 : mutex_unlock(&rdev->mutex);
1213 : 0 : return regulator;
1214 : : overflow_err:
1215 : : list_del(®ulator->list);
1216 : 0 : kfree(regulator);
1217 : 0 : mutex_unlock(&rdev->mutex);
1218 : 0 : return NULL;
1219 : : }
1220 : :
1221 : 0 : static int _regulator_get_enable_time(struct regulator_dev *rdev)
1222 : : {
1223 [ # # ][ # # ]: 0 : if (rdev->constraints && rdev->constraints->enable_time)
1224 : 0 : return rdev->constraints->enable_time;
1225 [ # # ]: 0 : if (!rdev->desc->ops->enable_time)
1226 : 0 : return rdev->desc->enable_time;
1227 : 0 : return rdev->desc->ops->enable_time(rdev);
1228 : : }
1229 : :
1230 : 0 : static struct regulator_supply_alias *regulator_find_supply_alias(
1231 : : struct device *dev, const char *supply)
1232 : : {
1233 : : struct regulator_supply_alias *map;
1234 : :
1235 [ # # ]: 0 : list_for_each_entry(map, ®ulator_supply_alias_list, list)
1236 [ # # ][ # # ]: 0 : if (map->src_dev == dev && strcmp(map->src_supply, supply) == 0)
1237 : : return map;
1238 : :
1239 : : return NULL;
1240 : : }
1241 : :
1242 : 0 : static void regulator_supply_alias(struct device **dev, const char **supply)
1243 : : {
1244 : : struct regulator_supply_alias *map;
1245 : :
1246 : 0 : map = regulator_find_supply_alias(*dev, *supply);
1247 [ # # ]: 0 : if (map) {
1248 : : dev_dbg(*dev, "Mapping supply %s to %s,%s\n",
1249 : : *supply, map->alias_supply,
1250 : : dev_name(map->alias_dev));
1251 : 0 : *dev = map->alias_dev;
1252 : 0 : *supply = map->alias_supply;
1253 : : }
1254 : 0 : }
1255 : :
1256 : 0 : static struct regulator_dev *regulator_dev_lookup(struct device *dev,
1257 : : const char *supply,
1258 : : int *ret)
1259 : : {
1260 : 0 : struct regulator_dev *r;
1261 : : struct device_node *node;
1262 : : struct regulator_map *map;
1263 : : const char *devname = NULL;
1264 : :
1265 : 0 : regulator_supply_alias(&dev, &supply);
1266 : :
1267 : : /* first do a dt based lookup */
1268 [ # # ][ # # ]: 0 : if (dev && dev->of_node) {
1269 : 0 : node = of_get_regulator(dev, supply);
1270 [ # # ]: 0 : if (node) {
1271 [ # # ]: 0 : list_for_each_entry(r, ®ulator_list, list)
1272 [ # # ][ # # ]: 0 : if (r->dev.parent &&
1273 : 0 : node == r->dev.of_node)
1274 : : return r;
1275 : : } else {
1276 : : /*
1277 : : * If we couldn't even get the node then it's
1278 : : * not just that the device didn't register
1279 : : * yet, there's no node and we'll never
1280 : : * succeed.
1281 : : */
1282 : 0 : *ret = -ENODEV;
1283 : : }
1284 : : }
1285 : :
1286 : : /* if not found, try doing it non-dt way */
1287 [ # # ]: 0 : if (dev)
1288 : : devname = dev_name(dev);
1289 : :
1290 [ # # ]: 0 : list_for_each_entry(r, ®ulator_list, list)
1291 [ # # ]: 0 : if (strcmp(rdev_get_name(r), supply) == 0)
1292 : : return r;
1293 : :
1294 [ # # ]: 0 : list_for_each_entry(map, ®ulator_map_list, list) {
1295 : : /* If the mapping has a device set up it must match */
1296 [ # # ][ # # ]: 0 : if (map->dev_name &&
1297 [ # # ]: 0 : (!devname || strcmp(map->dev_name, devname)))
1298 : 0 : continue;
1299 : :
1300 [ # # ]: 0 : if (strcmp(map->supply, supply) == 0)
1301 : 0 : return map->regulator;
1302 : : }
1303 : :
1304 : :
1305 : : return NULL;
1306 : : }
1307 : :
1308 : : /* Internal regulator request function */
1309 : 0 : static struct regulator *_regulator_get(struct device *dev, const char *id,
1310 : : bool exclusive, bool allow_dummy)
1311 : : {
1312 : : struct regulator_dev *rdev;
1313 : : struct regulator *regulator = ERR_PTR(-EPROBE_DEFER);
1314 : : const char *devname = NULL;
1315 : 0 : int ret = -EPROBE_DEFER;
1316 : :
1317 [ # # ]: 0 : if (id == NULL) {
1318 : 0 : pr_err("get() with no identifier\n");
1319 : 0 : return ERR_PTR(-EINVAL);
1320 : : }
1321 : :
1322 [ # # ]: 0 : if (dev)
1323 : : devname = dev_name(dev);
1324 : :
1325 : 0 : mutex_lock(®ulator_list_mutex);
1326 : :
1327 : 0 : rdev = regulator_dev_lookup(dev, id, &ret);
1328 [ # # ]: 0 : if (rdev)
1329 : : goto found;
1330 : :
1331 : 0 : regulator = ERR_PTR(ret);
1332 : :
1333 : : /*
1334 : : * If we have return value from dev_lookup fail, we do not expect to
1335 : : * succeed, so, quit with appropriate error value
1336 : : */
1337 [ # # ]: 0 : if (ret && ret != -ENODEV) {
1338 : : goto out;
1339 : : }
1340 : :
1341 [ # # ]: 0 : if (!devname)
1342 : : devname = "deviceless";
1343 : :
1344 : : /*
1345 : : * Assume that a regulator is physically present and enabled
1346 : : * even if it isn't hooked up and just provide a dummy.
1347 : : */
1348 [ # # ][ # # ]: 0 : if (have_full_constraints() && allow_dummy) {
1349 : 0 : pr_warn("%s supply %s not found, using dummy regulator\n",
1350 : : devname, id);
1351 : :
1352 : 0 : rdev = dummy_regulator_rdev;
1353 : 0 : goto found;
1354 : : } else {
1355 : 0 : dev_err(dev, "dummy supplies not allowed\n");
1356 : : }
1357 : :
1358 : 0 : mutex_unlock(®ulator_list_mutex);
1359 : 0 : return regulator;
1360 : :
1361 : : found:
1362 [ # # ]: 0 : if (rdev->exclusive) {
1363 : : regulator = ERR_PTR(-EPERM);
1364 : : goto out;
1365 : : }
1366 : :
1367 [ # # ][ # # ]: 0 : if (exclusive && rdev->open_count) {
1368 : : regulator = ERR_PTR(-EBUSY);
1369 : : goto out;
1370 : : }
1371 : :
1372 [ # # ]: 0 : if (!try_module_get(rdev->owner))
1373 : : goto out;
1374 : :
1375 : 0 : regulator = create_regulator(rdev, dev, id);
1376 [ # # ]: 0 : if (regulator == NULL) {
1377 : : regulator = ERR_PTR(-ENOMEM);
1378 : 0 : module_put(rdev->owner);
1379 : 0 : goto out;
1380 : : }
1381 : :
1382 : 0 : rdev->open_count++;
1383 [ # # ]: 0 : if (exclusive) {
1384 : 0 : rdev->exclusive = 1;
1385 : :
1386 : 0 : ret = _regulator_is_enabled(rdev);
1387 [ # # ]: 0 : if (ret > 0)
1388 : 0 : rdev->use_count = 1;
1389 : : else
1390 : 0 : rdev->use_count = 0;
1391 : : }
1392 : :
1393 : : out:
1394 : 0 : mutex_unlock(®ulator_list_mutex);
1395 : :
1396 : 0 : return regulator;
1397 : : }
1398 : :
1399 : : /**
1400 : : * regulator_get - lookup and obtain a reference to a regulator.
1401 : : * @dev: device for regulator "consumer"
1402 : : * @id: Supply name or regulator ID.
1403 : : *
1404 : : * Returns a struct regulator corresponding to the regulator producer,
1405 : : * or IS_ERR() condition containing errno.
1406 : : *
1407 : : * Use of supply names configured via regulator_set_device_supply() is
1408 : : * strongly encouraged. It is recommended that the supply name used
1409 : : * should match the name used for the supply and/or the relevant
1410 : : * device pins in the datasheet.
1411 : : */
1412 : 0 : struct regulator *regulator_get(struct device *dev, const char *id)
1413 : : {
1414 : 0 : return _regulator_get(dev, id, false, true);
1415 : : }
1416 : : EXPORT_SYMBOL_GPL(regulator_get);
1417 : :
1418 : : /**
1419 : : * regulator_get_exclusive - obtain exclusive access to a regulator.
1420 : : * @dev: device for regulator "consumer"
1421 : : * @id: Supply name or regulator ID.
1422 : : *
1423 : : * Returns a struct regulator corresponding to the regulator producer,
1424 : : * or IS_ERR() condition containing errno. Other consumers will be
1425 : : * unable to obtain this reference is held and the use count for the
1426 : : * regulator will be initialised to reflect the current state of the
1427 : : * regulator.
1428 : : *
1429 : : * This is intended for use by consumers which cannot tolerate shared
1430 : : * use of the regulator such as those which need to force the
1431 : : * regulator off for correct operation of the hardware they are
1432 : : * controlling.
1433 : : *
1434 : : * Use of supply names configured via regulator_set_device_supply() is
1435 : : * strongly encouraged. It is recommended that the supply name used
1436 : : * should match the name used for the supply and/or the relevant
1437 : : * device pins in the datasheet.
1438 : : */
1439 : 0 : struct regulator *regulator_get_exclusive(struct device *dev, const char *id)
1440 : : {
1441 : 0 : return _regulator_get(dev, id, true, false);
1442 : : }
1443 : : EXPORT_SYMBOL_GPL(regulator_get_exclusive);
1444 : :
1445 : : /**
1446 : : * regulator_get_optional - obtain optional access to a regulator.
1447 : : * @dev: device for regulator "consumer"
1448 : : * @id: Supply name or regulator ID.
1449 : : *
1450 : : * Returns a struct regulator corresponding to the regulator producer,
1451 : : * or IS_ERR() condition containing errno. Other consumers will be
1452 : : * unable to obtain this reference is held and the use count for the
1453 : : * regulator will be initialised to reflect the current state of the
1454 : : * regulator.
1455 : : *
1456 : : * This is intended for use by consumers for devices which can have
1457 : : * some supplies unconnected in normal use, such as some MMC devices.
1458 : : * It can allow the regulator core to provide stub supplies for other
1459 : : * supplies requested using normal regulator_get() calls without
1460 : : * disrupting the operation of drivers that can handle absent
1461 : : * supplies.
1462 : : *
1463 : : * Use of supply names configured via regulator_set_device_supply() is
1464 : : * strongly encouraged. It is recommended that the supply name used
1465 : : * should match the name used for the supply and/or the relevant
1466 : : * device pins in the datasheet.
1467 : : */
1468 : 0 : struct regulator *regulator_get_optional(struct device *dev, const char *id)
1469 : : {
1470 : 0 : return _regulator_get(dev, id, false, false);
1471 : : }
1472 : : EXPORT_SYMBOL_GPL(regulator_get_optional);
1473 : :
1474 : : /* Locks held by regulator_put() */
1475 : 0 : static void _regulator_put(struct regulator *regulator)
1476 : : {
1477 : : struct regulator_dev *rdev;
1478 : :
1479 [ # # ][ # # ]: 0 : if (regulator == NULL || IS_ERR(regulator))
1480 : 0 : return;
1481 : :
1482 : 0 : rdev = regulator->rdev;
1483 : :
1484 : 0 : debugfs_remove_recursive(regulator->debugfs);
1485 : :
1486 : : /* remove any sysfs entries */
1487 [ # # ]: 0 : if (regulator->dev)
1488 : 0 : sysfs_remove_link(&rdev->dev.kobj, regulator->supply_name);
1489 : 0 : kfree(regulator->supply_name);
1490 : : list_del(®ulator->list);
1491 : 0 : kfree(regulator);
1492 : :
1493 : 0 : rdev->open_count--;
1494 : 0 : rdev->exclusive = 0;
1495 : :
1496 : 0 : module_put(rdev->owner);
1497 : : }
1498 : :
1499 : : /**
1500 : : * regulator_put - "free" the regulator source
1501 : : * @regulator: regulator source
1502 : : *
1503 : : * Note: drivers must ensure that all regulator_enable calls made on this
1504 : : * regulator source are balanced by regulator_disable calls prior to calling
1505 : : * this function.
1506 : : */
1507 : 0 : void regulator_put(struct regulator *regulator)
1508 : : {
1509 : 0 : mutex_lock(®ulator_list_mutex);
1510 : 0 : _regulator_put(regulator);
1511 : 0 : mutex_unlock(®ulator_list_mutex);
1512 : 0 : }
1513 : : EXPORT_SYMBOL_GPL(regulator_put);
1514 : :
1515 : : /**
1516 : : * regulator_register_supply_alias - Provide device alias for supply lookup
1517 : : *
1518 : : * @dev: device that will be given as the regulator "consumer"
1519 : : * @id: Supply name or regulator ID
1520 : : * @alias_dev: device that should be used to lookup the supply
1521 : : * @alias_id: Supply name or regulator ID that should be used to lookup the
1522 : : * supply
1523 : : *
1524 : : * All lookups for id on dev will instead be conducted for alias_id on
1525 : : * alias_dev.
1526 : : */
1527 : 0 : int regulator_register_supply_alias(struct device *dev, const char *id,
1528 : : struct device *alias_dev,
1529 : : const char *alias_id)
1530 : : {
1531 : : struct regulator_supply_alias *map;
1532 : :
1533 : 0 : map = regulator_find_supply_alias(dev, id);
1534 [ # # ]: 0 : if (map)
1535 : : return -EEXIST;
1536 : :
1537 : : map = kzalloc(sizeof(struct regulator_supply_alias), GFP_KERNEL);
1538 [ # # ]: 0 : if (!map)
1539 : : return -ENOMEM;
1540 : :
1541 : 0 : map->src_dev = dev;
1542 : 0 : map->src_supply = id;
1543 : 0 : map->alias_dev = alias_dev;
1544 : 0 : map->alias_supply = alias_id;
1545 : :
1546 : 0 : list_add(&map->list, ®ulator_supply_alias_list);
1547 : :
1548 : 0 : pr_info("Adding alias for supply %s,%s -> %s,%s\n",
1549 : : id, dev_name(dev), alias_id, dev_name(alias_dev));
1550 : :
1551 : 0 : return 0;
1552 : : }
1553 : : EXPORT_SYMBOL_GPL(regulator_register_supply_alias);
1554 : :
1555 : : /**
1556 : : * regulator_unregister_supply_alias - Remove device alias
1557 : : *
1558 : : * @dev: device that will be given as the regulator "consumer"
1559 : : * @id: Supply name or regulator ID
1560 : : *
1561 : : * Remove a lookup alias if one exists for id on dev.
1562 : : */
1563 : 0 : void regulator_unregister_supply_alias(struct device *dev, const char *id)
1564 : : {
1565 : : struct regulator_supply_alias *map;
1566 : :
1567 : 0 : map = regulator_find_supply_alias(dev, id);
1568 [ # # ]: 0 : if (map) {
1569 : : list_del(&map->list);
1570 : 0 : kfree(map);
1571 : : }
1572 : 0 : }
1573 : : EXPORT_SYMBOL_GPL(regulator_unregister_supply_alias);
1574 : :
1575 : : /**
1576 : : * regulator_bulk_register_supply_alias - register multiple aliases
1577 : : *
1578 : : * @dev: device that will be given as the regulator "consumer"
1579 : : * @id: List of supply names or regulator IDs
1580 : : * @alias_dev: device that should be used to lookup the supply
1581 : : * @alias_id: List of supply names or regulator IDs that should be used to
1582 : : * lookup the supply
1583 : : * @num_id: Number of aliases to register
1584 : : *
1585 : : * @return 0 on success, an errno on failure.
1586 : : *
1587 : : * This helper function allows drivers to register several supply
1588 : : * aliases in one operation. If any of the aliases cannot be
1589 : : * registered any aliases that were registered will be removed
1590 : : * before returning to the caller.
1591 : : */
1592 : 0 : int regulator_bulk_register_supply_alias(struct device *dev, const char **id,
1593 : : struct device *alias_dev,
1594 : : const char **alias_id,
1595 : : int num_id)
1596 : : {
1597 : : int i;
1598 : : int ret;
1599 : :
1600 [ # # ]: 0 : for (i = 0; i < num_id; ++i) {
1601 : 0 : ret = regulator_register_supply_alias(dev, id[i], alias_dev,
1602 : 0 : alias_id[i]);
1603 [ # # ]: 0 : if (ret < 0)
1604 : : goto err;
1605 : : }
1606 : :
1607 : : return 0;
1608 : :
1609 : : err:
1610 : 0 : dev_err(dev,
1611 : : "Failed to create supply alias %s,%s -> %s,%s\n",
1612 : : id[i], dev_name(dev), alias_id[i], dev_name(alias_dev));
1613 : :
1614 [ # # ]: 0 : while (--i >= 0)
1615 : 0 : regulator_unregister_supply_alias(dev, id[i]);
1616 : :
1617 : : return ret;
1618 : : }
1619 : : EXPORT_SYMBOL_GPL(regulator_bulk_register_supply_alias);
1620 : :
1621 : : /**
1622 : : * regulator_bulk_unregister_supply_alias - unregister multiple aliases
1623 : : *
1624 : : * @dev: device that will be given as the regulator "consumer"
1625 : : * @id: List of supply names or regulator IDs
1626 : : * @num_id: Number of aliases to unregister
1627 : : *
1628 : : * This helper function allows drivers to unregister several supply
1629 : : * aliases in one operation.
1630 : : */
1631 : 0 : void regulator_bulk_unregister_supply_alias(struct device *dev,
1632 : : const char **id,
1633 : : int num_id)
1634 : : {
1635 : : int i;
1636 : :
1637 [ # # ]: 0 : for (i = 0; i < num_id; ++i)
1638 : 0 : regulator_unregister_supply_alias(dev, id[i]);
1639 : 0 : }
1640 : : EXPORT_SYMBOL_GPL(regulator_bulk_unregister_supply_alias);
1641 : :
1642 : :
1643 : : /* Manage enable GPIO list. Same GPIO pin can be shared among regulators */
1644 : 0 : static int regulator_ena_gpio_request(struct regulator_dev *rdev,
1645 : : const struct regulator_config *config)
1646 : : {
1647 : : struct regulator_enable_gpio *pin;
1648 : : int ret;
1649 : :
1650 [ # # ]: 0 : list_for_each_entry(pin, ®ulator_ena_gpio_list, list) {
1651 [ # # ]: 0 : if (pin->gpio == config->ena_gpio) {
1652 : : rdev_dbg(rdev, "GPIO %d is already used\n",
1653 : : config->ena_gpio);
1654 : : goto update_ena_gpio_to_rdev;
1655 : : }
1656 : : }
1657 : :
1658 : 0 : ret = gpio_request_one(config->ena_gpio,
1659 : 0 : GPIOF_DIR_OUT | config->ena_gpio_flags,
1660 : : rdev_get_name(rdev));
1661 [ # # ]: 0 : if (ret)
1662 : : return ret;
1663 : :
1664 : : pin = kzalloc(sizeof(struct regulator_enable_gpio), GFP_KERNEL);
1665 [ # # ]: 0 : if (pin == NULL) {
1666 : 0 : gpio_free(config->ena_gpio);
1667 : 0 : return -ENOMEM;
1668 : : }
1669 : :
1670 : 0 : pin->gpio = config->ena_gpio;
1671 : 0 : pin->ena_gpio_invert = config->ena_gpio_invert;
1672 : 0 : list_add(&pin->list, ®ulator_ena_gpio_list);
1673 : :
1674 : : update_ena_gpio_to_rdev:
1675 : 0 : pin->request_count++;
1676 : 0 : rdev->ena_pin = pin;
1677 : 0 : return 0;
1678 : : }
1679 : :
1680 : 0 : static void regulator_ena_gpio_free(struct regulator_dev *rdev)
1681 : : {
1682 : : struct regulator_enable_gpio *pin, *n;
1683 : :
1684 [ # # ]: 0 : if (!rdev->ena_pin)
1685 : 0 : return;
1686 : :
1687 : : /* Free the GPIO only in case of no use */
1688 [ # # ]: 0 : list_for_each_entry_safe(pin, n, ®ulator_ena_gpio_list, list) {
1689 [ # # ]: 0 : if (pin->gpio == rdev->ena_pin->gpio) {
1690 [ # # ]: 0 : if (pin->request_count <= 1) {
1691 : 0 : pin->request_count = 0;
1692 : 0 : gpio_free(pin->gpio);
1693 : : list_del(&pin->list);
1694 : 0 : kfree(pin);
1695 : : } else {
1696 : 0 : pin->request_count--;
1697 : : }
1698 : : }
1699 : : }
1700 : : }
1701 : :
1702 : : /**
1703 : : * regulator_ena_gpio_ctrl - balance enable_count of each GPIO and actual GPIO pin control
1704 : : * @rdev: regulator_dev structure
1705 : : * @enable: enable GPIO at initial use?
1706 : : *
1707 : : * GPIO is enabled in case of initial use. (enable_count is 0)
1708 : : * GPIO is disabled when it is not shared any more. (enable_count <= 1)
1709 : : */
1710 : 0 : static int regulator_ena_gpio_ctrl(struct regulator_dev *rdev, bool enable)
1711 : : {
1712 : 0 : struct regulator_enable_gpio *pin = rdev->ena_pin;
1713 : :
1714 [ # # ]: 0 : if (!pin)
1715 : : return -EINVAL;
1716 : :
1717 [ # # ]: 0 : if (enable) {
1718 : : /* Enable GPIO at initial use */
1719 [ # # ]: 0 : if (pin->enable_count == 0)
1720 : 0 : gpio_set_value_cansleep(pin->gpio,
1721 : 0 : !pin->ena_gpio_invert);
1722 : :
1723 : 0 : pin->enable_count++;
1724 : : } else {
1725 [ # # ]: 0 : if (pin->enable_count > 1) {
1726 : 0 : pin->enable_count--;
1727 : : return 0;
1728 : : }
1729 : :
1730 : : /* Disable GPIO if not used */
1731 [ # # ]: 0 : if (pin->enable_count <= 1) {
1732 : 0 : gpio_set_value_cansleep(pin->gpio,
1733 : 0 : pin->ena_gpio_invert);
1734 : 0 : pin->enable_count = 0;
1735 : : }
1736 : : }
1737 : :
1738 : : return 0;
1739 : : }
1740 : :
1741 : 0 : static int _regulator_do_enable(struct regulator_dev *rdev)
1742 : : {
1743 : : int ret, delay;
1744 : :
1745 : : /* Query before enabling in case configuration dependent. */
1746 : 0 : ret = _regulator_get_enable_time(rdev);
1747 [ # # ]: 0 : if (ret >= 0) {
1748 : : delay = ret;
1749 : : } else {
1750 : 0 : rdev_warn(rdev, "enable_time() failed: %d\n", ret);
1751 : : delay = 0;
1752 : : }
1753 : :
1754 : : trace_regulator_enable(rdev_get_name(rdev));
1755 : :
1756 [ # # ]: 0 : if (rdev->ena_pin) {
1757 : 0 : ret = regulator_ena_gpio_ctrl(rdev, true);
1758 [ # # ]: 0 : if (ret < 0)
1759 : : return ret;
1760 : 0 : rdev->ena_gpio_state = 1;
1761 [ # # ]: 0 : } else if (rdev->desc->ops->enable) {
1762 : 0 : ret = rdev->desc->ops->enable(rdev);
1763 [ # # ]: 0 : if (ret < 0)
1764 : : return ret;
1765 : : } else {
1766 : : return -EINVAL;
1767 : : }
1768 : :
1769 : : /* Allow the regulator to ramp; it would be useful to extend
1770 : : * this for bulk operations so that the regulators can ramp
1771 : : * together. */
1772 : : trace_regulator_enable_delay(rdev_get_name(rdev));
1773 : :
1774 : : /*
1775 : : * Delay for the requested amount of time as per the guidelines in:
1776 : : *
1777 : : * Documentation/timers/timers-howto.txt
1778 : : *
1779 : : * The assumption here is that regulators will never be enabled in
1780 : : * atomic context and therefore sleeping functions can be used.
1781 : : */
1782 [ # # ]: 0 : if (delay) {
1783 : 0 : unsigned int ms = delay / 1000;
1784 : 0 : unsigned int us = delay % 1000;
1785 : :
1786 [ # # ]: 0 : if (ms > 0) {
1787 : : /*
1788 : : * For small enough values, handle super-millisecond
1789 : : * delays in the usleep_range() call below.
1790 : : */
1791 [ # # ]: 0 : if (ms < 20)
1792 : 0 : us += ms * 1000;
1793 : : else
1794 : 0 : msleep(ms);
1795 : : }
1796 : :
1797 : : /*
1798 : : * Give the scheduler some room to coalesce with any other
1799 : : * wakeup sources. For delays shorter than 10 us, don't even
1800 : : * bother setting up high-resolution timers and just busy-
1801 : : * loop.
1802 : : */
1803 [ # # ]: 0 : if (us >= 10)
1804 : 0 : usleep_range(us, us + 100);
1805 : : else
1806 [ # # ][ # # ]: 0 : udelay(us);
1807 : : }
1808 : :
1809 : : trace_regulator_enable_complete(rdev_get_name(rdev));
1810 : :
1811 : : return 0;
1812 : : }
1813 : :
1814 : : /* locks held by regulator_enable() */
1815 : 0 : static int _regulator_enable(struct regulator_dev *rdev)
1816 : : {
1817 : : int ret;
1818 : :
1819 : : /* check voltage and requested load before enabling */
1820 [ # # ][ # # ]: 0 : if (rdev->constraints &&
1821 : 0 : (rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_DRMS))
1822 : 0 : drms_uA_update(rdev);
1823 : :
1824 [ # # ]: 0 : if (rdev->use_count == 0) {
1825 : : /* The regulator may on if it's not switchable or left on */
1826 : : ret = _regulator_is_enabled(rdev);
1827 [ # # ]: 0 : if (ret == -EINVAL || ret == 0) {
1828 [ # # ]: 0 : if (!_regulator_can_change_status(rdev))
1829 : : return -EPERM;
1830 : :
1831 : 0 : ret = _regulator_do_enable(rdev);
1832 [ # # ]: 0 : if (ret < 0)
1833 : : return ret;
1834 : :
1835 [ # # ]: 0 : } else if (ret < 0) {
1836 : 0 : rdev_err(rdev, "is_enabled() failed: %d\n", ret);
1837 : 0 : return ret;
1838 : : }
1839 : : /* Fallthrough on positive return values - already enabled */
1840 : : }
1841 : :
1842 : 0 : rdev->use_count++;
1843 : :
1844 : 0 : return 0;
1845 : : }
1846 : :
1847 : : /**
1848 : : * regulator_enable - enable regulator output
1849 : : * @regulator: regulator source
1850 : : *
1851 : : * Request that the regulator be enabled with the regulator output at
1852 : : * the predefined voltage or current value. Calls to regulator_enable()
1853 : : * must be balanced with calls to regulator_disable().
1854 : : *
1855 : : * NOTE: the output value can be set by other drivers, boot loader or may be
1856 : : * hardwired in the regulator.
1857 : : */
1858 : 0 : int regulator_enable(struct regulator *regulator)
1859 : : {
1860 : 0 : struct regulator_dev *rdev = regulator->rdev;
1861 : : int ret = 0;
1862 : :
1863 [ # # ]: 0 : if (regulator->always_on)
1864 : : return 0;
1865 : :
1866 [ # # ]: 0 : if (rdev->supply) {
1867 : 0 : ret = regulator_enable(rdev->supply);
1868 [ # # ]: 0 : if (ret != 0)
1869 : : return ret;
1870 : : }
1871 : :
1872 : 0 : mutex_lock(&rdev->mutex);
1873 : 0 : ret = _regulator_enable(rdev);
1874 : 0 : mutex_unlock(&rdev->mutex);
1875 : :
1876 [ # # ][ # # ]: 0 : if (ret != 0 && rdev->supply)
1877 : 0 : regulator_disable(rdev->supply);
1878 : :
1879 : 0 : return ret;
1880 : : }
1881 : : EXPORT_SYMBOL_GPL(regulator_enable);
1882 : :
1883 : 0 : static int _regulator_do_disable(struct regulator_dev *rdev)
1884 : : {
1885 : : int ret;
1886 : :
1887 : : trace_regulator_disable(rdev_get_name(rdev));
1888 : :
1889 [ # # ]: 0 : if (rdev->ena_pin) {
1890 : 0 : ret = regulator_ena_gpio_ctrl(rdev, false);
1891 [ # # ]: 0 : if (ret < 0)
1892 : : return ret;
1893 : 0 : rdev->ena_gpio_state = 0;
1894 : :
1895 [ # # ]: 0 : } else if (rdev->desc->ops->disable) {
1896 : 0 : ret = rdev->desc->ops->disable(rdev);
1897 [ # # ]: 0 : if (ret != 0)
1898 : : return ret;
1899 : : }
1900 : :
1901 : : trace_regulator_disable_complete(rdev_get_name(rdev));
1902 : :
1903 : : _notifier_call_chain(rdev, REGULATOR_EVENT_DISABLE,
1904 : : NULL);
1905 : 0 : return 0;
1906 : : }
1907 : :
1908 : : /* locks held by regulator_disable() */
1909 : 0 : static int _regulator_disable(struct regulator_dev *rdev)
1910 : : {
1911 : : int ret = 0;
1912 : :
1913 [ # # ][ # # ]: 0 : if (WARN(rdev->use_count <= 0,
1914 : : "unbalanced disables for %s\n", rdev_get_name(rdev)))
1915 : : return -EIO;
1916 : :
1917 : : /* are we the last user and permitted to disable ? */
1918 [ # # ][ # # ]: 0 : if (rdev->use_count == 1 &&
1919 [ # # ]: 0 : (rdev->constraints && !rdev->constraints->always_on)) {
1920 : :
1921 : : /* we are last user */
1922 [ # # ]: 0 : if (_regulator_can_change_status(rdev)) {
1923 : 0 : ret = _regulator_do_disable(rdev);
1924 [ # # ]: 0 : if (ret < 0) {
1925 : 0 : rdev_err(rdev, "failed to disable\n");
1926 : 0 : return ret;
1927 : : }
1928 : : }
1929 : :
1930 : 0 : rdev->use_count = 0;
1931 [ # # ]: 0 : } else if (rdev->use_count > 1) {
1932 : :
1933 [ # # ][ # # ]: 0 : if (rdev->constraints &&
1934 : 0 : (rdev->constraints->valid_ops_mask &
1935 : : REGULATOR_CHANGE_DRMS))
1936 : 0 : drms_uA_update(rdev);
1937 : :
1938 : 0 : rdev->use_count--;
1939 : : }
1940 : :
1941 : 0 : return ret;
1942 : : }
1943 : :
1944 : : /**
1945 : : * regulator_disable - disable regulator output
1946 : : * @regulator: regulator source
1947 : : *
1948 : : * Disable the regulator output voltage or current. Calls to
1949 : : * regulator_enable() must be balanced with calls to
1950 : : * regulator_disable().
1951 : : *
1952 : : * NOTE: this will only disable the regulator output if no other consumer
1953 : : * devices have it enabled, the regulator device supports disabling and
1954 : : * machine constraints permit this operation.
1955 : : */
1956 : 0 : int regulator_disable(struct regulator *regulator)
1957 : : {
1958 : 0 : struct regulator_dev *rdev = regulator->rdev;
1959 : : int ret = 0;
1960 : :
1961 [ # # ]: 0 : if (regulator->always_on)
1962 : : return 0;
1963 : :
1964 : 0 : mutex_lock(&rdev->mutex);
1965 : 0 : ret = _regulator_disable(rdev);
1966 : 0 : mutex_unlock(&rdev->mutex);
1967 : :
1968 [ # # ][ # # ]: 0 : if (ret == 0 && rdev->supply)
1969 : 0 : regulator_disable(rdev->supply);
1970 : :
1971 : 0 : return ret;
1972 : : }
1973 : : EXPORT_SYMBOL_GPL(regulator_disable);
1974 : :
1975 : : /* locks held by regulator_force_disable() */
1976 : 0 : static int _regulator_force_disable(struct regulator_dev *rdev)
1977 : : {
1978 : : int ret = 0;
1979 : :
1980 : : /* force disable */
1981 [ # # ]: 0 : if (rdev->desc->ops->disable) {
1982 : : /* ah well, who wants to live forever... */
1983 : 0 : ret = rdev->desc->ops->disable(rdev);
1984 [ # # ]: 0 : if (ret < 0) {
1985 : 0 : rdev_err(rdev, "failed to force disable\n");
1986 : 0 : return ret;
1987 : : }
1988 : : /* notify other consumers that power has been forced off */
1989 : : _notifier_call_chain(rdev, REGULATOR_EVENT_FORCE_DISABLE |
1990 : : REGULATOR_EVENT_DISABLE, NULL);
1991 : : }
1992 : :
1993 : 0 : return ret;
1994 : : }
1995 : :
1996 : : /**
1997 : : * regulator_force_disable - force disable regulator output
1998 : : * @regulator: regulator source
1999 : : *
2000 : : * Forcibly disable the regulator output voltage or current.
2001 : : * NOTE: this *will* disable the regulator output even if other consumer
2002 : : * devices have it enabled. This should be used for situations when device
2003 : : * damage will likely occur if the regulator is not disabled (e.g. over temp).
2004 : : */
2005 : 0 : int regulator_force_disable(struct regulator *regulator)
2006 : : {
2007 : 0 : struct regulator_dev *rdev = regulator->rdev;
2008 : : int ret;
2009 : :
2010 : 0 : mutex_lock(&rdev->mutex);
2011 : 0 : regulator->uA_load = 0;
2012 : 0 : ret = _regulator_force_disable(regulator->rdev);
2013 : 0 : mutex_unlock(&rdev->mutex);
2014 : :
2015 [ # # ]: 0 : if (rdev->supply)
2016 [ # # ]: 0 : while (rdev->open_count--)
2017 : 0 : regulator_disable(rdev->supply);
2018 : :
2019 : 0 : return ret;
2020 : : }
2021 : : EXPORT_SYMBOL_GPL(regulator_force_disable);
2022 : :
2023 : 0 : static void regulator_disable_work(struct work_struct *work)
2024 : : {
2025 : 0 : struct regulator_dev *rdev = container_of(work, struct regulator_dev,
2026 : : disable_work.work);
2027 : : int count, i, ret;
2028 : :
2029 : 0 : mutex_lock(&rdev->mutex);
2030 : :
2031 [ # # ]: 0 : BUG_ON(!rdev->deferred_disables);
2032 : :
2033 : : count = rdev->deferred_disables;
2034 : 0 : rdev->deferred_disables = 0;
2035 : :
2036 [ # # ]: 0 : for (i = 0; i < count; i++) {
2037 : 0 : ret = _regulator_disable(rdev);
2038 [ # # ]: 0 : if (ret != 0)
2039 : 0 : rdev_err(rdev, "Deferred disable failed: %d\n", ret);
2040 : : }
2041 : :
2042 : 0 : mutex_unlock(&rdev->mutex);
2043 : :
2044 [ # # ]: 0 : if (rdev->supply) {
2045 [ # # ]: 0 : for (i = 0; i < count; i++) {
2046 : 0 : ret = regulator_disable(rdev->supply);
2047 [ # # ]: 0 : if (ret != 0) {
2048 : 0 : rdev_err(rdev,
2049 : : "Supply disable failed: %d\n", ret);
2050 : : }
2051 : : }
2052 : : }
2053 : 0 : }
2054 : :
2055 : : /**
2056 : : * regulator_disable_deferred - disable regulator output with delay
2057 : : * @regulator: regulator source
2058 : : * @ms: miliseconds until the regulator is disabled
2059 : : *
2060 : : * Execute regulator_disable() on the regulator after a delay. This
2061 : : * is intended for use with devices that require some time to quiesce.
2062 : : *
2063 : : * NOTE: this will only disable the regulator output if no other consumer
2064 : : * devices have it enabled, the regulator device supports disabling and
2065 : : * machine constraints permit this operation.
2066 : : */
2067 : 0 : int regulator_disable_deferred(struct regulator *regulator, int ms)
2068 : : {
2069 : 0 : struct regulator_dev *rdev = regulator->rdev;
2070 : : int ret;
2071 : :
2072 [ # # ]: 0 : if (regulator->always_on)
2073 : : return 0;
2074 : :
2075 [ # # ]: 0 : if (!ms)
2076 : 0 : return regulator_disable(regulator);
2077 : :
2078 : 0 : mutex_lock(&rdev->mutex);
2079 : 0 : rdev->deferred_disables++;
2080 : 0 : mutex_unlock(&rdev->mutex);
2081 : :
2082 : 0 : ret = queue_delayed_work(system_power_efficient_wq,
2083 : : &rdev->disable_work,
2084 : : msecs_to_jiffies(ms));
2085 [ # # ]: 0 : if (ret < 0)
2086 : 0 : return ret;
2087 : : else
2088 : : return 0;
2089 : : }
2090 : : EXPORT_SYMBOL_GPL(regulator_disable_deferred);
2091 : :
2092 : : static int _regulator_is_enabled(struct regulator_dev *rdev)
2093 : : {
2094 : : /* A GPIO control always takes precedence */
2095 [ # # ][ # # ]: 0 : if (rdev->ena_pin)
[ # # # # ]
[ # # ][ # # ]
[ # # # # ]
2096 : 0 : return rdev->ena_gpio_state;
2097 : :
2098 : : /* If we don't know then assume that the regulator is always on */
2099 [ # # ][ # # ]: 0 : if (!rdev->desc->ops->is_enabled)
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
2100 : : return 1;
2101 : :
2102 : 0 : return rdev->desc->ops->is_enabled(rdev);
2103 : : }
2104 : :
2105 : : /**
2106 : : * regulator_is_enabled - is the regulator output enabled
2107 : : * @regulator: regulator source
2108 : : *
2109 : : * Returns positive if the regulator driver backing the source/client
2110 : : * has requested that the device be enabled, zero if it hasn't, else a
2111 : : * negative errno code.
2112 : : *
2113 : : * Note that the device backing this regulator handle can have multiple
2114 : : * users, so it might be enabled even if regulator_enable() was never
2115 : : * called for this particular source.
2116 : : */
2117 : 0 : int regulator_is_enabled(struct regulator *regulator)
2118 : : {
2119 : : int ret;
2120 : :
2121 [ # # ]: 0 : if (regulator->always_on)
2122 : : return 1;
2123 : :
2124 : 0 : mutex_lock(®ulator->rdev->mutex);
2125 : 0 : ret = _regulator_is_enabled(regulator->rdev);
2126 : 0 : mutex_unlock(®ulator->rdev->mutex);
2127 : :
2128 : 0 : return ret;
2129 : : }
2130 : : EXPORT_SYMBOL_GPL(regulator_is_enabled);
2131 : :
2132 : : /**
2133 : : * regulator_can_change_voltage - check if regulator can change voltage
2134 : : * @regulator: regulator source
2135 : : *
2136 : : * Returns positive if the regulator driver backing the source/client
2137 : : * can change its voltage, false otherwise. Usefull for detecting fixed
2138 : : * or dummy regulators and disabling voltage change logic in the client
2139 : : * driver.
2140 : : */
2141 : 0 : int regulator_can_change_voltage(struct regulator *regulator)
2142 : : {
2143 : 0 : struct regulator_dev *rdev = regulator->rdev;
2144 : :
2145 [ # # ][ # # ]: 0 : if (rdev->constraints &&
2146 : 0 : (rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) {
2147 [ # # ]: 0 : if (rdev->desc->n_voltages - rdev->desc->linear_min_sel > 1)
2148 : : return 1;
2149 : :
2150 [ # # ][ # # ]: 0 : if (rdev->desc->continuous_voltage_range &&
2151 [ # # ][ # # ]: 0 : rdev->constraints->min_uV && rdev->constraints->max_uV &&
2152 : : rdev->constraints->min_uV != rdev->constraints->max_uV)
2153 : : return 1;
2154 : : }
2155 : :
2156 : 0 : return 0;
2157 : : }
2158 : : EXPORT_SYMBOL_GPL(regulator_can_change_voltage);
2159 : :
2160 : : /**
2161 : : * regulator_count_voltages - count regulator_list_voltage() selectors
2162 : : * @regulator: regulator source
2163 : : *
2164 : : * Returns number of selectors, or negative errno. Selectors are
2165 : : * numbered starting at zero, and typically correspond to bitfields
2166 : : * in hardware registers.
2167 : : */
2168 : 0 : int regulator_count_voltages(struct regulator *regulator)
2169 : : {
2170 : 0 : struct regulator_dev *rdev = regulator->rdev;
2171 : :
2172 [ # # ][ # # ]: 0 : return rdev->desc->n_voltages ? : -EINVAL;
2173 : : }
2174 : : EXPORT_SYMBOL_GPL(regulator_count_voltages);
2175 : :
2176 : : /**
2177 : : * regulator_list_voltage - enumerate supported voltages
2178 : : * @regulator: regulator source
2179 : : * @selector: identify voltage to list
2180 : : * Context: can sleep
2181 : : *
2182 : : * Returns a voltage that can be passed to @regulator_set_voltage(),
2183 : : * zero if this selector code can't be used on this system, or a
2184 : : * negative errno.
2185 : : */
2186 : 0 : int regulator_list_voltage(struct regulator *regulator, unsigned selector)
2187 : : {
2188 : 0 : struct regulator_dev *rdev = regulator->rdev;
2189 : 0 : struct regulator_ops *ops = rdev->desc->ops;
2190 : : int ret;
2191 : :
2192 [ # # ][ # # ]: 0 : if (rdev->desc->fixed_uV && rdev->desc->n_voltages == 1 && !selector)
[ # # ]
2193 : : return rdev->desc->fixed_uV;
2194 : :
2195 [ # # ][ # # ]: 0 : if (!ops->list_voltage || selector >= rdev->desc->n_voltages)
2196 : : return -EINVAL;
2197 : :
2198 : 0 : mutex_lock(&rdev->mutex);
2199 : 0 : ret = ops->list_voltage(rdev, selector);
2200 : 0 : mutex_unlock(&rdev->mutex);
2201 : :
2202 [ # # ]: 0 : if (ret > 0) {
2203 [ # # ]: 0 : if (ret < rdev->constraints->min_uV)
2204 : : ret = 0;
2205 [ # # ]: 0 : else if (ret > rdev->constraints->max_uV)
2206 : : ret = 0;
2207 : : }
2208 : :
2209 : 0 : return ret;
2210 : : }
2211 : : EXPORT_SYMBOL_GPL(regulator_list_voltage);
2212 : :
2213 : : /**
2214 : : * regulator_get_linear_step - return the voltage step size between VSEL values
2215 : : * @regulator: regulator source
2216 : : *
2217 : : * Returns the voltage step size between VSEL values for linear
2218 : : * regulators, or return 0 if the regulator isn't a linear regulator.
2219 : : */
2220 : 0 : unsigned int regulator_get_linear_step(struct regulator *regulator)
2221 : : {
2222 : 0 : struct regulator_dev *rdev = regulator->rdev;
2223 : :
2224 : 0 : return rdev->desc->uV_step;
2225 : : }
2226 : : EXPORT_SYMBOL_GPL(regulator_get_linear_step);
2227 : :
2228 : : /**
2229 : : * regulator_is_supported_voltage - check if a voltage range can be supported
2230 : : *
2231 : : * @regulator: Regulator to check.
2232 : : * @min_uV: Minimum required voltage in uV.
2233 : : * @max_uV: Maximum required voltage in uV.
2234 : : *
2235 : : * Returns a boolean or a negative error code.
2236 : : */
2237 : 0 : int regulator_is_supported_voltage(struct regulator *regulator,
2238 : : int min_uV, int max_uV)
2239 : : {
2240 : 0 : struct regulator_dev *rdev = regulator->rdev;
2241 : : int i, voltages, ret;
2242 : :
2243 : : /* If we can't change voltage check the current voltage */
2244 [ # # ]: 0 : if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) {
2245 : 0 : ret = regulator_get_voltage(regulator);
2246 [ # # ]: 0 : if (ret >= 0)
2247 : 0 : return (min_uV <= ret && ret <= max_uV);
2248 : : else
2249 : : return ret;
2250 : : }
2251 : :
2252 : : /* Any voltage within constrains range is fine? */
2253 [ # # ]: 0 : if (rdev->desc->continuous_voltage_range)
2254 [ # # ][ # # ]: 0 : return min_uV >= rdev->constraints->min_uV &&
2255 : 0 : max_uV <= rdev->constraints->max_uV;
2256 : :
2257 : : ret = regulator_count_voltages(regulator);
2258 [ # # ]: 0 : if (ret < 0)
2259 : : return ret;
2260 : : voltages = ret;
2261 : :
2262 [ # # ]: 0 : for (i = 0; i < voltages; i++) {
2263 : 0 : ret = regulator_list_voltage(regulator, i);
2264 : :
2265 [ # # ]: 0 : if (ret >= min_uV && ret <= max_uV)
2266 : : return 1;
2267 : : }
2268 : :
2269 : : return 0;
2270 : : }
2271 : : EXPORT_SYMBOL_GPL(regulator_is_supported_voltage);
2272 : :
2273 : 0 : static int _regulator_do_set_voltage(struct regulator_dev *rdev,
2274 : : int min_uV, int max_uV)
2275 : : {
2276 : : int ret;
2277 : : int delay = 0;
2278 : : int best_val = 0;
2279 : : unsigned int selector;
2280 : : int old_selector = -1;
2281 : :
2282 : : trace_regulator_set_voltage(rdev_get_name(rdev), min_uV, max_uV);
2283 : :
2284 : 0 : min_uV += rdev->constraints->uV_offset;
2285 : 0 : max_uV += rdev->constraints->uV_offset;
2286 : :
2287 : : /*
2288 : : * If we can't obtain the old selector there is not enough
2289 : : * info to call set_voltage_time_sel().
2290 : : */
2291 [ # # ][ # # ]: 0 : if (_regulator_is_enabled(rdev) &&
2292 [ # # ]: 0 : rdev->desc->ops->set_voltage_time_sel &&
2293 : 0 : rdev->desc->ops->get_voltage_sel) {
2294 : 0 : old_selector = rdev->desc->ops->get_voltage_sel(rdev);
2295 [ # # ]: 0 : if (old_selector < 0)
2296 : : return old_selector;
2297 : : }
2298 : :
2299 [ # # ]: 0 : if (rdev->desc->ops->set_voltage) {
2300 : 0 : ret = rdev->desc->ops->set_voltage(rdev, min_uV, max_uV,
2301 : : &selector);
2302 : :
2303 [ # # ]: 0 : if (ret >= 0) {
2304 [ # # ]: 0 : if (rdev->desc->ops->list_voltage)
2305 : 0 : best_val = rdev->desc->ops->list_voltage(rdev,
2306 : : selector);
2307 : : else
2308 : 0 : best_val = _regulator_get_voltage(rdev);
2309 : : }
2310 : :
2311 [ # # ]: 0 : } else if (rdev->desc->ops->set_voltage_sel) {
2312 [ # # ]: 0 : if (rdev->desc->ops->map_voltage) {
2313 : 0 : ret = rdev->desc->ops->map_voltage(rdev, min_uV,
2314 : : max_uV);
2315 : : } else {
2316 [ # # ]: 0 : if (rdev->desc->ops->list_voltage ==
2317 : : regulator_list_voltage_linear)
2318 : 0 : ret = regulator_map_voltage_linear(rdev,
2319 : : min_uV, max_uV);
2320 : : else
2321 : 0 : ret = regulator_map_voltage_iterate(rdev,
2322 : : min_uV, max_uV);
2323 : : }
2324 : :
2325 [ # # ]: 0 : if (ret >= 0) {
2326 : 0 : best_val = rdev->desc->ops->list_voltage(rdev, ret);
2327 [ # # ]: 0 : if (min_uV <= best_val && max_uV >= best_val) {
2328 : 0 : selector = ret;
2329 [ # # ]: 0 : if (old_selector == selector)
2330 : : ret = 0;
2331 : : else
2332 : 0 : ret = rdev->desc->ops->set_voltage_sel(
2333 : : rdev, ret);
2334 : : } else {
2335 : : ret = -EINVAL;
2336 : : }
2337 : : }
2338 : : } else {
2339 : : ret = -EINVAL;
2340 : : }
2341 : :
2342 : : /* Call set_voltage_time_sel if successfully obtained old_selector */
2343 [ # # ][ # # ]: 0 : if (ret == 0 && !rdev->constraints->ramp_disable && old_selector >= 0
[ # # ]
2344 [ # # ]: 0 : && old_selector != selector) {
2345 : :
2346 : 0 : delay = rdev->desc->ops->set_voltage_time_sel(rdev,
2347 : : old_selector, selector);
2348 [ # # ]: 0 : if (delay < 0) {
2349 : 0 : rdev_warn(rdev, "set_voltage_time_sel() failed: %d\n",
2350 : : delay);
2351 : : delay = 0;
2352 : : }
2353 : :
2354 : : /* Insert any necessary delays */
2355 [ # # ]: 0 : if (delay >= 1000) {
2356 [ # # ][ # # ]: 0 : mdelay(delay / 1000);
[ # # ][ # # ]
[ # # ]
2357 [ # # ][ # # ]: 0 : udelay(delay % 1000);
2358 [ # # ]: 0 : } else if (delay) {
2359 [ # # ][ # # ]: 0 : udelay(delay);
2360 : : }
2361 : : }
2362 : :
2363 [ # # ]: 0 : if (ret == 0 && best_val >= 0) {
2364 : : unsigned long data = best_val;
2365 : :
2366 : 0 : _notifier_call_chain(rdev, REGULATOR_EVENT_VOLTAGE_CHANGE,
2367 : : (void *)data);
2368 : : }
2369 : :
2370 : 0 : trace_regulator_set_voltage_complete(rdev_get_name(rdev), best_val);
2371 : :
2372 : 0 : return ret;
2373 : : }
2374 : :
2375 : : /**
2376 : : * regulator_set_voltage - set regulator output voltage
2377 : : * @regulator: regulator source
2378 : : * @min_uV: Minimum required voltage in uV
2379 : : * @max_uV: Maximum acceptable voltage in uV
2380 : : *
2381 : : * Sets a voltage regulator to the desired output voltage. This can be set
2382 : : * during any regulator state. IOW, regulator can be disabled or enabled.
2383 : : *
2384 : : * If the regulator is enabled then the voltage will change to the new value
2385 : : * immediately otherwise if the regulator is disabled the regulator will
2386 : : * output at the new voltage when enabled.
2387 : : *
2388 : : * NOTE: If the regulator is shared between several devices then the lowest
2389 : : * request voltage that meets the system constraints will be used.
2390 : : * Regulator system constraints must be set for this regulator before
2391 : : * calling this function otherwise this call will fail.
2392 : : */
2393 : 0 : int regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV)
2394 : : {
2395 : 0 : struct regulator_dev *rdev = regulator->rdev;
2396 : : int ret = 0;
2397 : : int old_min_uV, old_max_uV;
2398 : :
2399 : 0 : mutex_lock(&rdev->mutex);
2400 : :
2401 : : /* If we're setting the same range as last time the change
2402 : : * should be a noop (some cpufreq implementations use the same
2403 : : * voltage for multiple frequencies, for example).
2404 : : */
2405 [ # # ][ # # ]: 0 : if (regulator->min_uV == min_uV && regulator->max_uV == max_uV)
2406 : : goto out;
2407 : :
2408 : : /* sanity check */
2409 [ # # ][ # # ]: 0 : if (!rdev->desc->ops->set_voltage &&
2410 : 0 : !rdev->desc->ops->set_voltage_sel) {
2411 : : ret = -EINVAL;
2412 : : goto out;
2413 : : }
2414 : :
2415 : : /* constraints check */
2416 : 0 : ret = regulator_check_voltage(rdev, &min_uV, &max_uV);
2417 [ # # ]: 0 : if (ret < 0)
2418 : : goto out;
2419 : :
2420 : : /* restore original values in case of error */
2421 : 0 : old_min_uV = regulator->min_uV;
2422 : 0 : old_max_uV = regulator->max_uV;
2423 : 0 : regulator->min_uV = min_uV;
2424 : 0 : regulator->max_uV = max_uV;
2425 : :
2426 : 0 : ret = regulator_check_consumers(rdev, &min_uV, &max_uV);
2427 [ # # ]: 0 : if (ret < 0)
2428 : : goto out2;
2429 : :
2430 : 0 : ret = _regulator_do_set_voltage(rdev, min_uV, max_uV);
2431 [ # # ]: 0 : if (ret < 0)
2432 : : goto out2;
2433 : :
2434 : : out:
2435 : 0 : mutex_unlock(&rdev->mutex);
2436 : 0 : return ret;
2437 : : out2:
2438 : 0 : regulator->min_uV = old_min_uV;
2439 : 0 : regulator->max_uV = old_max_uV;
2440 : 0 : mutex_unlock(&rdev->mutex);
2441 : 0 : return ret;
2442 : : }
2443 : : EXPORT_SYMBOL_GPL(regulator_set_voltage);
2444 : :
2445 : : /**
2446 : : * regulator_set_voltage_time - get raise/fall time
2447 : : * @regulator: regulator source
2448 : : * @old_uV: starting voltage in microvolts
2449 : : * @new_uV: target voltage in microvolts
2450 : : *
2451 : : * Provided with the starting and ending voltage, this function attempts to
2452 : : * calculate the time in microseconds required to rise or fall to this new
2453 : : * voltage.
2454 : : */
2455 : 0 : int regulator_set_voltage_time(struct regulator *regulator,
2456 : : int old_uV, int new_uV)
2457 : : {
2458 : 0 : struct regulator_dev *rdev = regulator->rdev;
2459 : 0 : struct regulator_ops *ops = rdev->desc->ops;
2460 : : int old_sel = -1;
2461 : : int new_sel = -1;
2462 : : int voltage;
2463 : : int i;
2464 : :
2465 : : /* Currently requires operations to do this */
2466 [ # # ][ # # ]: 0 : if (!ops->list_voltage || !ops->set_voltage_time_sel
2467 [ # # ]: 0 : || !rdev->desc->n_voltages)
2468 : : return -EINVAL;
2469 : :
2470 [ # # ]: 0 : for (i = 0; i < rdev->desc->n_voltages; i++) {
2471 : : /* We only look for exact voltage matches here */
2472 : 0 : voltage = regulator_list_voltage(regulator, i);
2473 [ # # ]: 0 : if (voltage < 0)
2474 : : return -EINVAL;
2475 [ # # ]: 0 : if (voltage == 0)
2476 : 0 : continue;
2477 [ # # ]: 0 : if (voltage == old_uV)
2478 : : old_sel = i;
2479 [ # # ]: 0 : if (voltage == new_uV)
2480 : : new_sel = i;
2481 : : }
2482 : :
2483 [ # # ]: 0 : if (old_sel < 0 || new_sel < 0)
2484 : : return -EINVAL;
2485 : :
2486 : 0 : return ops->set_voltage_time_sel(rdev, old_sel, new_sel);
2487 : : }
2488 : : EXPORT_SYMBOL_GPL(regulator_set_voltage_time);
2489 : :
2490 : : /**
2491 : : * regulator_set_voltage_time_sel - get raise/fall time
2492 : : * @rdev: regulator source device
2493 : : * @old_selector: selector for starting voltage
2494 : : * @new_selector: selector for target voltage
2495 : : *
2496 : : * Provided with the starting and target voltage selectors, this function
2497 : : * returns time in microseconds required to rise or fall to this new voltage
2498 : : *
2499 : : * Drivers providing ramp_delay in regulation_constraints can use this as their
2500 : : * set_voltage_time_sel() operation.
2501 : : */
2502 : 0 : int regulator_set_voltage_time_sel(struct regulator_dev *rdev,
2503 : : unsigned int old_selector,
2504 : : unsigned int new_selector)
2505 : : {
2506 : : unsigned int ramp_delay = 0;
2507 : : int old_volt, new_volt;
2508 : :
2509 [ # # ]: 0 : if (rdev->constraints->ramp_delay)
2510 : : ramp_delay = rdev->constraints->ramp_delay;
2511 [ # # ]: 0 : else if (rdev->desc->ramp_delay)
2512 : : ramp_delay = rdev->desc->ramp_delay;
2513 : :
2514 [ # # ]: 0 : if (ramp_delay == 0) {
2515 : 0 : rdev_warn(rdev, "ramp_delay not set\n");
2516 : 0 : return 0;
2517 : : }
2518 : :
2519 : : /* sanity check */
2520 [ # # ]: 0 : if (!rdev->desc->ops->list_voltage)
2521 : : return -EINVAL;
2522 : :
2523 : 0 : old_volt = rdev->desc->ops->list_voltage(rdev, old_selector);
2524 : 0 : new_volt = rdev->desc->ops->list_voltage(rdev, new_selector);
2525 : :
2526 : 0 : return DIV_ROUND_UP(abs(new_volt - old_volt), ramp_delay);
2527 : : }
2528 : : EXPORT_SYMBOL_GPL(regulator_set_voltage_time_sel);
2529 : :
2530 : : /**
2531 : : * regulator_sync_voltage - re-apply last regulator output voltage
2532 : : * @regulator: regulator source
2533 : : *
2534 : : * Re-apply the last configured voltage. This is intended to be used
2535 : : * where some external control source the consumer is cooperating with
2536 : : * has caused the configured voltage to change.
2537 : : */
2538 : 0 : int regulator_sync_voltage(struct regulator *regulator)
2539 : : {
2540 : 0 : struct regulator_dev *rdev = regulator->rdev;
2541 : : int ret, min_uV, max_uV;
2542 : :
2543 : 0 : mutex_lock(&rdev->mutex);
2544 : :
2545 [ # # ][ # # ]: 0 : if (!rdev->desc->ops->set_voltage &&
2546 : 0 : !rdev->desc->ops->set_voltage_sel) {
2547 : : ret = -EINVAL;
2548 : : goto out;
2549 : : }
2550 : :
2551 : : /* This is only going to work if we've had a voltage configured. */
2552 [ # # ][ # # ]: 0 : if (!regulator->min_uV && !regulator->max_uV) {
2553 : : ret = -EINVAL;
2554 : : goto out;
2555 : : }
2556 : :
2557 : 0 : min_uV = regulator->min_uV;
2558 : 0 : max_uV = regulator->max_uV;
2559 : :
2560 : : /* This should be a paranoia check... */
2561 : 0 : ret = regulator_check_voltage(rdev, &min_uV, &max_uV);
2562 [ # # ]: 0 : if (ret < 0)
2563 : : goto out;
2564 : :
2565 : 0 : ret = regulator_check_consumers(rdev, &min_uV, &max_uV);
2566 [ # # ]: 0 : if (ret < 0)
2567 : : goto out;
2568 : :
2569 : 0 : ret = _regulator_do_set_voltage(rdev, min_uV, max_uV);
2570 : :
2571 : : out:
2572 : 0 : mutex_unlock(&rdev->mutex);
2573 : 0 : return ret;
2574 : : }
2575 : : EXPORT_SYMBOL_GPL(regulator_sync_voltage);
2576 : :
2577 : 0 : static int _regulator_get_voltage(struct regulator_dev *rdev)
2578 : : {
2579 : : int sel, ret;
2580 : :
2581 [ # # ]: 0 : if (rdev->desc->ops->get_voltage_sel) {
2582 : 0 : sel = rdev->desc->ops->get_voltage_sel(rdev);
2583 [ # # ]: 0 : if (sel < 0)
2584 : : return sel;
2585 : 0 : ret = rdev->desc->ops->list_voltage(rdev, sel);
2586 [ # # ]: 0 : } else if (rdev->desc->ops->get_voltage) {
2587 : 0 : ret = rdev->desc->ops->get_voltage(rdev);
2588 [ # # ]: 0 : } else if (rdev->desc->ops->list_voltage) {
2589 : 0 : ret = rdev->desc->ops->list_voltage(rdev, 0);
2590 [ # # ][ # # ]: 0 : } else if (rdev->desc->fixed_uV && (rdev->desc->n_voltages == 1)) {
2591 : : ret = rdev->desc->fixed_uV;
2592 : : } else {
2593 : : return -EINVAL;
2594 : : }
2595 : :
2596 [ # # ]: 0 : if (ret < 0)
2597 : : return ret;
2598 : 0 : return ret - rdev->constraints->uV_offset;
2599 : : }
2600 : :
2601 : : /**
2602 : : * regulator_get_voltage - get regulator output voltage
2603 : : * @regulator: regulator source
2604 : : *
2605 : : * This returns the current regulator voltage in uV.
2606 : : *
2607 : : * NOTE: If the regulator is disabled it will return the voltage value. This
2608 : : * function should not be used to determine regulator state.
2609 : : */
2610 : 0 : int regulator_get_voltage(struct regulator *regulator)
2611 : : {
2612 : : int ret;
2613 : :
2614 : 0 : mutex_lock(®ulator->rdev->mutex);
2615 : :
2616 : 0 : ret = _regulator_get_voltage(regulator->rdev);
2617 : :
2618 : 0 : mutex_unlock(®ulator->rdev->mutex);
2619 : :
2620 : 0 : return ret;
2621 : : }
2622 : : EXPORT_SYMBOL_GPL(regulator_get_voltage);
2623 : :
2624 : : /**
2625 : : * regulator_set_current_limit - set regulator output current limit
2626 : : * @regulator: regulator source
2627 : : * @min_uA: Minimum supported current in uA
2628 : : * @max_uA: Maximum supported current in uA
2629 : : *
2630 : : * Sets current sink to the desired output current. This can be set during
2631 : : * any regulator state. IOW, regulator can be disabled or enabled.
2632 : : *
2633 : : * If the regulator is enabled then the current will change to the new value
2634 : : * immediately otherwise if the regulator is disabled the regulator will
2635 : : * output at the new current when enabled.
2636 : : *
2637 : : * NOTE: Regulator system constraints must be set for this regulator before
2638 : : * calling this function otherwise this call will fail.
2639 : : */
2640 : 0 : int regulator_set_current_limit(struct regulator *regulator,
2641 : : int min_uA, int max_uA)
2642 : : {
2643 : 0 : struct regulator_dev *rdev = regulator->rdev;
2644 : : int ret;
2645 : :
2646 : 0 : mutex_lock(&rdev->mutex);
2647 : :
2648 : : /* sanity check */
2649 [ # # ]: 0 : if (!rdev->desc->ops->set_current_limit) {
2650 : : ret = -EINVAL;
2651 : : goto out;
2652 : : }
2653 : :
2654 : : /* constraints check */
2655 : 0 : ret = regulator_check_current_limit(rdev, &min_uA, &max_uA);
2656 [ # # ]: 0 : if (ret < 0)
2657 : : goto out;
2658 : :
2659 : 0 : ret = rdev->desc->ops->set_current_limit(rdev, min_uA, max_uA);
2660 : : out:
2661 : 0 : mutex_unlock(&rdev->mutex);
2662 : 0 : return ret;
2663 : : }
2664 : : EXPORT_SYMBOL_GPL(regulator_set_current_limit);
2665 : :
2666 : 0 : static int _regulator_get_current_limit(struct regulator_dev *rdev)
2667 : : {
2668 : : int ret;
2669 : :
2670 : 0 : mutex_lock(&rdev->mutex);
2671 : :
2672 : : /* sanity check */
2673 [ # # ]: 0 : if (!rdev->desc->ops->get_current_limit) {
2674 : : ret = -EINVAL;
2675 : : goto out;
2676 : : }
2677 : :
2678 : 0 : ret = rdev->desc->ops->get_current_limit(rdev);
2679 : : out:
2680 : 0 : mutex_unlock(&rdev->mutex);
2681 : 0 : return ret;
2682 : : }
2683 : :
2684 : : /**
2685 : : * regulator_get_current_limit - get regulator output current
2686 : : * @regulator: regulator source
2687 : : *
2688 : : * This returns the current supplied by the specified current sink in uA.
2689 : : *
2690 : : * NOTE: If the regulator is disabled it will return the current value. This
2691 : : * function should not be used to determine regulator state.
2692 : : */
2693 : 0 : int regulator_get_current_limit(struct regulator *regulator)
2694 : : {
2695 : 0 : return _regulator_get_current_limit(regulator->rdev);
2696 : : }
2697 : : EXPORT_SYMBOL_GPL(regulator_get_current_limit);
2698 : :
2699 : : /**
2700 : : * regulator_set_mode - set regulator operating mode
2701 : : * @regulator: regulator source
2702 : : * @mode: operating mode - one of the REGULATOR_MODE constants
2703 : : *
2704 : : * Set regulator operating mode to increase regulator efficiency or improve
2705 : : * regulation performance.
2706 : : *
2707 : : * NOTE: Regulator system constraints must be set for this regulator before
2708 : : * calling this function otherwise this call will fail.
2709 : : */
2710 : 0 : int regulator_set_mode(struct regulator *regulator, unsigned int mode)
2711 : : {
2712 : 0 : struct regulator_dev *rdev = regulator->rdev;
2713 : : int ret;
2714 : : int regulator_curr_mode;
2715 : :
2716 : 0 : mutex_lock(&rdev->mutex);
2717 : :
2718 : : /* sanity check */
2719 [ # # ]: 0 : if (!rdev->desc->ops->set_mode) {
2720 : : ret = -EINVAL;
2721 : : goto out;
2722 : : }
2723 : :
2724 : : /* return if the same mode is requested */
2725 [ # # ]: 0 : if (rdev->desc->ops->get_mode) {
2726 : 0 : regulator_curr_mode = rdev->desc->ops->get_mode(rdev);
2727 [ # # ]: 0 : if (regulator_curr_mode == mode) {
2728 : : ret = 0;
2729 : : goto out;
2730 : : }
2731 : : }
2732 : :
2733 : : /* constraints check */
2734 : 0 : ret = regulator_mode_constrain(rdev, &mode);
2735 [ # # ]: 0 : if (ret < 0)
2736 : : goto out;
2737 : :
2738 : 0 : ret = rdev->desc->ops->set_mode(rdev, mode);
2739 : : out:
2740 : 0 : mutex_unlock(&rdev->mutex);
2741 : 0 : return ret;
2742 : : }
2743 : : EXPORT_SYMBOL_GPL(regulator_set_mode);
2744 : :
2745 : 0 : static unsigned int _regulator_get_mode(struct regulator_dev *rdev)
2746 : : {
2747 : : int ret;
2748 : :
2749 : 0 : mutex_lock(&rdev->mutex);
2750 : :
2751 : : /* sanity check */
2752 [ # # ]: 0 : if (!rdev->desc->ops->get_mode) {
2753 : : ret = -EINVAL;
2754 : : goto out;
2755 : : }
2756 : :
2757 : 0 : ret = rdev->desc->ops->get_mode(rdev);
2758 : : out:
2759 : 0 : mutex_unlock(&rdev->mutex);
2760 : 0 : return ret;
2761 : : }
2762 : :
2763 : : /**
2764 : : * regulator_get_mode - get regulator operating mode
2765 : : * @regulator: regulator source
2766 : : *
2767 : : * Get the current regulator operating mode.
2768 : : */
2769 : 0 : unsigned int regulator_get_mode(struct regulator *regulator)
2770 : : {
2771 : 0 : return _regulator_get_mode(regulator->rdev);
2772 : : }
2773 : : EXPORT_SYMBOL_GPL(regulator_get_mode);
2774 : :
2775 : : /**
2776 : : * regulator_set_optimum_mode - set regulator optimum operating mode
2777 : : * @regulator: regulator source
2778 : : * @uA_load: load current
2779 : : *
2780 : : * Notifies the regulator core of a new device load. This is then used by
2781 : : * DRMS (if enabled by constraints) to set the most efficient regulator
2782 : : * operating mode for the new regulator loading.
2783 : : *
2784 : : * Consumer devices notify their supply regulator of the maximum power
2785 : : * they will require (can be taken from device datasheet in the power
2786 : : * consumption tables) when they change operational status and hence power
2787 : : * state. Examples of operational state changes that can affect power
2788 : : * consumption are :-
2789 : : *
2790 : : * o Device is opened / closed.
2791 : : * o Device I/O is about to begin or has just finished.
2792 : : * o Device is idling in between work.
2793 : : *
2794 : : * This information is also exported via sysfs to userspace.
2795 : : *
2796 : : * DRMS will sum the total requested load on the regulator and change
2797 : : * to the most efficient operating mode if platform constraints allow.
2798 : : *
2799 : : * Returns the new regulator mode or error.
2800 : : */
2801 : 0 : int regulator_set_optimum_mode(struct regulator *regulator, int uA_load)
2802 : : {
2803 : 0 : struct regulator_dev *rdev = regulator->rdev;
2804 : : struct regulator *consumer;
2805 : : int ret, output_uV, input_uV = 0, total_uA_load = 0;
2806 : : unsigned int mode;
2807 : :
2808 [ # # ]: 0 : if (rdev->supply)
2809 : 0 : input_uV = regulator_get_voltage(rdev->supply);
2810 : :
2811 : 0 : mutex_lock(&rdev->mutex);
2812 : :
2813 : : /*
2814 : : * first check to see if we can set modes at all, otherwise just
2815 : : * tell the consumer everything is OK.
2816 : : */
2817 : 0 : regulator->uA_load = uA_load;
2818 : 0 : ret = regulator_check_drms(rdev);
2819 [ # # ]: 0 : if (ret < 0) {
2820 : : ret = 0;
2821 : : goto out;
2822 : : }
2823 : :
2824 [ # # ]: 0 : if (!rdev->desc->ops->get_optimum_mode)
2825 : : goto out;
2826 : :
2827 : : /*
2828 : : * we can actually do this so any errors are indicators of
2829 : : * potential real failure.
2830 : : */
2831 : : ret = -EINVAL;
2832 : :
2833 [ # # ]: 0 : if (!rdev->desc->ops->set_mode)
2834 : : goto out;
2835 : :
2836 : : /* get output voltage */
2837 : 0 : output_uV = _regulator_get_voltage(rdev);
2838 [ # # ]: 0 : if (output_uV <= 0) {
2839 : 0 : rdev_err(rdev, "invalid output voltage found\n");
2840 : 0 : goto out;
2841 : : }
2842 : :
2843 : : /* No supply? Use constraint voltage */
2844 [ # # ]: 0 : if (input_uV <= 0)
2845 : 0 : input_uV = rdev->constraints->input_uV;
2846 [ # # ]: 0 : if (input_uV <= 0) {
2847 : 0 : rdev_err(rdev, "invalid input voltage found\n");
2848 : 0 : goto out;
2849 : : }
2850 : :
2851 : : /* calc total requested load for this regulator */
2852 [ # # ]: 0 : list_for_each_entry(consumer, &rdev->consumer_list, list)
2853 : 0 : total_uA_load += consumer->uA_load;
2854 : :
2855 : 0 : mode = rdev->desc->ops->get_optimum_mode(rdev,
2856 : : input_uV, output_uV,
2857 : : total_uA_load);
2858 : 0 : ret = regulator_mode_constrain(rdev, &mode);
2859 [ # # ]: 0 : if (ret < 0) {
2860 : 0 : rdev_err(rdev, "failed to get optimum mode @ %d uA %d -> %d uV\n",
2861 : : total_uA_load, input_uV, output_uV);
2862 : 0 : goto out;
2863 : : }
2864 : :
2865 : 0 : ret = rdev->desc->ops->set_mode(rdev, mode);
2866 [ # # ]: 0 : if (ret < 0) {
2867 : 0 : rdev_err(rdev, "failed to set optimum mode %x\n", mode);
2868 : 0 : goto out;
2869 : : }
2870 : 0 : ret = mode;
2871 : : out:
2872 : 0 : mutex_unlock(&rdev->mutex);
2873 : 0 : return ret;
2874 : : }
2875 : : EXPORT_SYMBOL_GPL(regulator_set_optimum_mode);
2876 : :
2877 : : /**
2878 : : * regulator_allow_bypass - allow the regulator to go into bypass mode
2879 : : *
2880 : : * @regulator: Regulator to configure
2881 : : * @enable: enable or disable bypass mode
2882 : : *
2883 : : * Allow the regulator to go into bypass mode if all other consumers
2884 : : * for the regulator also enable bypass mode and the machine
2885 : : * constraints allow this. Bypass mode means that the regulator is
2886 : : * simply passing the input directly to the output with no regulation.
2887 : : */
2888 : 0 : int regulator_allow_bypass(struct regulator *regulator, bool enable)
2889 : : {
2890 : 0 : struct regulator_dev *rdev = regulator->rdev;
2891 : : int ret = 0;
2892 : :
2893 [ # # ]: 0 : if (!rdev->desc->ops->set_bypass)
2894 : : return 0;
2895 : :
2896 [ # # ][ # # ]: 0 : if (rdev->constraints &&
2897 : 0 : !(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_BYPASS))
2898 : : return 0;
2899 : :
2900 : 0 : mutex_lock(&rdev->mutex);
2901 : :
2902 [ # # ][ # # ]: 0 : if (enable && !regulator->bypass) {
2903 : 0 : rdev->bypass_count++;
2904 : :
2905 [ # # ]: 0 : if (rdev->bypass_count == rdev->open_count) {
2906 : 0 : ret = rdev->desc->ops->set_bypass(rdev, enable);
2907 [ # # ]: 0 : if (ret != 0)
2908 : 0 : rdev->bypass_count--;
2909 : : }
2910 : :
2911 [ # # ][ # # ]: 0 : } else if (!enable && regulator->bypass) {
2912 : 0 : rdev->bypass_count--;
2913 : :
2914 [ # # ]: 0 : if (rdev->bypass_count != rdev->open_count) {
2915 : 0 : ret = rdev->desc->ops->set_bypass(rdev, enable);
2916 [ # # ]: 0 : if (ret != 0)
2917 : 0 : rdev->bypass_count++;
2918 : : }
2919 : : }
2920 : :
2921 [ # # ]: 0 : if (ret == 0)
2922 : 0 : regulator->bypass = enable;
2923 : :
2924 : 0 : mutex_unlock(&rdev->mutex);
2925 : :
2926 : 0 : return ret;
2927 : : }
2928 : : EXPORT_SYMBOL_GPL(regulator_allow_bypass);
2929 : :
2930 : : /**
2931 : : * regulator_register_notifier - register regulator event notifier
2932 : : * @regulator: regulator source
2933 : : * @nb: notifier block
2934 : : *
2935 : : * Register notifier block to receive regulator events.
2936 : : */
2937 : 0 : int regulator_register_notifier(struct regulator *regulator,
2938 : : struct notifier_block *nb)
2939 : : {
2940 : 0 : return blocking_notifier_chain_register(®ulator->rdev->notifier,
2941 : : nb);
2942 : : }
2943 : : EXPORT_SYMBOL_GPL(regulator_register_notifier);
2944 : :
2945 : : /**
2946 : : * regulator_unregister_notifier - unregister regulator event notifier
2947 : : * @regulator: regulator source
2948 : : * @nb: notifier block
2949 : : *
2950 : : * Unregister regulator event notifier block.
2951 : : */
2952 : 0 : int regulator_unregister_notifier(struct regulator *regulator,
2953 : : struct notifier_block *nb)
2954 : : {
2955 : 0 : return blocking_notifier_chain_unregister(®ulator->rdev->notifier,
2956 : : nb);
2957 : : }
2958 : : EXPORT_SYMBOL_GPL(regulator_unregister_notifier);
2959 : :
2960 : : /* notify regulator consumers and downstream regulator consumers.
2961 : : * Note mutex must be held by caller.
2962 : : */
2963 : : static void _notifier_call_chain(struct regulator_dev *rdev,
2964 : : unsigned long event, void *data)
2965 : : {
2966 : : /* call rdev chain first */
2967 : 0 : blocking_notifier_call_chain(&rdev->notifier, event, data);
2968 : : }
2969 : :
2970 : : /**
2971 : : * regulator_bulk_get - get multiple regulator consumers
2972 : : *
2973 : : * @dev: Device to supply
2974 : : * @num_consumers: Number of consumers to register
2975 : : * @consumers: Configuration of consumers; clients are stored here.
2976 : : *
2977 : : * @return 0 on success, an errno on failure.
2978 : : *
2979 : : * This helper function allows drivers to get several regulator
2980 : : * consumers in one operation. If any of the regulators cannot be
2981 : : * acquired then any regulators that were allocated will be freed
2982 : : * before returning to the caller.
2983 : : */
2984 : 0 : int regulator_bulk_get(struct device *dev, int num_consumers,
2985 : : struct regulator_bulk_data *consumers)
2986 : : {
2987 : : int i;
2988 : : int ret;
2989 : :
2990 [ # # ]: 0 : for (i = 0; i < num_consumers; i++)
2991 : 0 : consumers[i].consumer = NULL;
2992 : :
2993 [ # # ]: 0 : for (i = 0; i < num_consumers; i++) {
2994 : 0 : consumers[i].consumer = regulator_get(dev,
2995 : 0 : consumers[i].supply);
2996 [ # # ]: 0 : if (IS_ERR(consumers[i].consumer)) {
2997 : : ret = PTR_ERR(consumers[i].consumer);
2998 : 0 : dev_err(dev, "Failed to get supply '%s': %d\n",
2999 : : consumers[i].supply, ret);
3000 : 0 : consumers[i].consumer = NULL;
3001 : : goto err;
3002 : : }
3003 : : }
3004 : :
3005 : : return 0;
3006 : :
3007 : : err:
3008 [ # # ]: 0 : while (--i >= 0)
3009 : 0 : regulator_put(consumers[i].consumer);
3010 : :
3011 : : return ret;
3012 : : }
3013 : : EXPORT_SYMBOL_GPL(regulator_bulk_get);
3014 : :
3015 : 0 : static void regulator_bulk_enable_async(void *data, async_cookie_t cookie)
3016 : : {
3017 : : struct regulator_bulk_data *bulk = data;
3018 : :
3019 : 0 : bulk->ret = regulator_enable(bulk->consumer);
3020 : 0 : }
3021 : :
3022 : : /**
3023 : : * regulator_bulk_enable - enable multiple regulator consumers
3024 : : *
3025 : : * @num_consumers: Number of consumers
3026 : : * @consumers: Consumer data; clients are stored here.
3027 : : * @return 0 on success, an errno on failure
3028 : : *
3029 : : * This convenience API allows consumers to enable multiple regulator
3030 : : * clients in a single API call. If any consumers cannot be enabled
3031 : : * then any others that were enabled will be disabled again prior to
3032 : : * return.
3033 : : */
3034 : 0 : int regulator_bulk_enable(int num_consumers,
3035 : : struct regulator_bulk_data *consumers)
3036 : : {
3037 : 0 : ASYNC_DOMAIN_EXCLUSIVE(async_domain);
3038 : : int i;
3039 : : int ret = 0;
3040 : :
3041 [ # # ]: 0 : for (i = 0; i < num_consumers; i++) {
3042 [ # # ]: 0 : if (consumers[i].consumer->always_on)
3043 : 0 : consumers[i].ret = 0;
3044 : : else
3045 : 0 : async_schedule_domain(regulator_bulk_enable_async,
3046 : : &consumers[i], &async_domain);
3047 : : }
3048 : :
3049 : 0 : async_synchronize_full_domain(&async_domain);
3050 : :
3051 : : /* If any consumer failed we need to unwind any that succeeded */
3052 [ # # ]: 0 : for (i = 0; i < num_consumers; i++) {
3053 [ # # ]: 0 : if (consumers[i].ret != 0) {
3054 : : ret = consumers[i].ret;
3055 : : goto err;
3056 : : }
3057 : : }
3058 : :
3059 : : return 0;
3060 : :
3061 : : err:
3062 [ # # ]: 0 : for (i = 0; i < num_consumers; i++) {
3063 [ # # ]: 0 : if (consumers[i].ret < 0)
3064 : 0 : pr_err("Failed to enable %s: %d\n", consumers[i].supply,
3065 : : consumers[i].ret);
3066 : : else
3067 : 0 : regulator_disable(consumers[i].consumer);
3068 : : }
3069 : :
3070 : : return ret;
3071 : : }
3072 : : EXPORT_SYMBOL_GPL(regulator_bulk_enable);
3073 : :
3074 : : /**
3075 : : * regulator_bulk_disable - disable multiple regulator consumers
3076 : : *
3077 : : * @num_consumers: Number of consumers
3078 : : * @consumers: Consumer data; clients are stored here.
3079 : : * @return 0 on success, an errno on failure
3080 : : *
3081 : : * This convenience API allows consumers to disable multiple regulator
3082 : : * clients in a single API call. If any consumers cannot be disabled
3083 : : * then any others that were disabled will be enabled again prior to
3084 : : * return.
3085 : : */
3086 : 0 : int regulator_bulk_disable(int num_consumers,
3087 : : struct regulator_bulk_data *consumers)
3088 : : {
3089 : : int i;
3090 : : int ret, r;
3091 : :
3092 [ # # ]: 0 : for (i = num_consumers - 1; i >= 0; --i) {
3093 : 0 : ret = regulator_disable(consumers[i].consumer);
3094 [ # # ]: 0 : if (ret != 0)
3095 : : goto err;
3096 : : }
3097 : :
3098 : : return 0;
3099 : :
3100 : : err:
3101 : 0 : pr_err("Failed to disable %s: %d\n", consumers[i].supply, ret);
3102 [ # # ]: 0 : for (++i; i < num_consumers; ++i) {
3103 : 0 : r = regulator_enable(consumers[i].consumer);
3104 [ # # ]: 0 : if (r != 0)
3105 : 0 : pr_err("Failed to reename %s: %d\n",
3106 : : consumers[i].supply, r);
3107 : : }
3108 : :
3109 : : return ret;
3110 : : }
3111 : : EXPORT_SYMBOL_GPL(regulator_bulk_disable);
3112 : :
3113 : : /**
3114 : : * regulator_bulk_force_disable - force disable multiple regulator consumers
3115 : : *
3116 : : * @num_consumers: Number of consumers
3117 : : * @consumers: Consumer data; clients are stored here.
3118 : : * @return 0 on success, an errno on failure
3119 : : *
3120 : : * This convenience API allows consumers to forcibly disable multiple regulator
3121 : : * clients in a single API call.
3122 : : * NOTE: This should be used for situations when device damage will
3123 : : * likely occur if the regulators are not disabled (e.g. over temp).
3124 : : * Although regulator_force_disable function call for some consumers can
3125 : : * return error numbers, the function is called for all consumers.
3126 : : */
3127 : 0 : int regulator_bulk_force_disable(int num_consumers,
3128 : : struct regulator_bulk_data *consumers)
3129 : : {
3130 : : int i;
3131 : : int ret;
3132 : :
3133 [ # # ]: 0 : for (i = 0; i < num_consumers; i++)
3134 : 0 : consumers[i].ret =
3135 : 0 : regulator_force_disable(consumers[i].consumer);
3136 : :
3137 [ # # ]: 0 : for (i = 0; i < num_consumers; i++) {
3138 [ # # ]: 0 : if (consumers[i].ret != 0) {
3139 : : ret = consumers[i].ret;
3140 : : goto out;
3141 : : }
3142 : : }
3143 : :
3144 : : return 0;
3145 : : out:
3146 : : return ret;
3147 : : }
3148 : : EXPORT_SYMBOL_GPL(regulator_bulk_force_disable);
3149 : :
3150 : : /**
3151 : : * regulator_bulk_free - free multiple regulator consumers
3152 : : *
3153 : : * @num_consumers: Number of consumers
3154 : : * @consumers: Consumer data; clients are stored here.
3155 : : *
3156 : : * This convenience API allows consumers to free multiple regulator
3157 : : * clients in a single API call.
3158 : : */
3159 : 0 : void regulator_bulk_free(int num_consumers,
3160 : : struct regulator_bulk_data *consumers)
3161 : : {
3162 : : int i;
3163 : :
3164 [ # # ]: 0 : for (i = 0; i < num_consumers; i++) {
3165 : 0 : regulator_put(consumers[i].consumer);
3166 : 0 : consumers[i].consumer = NULL;
3167 : : }
3168 : 0 : }
3169 : : EXPORT_SYMBOL_GPL(regulator_bulk_free);
3170 : :
3171 : : /**
3172 : : * regulator_notifier_call_chain - call regulator event notifier
3173 : : * @rdev: regulator source
3174 : : * @event: notifier block
3175 : : * @data: callback-specific data.
3176 : : *
3177 : : * Called by regulator drivers to notify clients a regulator event has
3178 : : * occurred. We also notify regulator clients downstream.
3179 : : * Note lock must be held by caller.
3180 : : */
3181 : 0 : int regulator_notifier_call_chain(struct regulator_dev *rdev,
3182 : : unsigned long event, void *data)
3183 : : {
3184 : : _notifier_call_chain(rdev, event, data);
3185 : 0 : return NOTIFY_DONE;
3186 : :
3187 : : }
3188 : : EXPORT_SYMBOL_GPL(regulator_notifier_call_chain);
3189 : :
3190 : : /**
3191 : : * regulator_mode_to_status - convert a regulator mode into a status
3192 : : *
3193 : : * @mode: Mode to convert
3194 : : *
3195 : : * Convert a regulator mode into a status.
3196 : : */
3197 [ # # ]: 0 : int regulator_mode_to_status(unsigned int mode)
3198 : : {
3199 : : switch (mode) {
3200 : : case REGULATOR_MODE_FAST:
3201 : : return REGULATOR_STATUS_FAST;
3202 : : case REGULATOR_MODE_NORMAL:
3203 : : return REGULATOR_STATUS_NORMAL;
3204 : : case REGULATOR_MODE_IDLE:
3205 : : return REGULATOR_STATUS_IDLE;
3206 : : case REGULATOR_MODE_STANDBY:
3207 : : return REGULATOR_STATUS_STANDBY;
3208 : : default:
3209 : : return REGULATOR_STATUS_UNDEFINED;
3210 : : }
3211 : : }
3212 : : EXPORT_SYMBOL_GPL(regulator_mode_to_status);
3213 : :
3214 : : /*
3215 : : * To avoid cluttering sysfs (and memory) with useless state, only
3216 : : * create attributes that can be meaningfully displayed.
3217 : : */
3218 : 0 : static int add_regulator_attributes(struct regulator_dev *rdev)
3219 : : {
3220 : 0 : struct device *dev = &rdev->dev;
3221 : 0 : struct regulator_ops *ops = rdev->desc->ops;
3222 : : int status = 0;
3223 : :
3224 : : /* some attributes need specific methods to be displayed */
3225 [ # # ][ # # ]: 0 : if ((ops->get_voltage && ops->get_voltage(rdev) >= 0) ||
[ # # ]
3226 [ # # ][ # # ]: 0 : (ops->get_voltage_sel && ops->get_voltage_sel(rdev) >= 0) ||
3227 [ # # ][ # # ]: 0 : (ops->list_voltage && ops->list_voltage(rdev, 0) >= 0) ||
3228 [ # # ]: 0 : (rdev->desc->fixed_uV && (rdev->desc->n_voltages == 1))) {
3229 : 0 : status = device_create_file(dev, &dev_attr_microvolts);
3230 [ # # ]: 0 : if (status < 0)
3231 : : return status;
3232 : : }
3233 [ # # ]: 0 : if (ops->get_current_limit) {
3234 : 0 : status = device_create_file(dev, &dev_attr_microamps);
3235 [ # # ]: 0 : if (status < 0)
3236 : : return status;
3237 : : }
3238 [ # # ]: 0 : if (ops->get_mode) {
3239 : 0 : status = device_create_file(dev, &dev_attr_opmode);
3240 [ # # ]: 0 : if (status < 0)
3241 : : return status;
3242 : : }
3243 [ # # ][ # # ]: 0 : if (rdev->ena_pin || ops->is_enabled) {
3244 : 0 : status = device_create_file(dev, &dev_attr_state);
3245 [ # # ]: 0 : if (status < 0)
3246 : : return status;
3247 : : }
3248 [ # # ]: 0 : if (ops->get_status) {
3249 : 0 : status = device_create_file(dev, &dev_attr_status);
3250 [ # # ]: 0 : if (status < 0)
3251 : : return status;
3252 : : }
3253 [ # # ]: 0 : if (ops->get_bypass) {
3254 : 0 : status = device_create_file(dev, &dev_attr_bypass);
3255 [ # # ]: 0 : if (status < 0)
3256 : : return status;
3257 : : }
3258 : :
3259 : : /* some attributes are type-specific */
3260 [ # # ]: 0 : if (rdev->desc->type == REGULATOR_CURRENT) {
3261 : 0 : status = device_create_file(dev, &dev_attr_requested_microamps);
3262 [ # # ]: 0 : if (status < 0)
3263 : : return status;
3264 : : }
3265 : :
3266 : : /* all the other attributes exist to support constraints;
3267 : : * don't show them if there are no constraints, or if the
3268 : : * relevant supporting methods are missing.
3269 : : */
3270 [ # # ]: 0 : if (!rdev->constraints)
3271 : : return status;
3272 : :
3273 : : /* constraints need specific supporting methods */
3274 [ # # ][ # # ]: 0 : if (ops->set_voltage || ops->set_voltage_sel) {
3275 : 0 : status = device_create_file(dev, &dev_attr_min_microvolts);
3276 [ # # ]: 0 : if (status < 0)
3277 : : return status;
3278 : 0 : status = device_create_file(dev, &dev_attr_max_microvolts);
3279 [ # # ]: 0 : if (status < 0)
3280 : : return status;
3281 : : }
3282 [ # # ]: 0 : if (ops->set_current_limit) {
3283 : 0 : status = device_create_file(dev, &dev_attr_min_microamps);
3284 [ # # ]: 0 : if (status < 0)
3285 : : return status;
3286 : 0 : status = device_create_file(dev, &dev_attr_max_microamps);
3287 [ # # ]: 0 : if (status < 0)
3288 : : return status;
3289 : : }
3290 : :
3291 : 0 : status = device_create_file(dev, &dev_attr_suspend_standby_state);
3292 [ # # ]: 0 : if (status < 0)
3293 : : return status;
3294 : 0 : status = device_create_file(dev, &dev_attr_suspend_mem_state);
3295 [ # # ]: 0 : if (status < 0)
3296 : : return status;
3297 : 0 : status = device_create_file(dev, &dev_attr_suspend_disk_state);
3298 [ # # ]: 0 : if (status < 0)
3299 : : return status;
3300 : :
3301 [ # # ]: 0 : if (ops->set_suspend_voltage) {
3302 : 0 : status = device_create_file(dev,
3303 : : &dev_attr_suspend_standby_microvolts);
3304 [ # # ]: 0 : if (status < 0)
3305 : : return status;
3306 : 0 : status = device_create_file(dev,
3307 : : &dev_attr_suspend_mem_microvolts);
3308 [ # # ]: 0 : if (status < 0)
3309 : : return status;
3310 : 0 : status = device_create_file(dev,
3311 : : &dev_attr_suspend_disk_microvolts);
3312 [ # # ]: 0 : if (status < 0)
3313 : : return status;
3314 : : }
3315 : :
3316 [ # # ]: 0 : if (ops->set_suspend_mode) {
3317 : 0 : status = device_create_file(dev,
3318 : : &dev_attr_suspend_standby_mode);
3319 [ # # ]: 0 : if (status < 0)
3320 : : return status;
3321 : 0 : status = device_create_file(dev,
3322 : : &dev_attr_suspend_mem_mode);
3323 [ # # ]: 0 : if (status < 0)
3324 : : return status;
3325 : 0 : status = device_create_file(dev,
3326 : : &dev_attr_suspend_disk_mode);
3327 [ # # ]: 0 : if (status < 0)
3328 : : return status;
3329 : : }
3330 : :
3331 : 0 : return status;
3332 : : }
3333 : :
3334 : 0 : static void rdev_init_debugfs(struct regulator_dev *rdev)
3335 : : {
3336 : 0 : rdev->debugfs = debugfs_create_dir(rdev_get_name(rdev), debugfs_root);
3337 [ # # ]: 0 : if (!rdev->debugfs) {
3338 : 0 : rdev_warn(rdev, "Failed to create debugfs directory\n");
3339 : 0 : return;
3340 : : }
3341 : :
3342 : 0 : debugfs_create_u32("use_count", 0444, rdev->debugfs,
3343 : : &rdev->use_count);
3344 : 0 : debugfs_create_u32("open_count", 0444, rdev->debugfs,
3345 : : &rdev->open_count);
3346 : 0 : debugfs_create_u32("bypass_count", 0444, rdev->debugfs,
3347 : : &rdev->bypass_count);
3348 : : }
3349 : :
3350 : : /**
3351 : : * regulator_register - register regulator
3352 : : * @regulator_desc: regulator to register
3353 : : * @config: runtime configuration for regulator
3354 : : *
3355 : : * Called by regulator drivers to register a regulator.
3356 : : * Returns a valid pointer to struct regulator_dev on success
3357 : : * or an ERR_PTR() on error.
3358 : : */
3359 : : struct regulator_dev *
3360 : 0 : regulator_register(const struct regulator_desc *regulator_desc,
3361 : : const struct regulator_config *config)
3362 : : {
3363 : : const struct regulation_constraints *constraints = NULL;
3364 : : const struct regulator_init_data *init_data;
3365 : : static atomic_t regulator_no = ATOMIC_INIT(0);
3366 : 0 : struct regulator_dev *rdev;
3367 : : struct device *dev;
3368 : : int ret, i;
3369 : : const char *supply = NULL;
3370 : :
3371 [ # # ]: 0 : if (regulator_desc == NULL || config == NULL)
3372 : : return ERR_PTR(-EINVAL);
3373 : :
3374 : 0 : dev = config->dev;
3375 [ # # ]: 0 : WARN_ON(!dev);
3376 : :
3377 [ # # ][ # # ]: 0 : if (regulator_desc->name == NULL || regulator_desc->ops == NULL)
3378 : : return ERR_PTR(-EINVAL);
3379 : :
3380 [ # # ]: 0 : if (regulator_desc->type != REGULATOR_VOLTAGE &&
3381 : : regulator_desc->type != REGULATOR_CURRENT)
3382 : : return ERR_PTR(-EINVAL);
3383 : :
3384 : : /* Only one of each should be implemented */
3385 [ # # ][ # # ]: 0 : WARN_ON(regulator_desc->ops->get_voltage &&
[ # # ]
3386 : : regulator_desc->ops->get_voltage_sel);
3387 [ # # ][ # # ]: 0 : WARN_ON(regulator_desc->ops->set_voltage &&
[ # # ]
3388 : : regulator_desc->ops->set_voltage_sel);
3389 : :
3390 : : /* If we're using selectors we must implement list_voltage. */
3391 [ # # ][ # # ]: 0 : if (regulator_desc->ops->get_voltage_sel &&
3392 : 0 : !regulator_desc->ops->list_voltage) {
3393 : : return ERR_PTR(-EINVAL);
3394 : : }
3395 [ # # ][ # # ]: 0 : if (regulator_desc->ops->set_voltage_sel &&
3396 : 0 : !regulator_desc->ops->list_voltage) {
3397 : : return ERR_PTR(-EINVAL);
3398 : : }
3399 : :
3400 : 0 : init_data = config->init_data;
3401 : :
3402 : : rdev = kzalloc(sizeof(struct regulator_dev), GFP_KERNEL);
3403 [ # # ]: 0 : if (rdev == NULL)
3404 : : return ERR_PTR(-ENOMEM);
3405 : :
3406 : 0 : mutex_lock(®ulator_list_mutex);
3407 : :
3408 : 0 : mutex_init(&rdev->mutex);
3409 : 0 : rdev->reg_data = config->driver_data;
3410 : 0 : rdev->owner = regulator_desc->owner;
3411 : 0 : rdev->desc = regulator_desc;
3412 [ # # ]: 0 : if (config->regmap)
3413 : 0 : rdev->regmap = config->regmap;
3414 : : else if (dev_get_regmap(dev, NULL))
3415 : : rdev->regmap = dev_get_regmap(dev, NULL);
3416 [ # # ]: 0 : else if (dev->parent)
3417 : 0 : rdev->regmap = dev_get_regmap(dev->parent, NULL);
3418 : 0 : INIT_LIST_HEAD(&rdev->consumer_list);
3419 : 0 : INIT_LIST_HEAD(&rdev->list);
3420 : 0 : BLOCKING_INIT_NOTIFIER_HEAD(&rdev->notifier);
3421 : 0 : INIT_DELAYED_WORK(&rdev->disable_work, regulator_disable_work);
3422 : :
3423 : : /* preform any regulator specific init */
3424 [ # # ][ # # ]: 0 : if (init_data && init_data->regulator_init) {
3425 : 0 : ret = init_data->regulator_init(rdev->reg_data);
3426 [ # # ]: 0 : if (ret < 0)
3427 : : goto clean;
3428 : : }
3429 : :
3430 : : /* register with sysfs */
3431 : 0 : rdev->dev.class = ®ulator_class;
3432 : 0 : rdev->dev.of_node = config->of_node;
3433 : 0 : rdev->dev.parent = dev;
3434 : 0 : dev_set_name(&rdev->dev, "regulator.%d",
3435 : : atomic_inc_return(®ulator_no) - 1);
3436 : 0 : ret = device_register(&rdev->dev);
3437 [ # # ]: 0 : if (ret != 0) {
3438 : 0 : put_device(&rdev->dev);
3439 : 0 : goto clean;
3440 : : }
3441 : :
3442 : 0 : dev_set_drvdata(&rdev->dev, rdev);
3443 : :
3444 [ # # ][ # # ]: 0 : if (config->ena_gpio && gpio_is_valid(config->ena_gpio)) {
3445 : 0 : ret = regulator_ena_gpio_request(rdev, config);
3446 [ # # ]: 0 : if (ret != 0) {
3447 : 0 : rdev_err(rdev, "Failed to request enable GPIO%d: %d\n",
3448 : : config->ena_gpio, ret);
3449 : 0 : goto wash;
3450 : : }
3451 : :
3452 [ # # ]: 0 : if (config->ena_gpio_flags & GPIOF_OUT_INIT_HIGH)
3453 : 0 : rdev->ena_gpio_state = 1;
3454 : :
3455 [ # # ]: 0 : if (config->ena_gpio_invert)
3456 : 0 : rdev->ena_gpio_state = !rdev->ena_gpio_state;
3457 : : }
3458 : :
3459 : : /* set regulator constraints */
3460 [ # # ]: 0 : if (init_data)
3461 : 0 : constraints = &init_data->constraints;
3462 : :
3463 : 0 : ret = set_machine_constraints(rdev, constraints);
3464 [ # # ]: 0 : if (ret < 0)
3465 : : goto scrub;
3466 : :
3467 : : /* add attributes supported by this regulator */
3468 : 0 : ret = add_regulator_attributes(rdev);
3469 [ # # ]: 0 : if (ret < 0)
3470 : : goto scrub;
3471 : :
3472 [ # # ][ # # ]: 0 : if (init_data && init_data->supply_regulator)
3473 : : supply = init_data->supply_regulator;
3474 [ # # ]: 0 : else if (regulator_desc->supply_name)
3475 : : supply = regulator_desc->supply_name;
3476 : :
3477 [ # # ]: 0 : if (supply) {
3478 : : struct regulator_dev *r;
3479 : :
3480 : 0 : r = regulator_dev_lookup(dev, supply, &ret);
3481 : :
3482 [ # # ]: 0 : if (ret == -ENODEV) {
3483 : : /*
3484 : : * No supply was specified for this regulator and
3485 : : * there will never be one.
3486 : : */
3487 : 0 : ret = 0;
3488 : 0 : goto add_dev;
3489 [ # # ]: 0 : } else if (!r) {
3490 : 0 : dev_err(dev, "Failed to find supply %s\n", supply);
3491 : 0 : ret = -EPROBE_DEFER;
3492 : 0 : goto scrub;
3493 : : }
3494 : :
3495 : 0 : ret = set_supply(rdev, r);
3496 [ # # ]: 0 : if (ret < 0)
3497 : : goto scrub;
3498 : :
3499 : : /* Enable supply if rail is enabled */
3500 [ # # ]: 0 : if (_regulator_is_enabled(rdev)) {
3501 : 0 : ret = regulator_enable(rdev->supply);
3502 [ # # ]: 0 : if (ret < 0)
3503 : : goto scrub;
3504 : : }
3505 : : }
3506 : :
3507 : : add_dev:
3508 : : /* add consumers devices */
3509 [ # # ]: 0 : if (init_data) {
3510 [ # # ]: 0 : for (i = 0; i < init_data->num_consumer_supplies; i++) {
3511 : 0 : ret = set_consumer_device_supply(rdev,
3512 : 0 : init_data->consumer_supplies[i].dev_name,
3513 : : init_data->consumer_supplies[i].supply);
3514 [ # # ]: 0 : if (ret < 0) {
3515 : 0 : dev_err(dev, "Failed to set supply %s\n",
3516 : 0 : init_data->consumer_supplies[i].supply);
3517 : : goto unset_supplies;
3518 : : }
3519 : : }
3520 : : }
3521 : :
3522 : : list_add(&rdev->list, ®ulator_list);
3523 : :
3524 : 0 : rdev_init_debugfs(rdev);
3525 : : out:
3526 : 0 : mutex_unlock(®ulator_list_mutex);
3527 : 0 : return rdev;
3528 : :
3529 : : unset_supplies:
3530 : 0 : unset_regulator_supplies(rdev);
3531 : :
3532 : : scrub:
3533 [ # # ]: 0 : if (rdev->supply)
3534 : 0 : _regulator_put(rdev->supply);
3535 : 0 : regulator_ena_gpio_free(rdev);
3536 : 0 : kfree(rdev->constraints);
3537 : : wash:
3538 : 0 : device_unregister(&rdev->dev);
3539 : : /* device core frees rdev */
3540 : 0 : rdev = ERR_PTR(ret);
3541 : 0 : goto out;
3542 : :
3543 : : clean:
3544 : 0 : kfree(rdev);
3545 : 0 : rdev = ERR_PTR(ret);
3546 : 0 : goto out;
3547 : : }
3548 : : EXPORT_SYMBOL_GPL(regulator_register);
3549 : :
3550 : : /**
3551 : : * regulator_unregister - unregister regulator
3552 : : * @rdev: regulator to unregister
3553 : : *
3554 : : * Called by regulator drivers to unregister a regulator.
3555 : : */
3556 : 0 : void regulator_unregister(struct regulator_dev *rdev)
3557 : : {
3558 [ # # ]: 0 : if (rdev == NULL)
3559 : 0 : return;
3560 : :
3561 [ # # ]: 0 : if (rdev->supply) {
3562 [ # # ]: 0 : while (rdev->use_count--)
3563 : 0 : regulator_disable(rdev->supply);
3564 : 0 : regulator_put(rdev->supply);
3565 : : }
3566 : 0 : mutex_lock(®ulator_list_mutex);
3567 : 0 : debugfs_remove_recursive(rdev->debugfs);
3568 : 0 : flush_work(&rdev->disable_work.work);
3569 [ # # ]: 0 : WARN_ON(rdev->open_count);
3570 : 0 : unset_regulator_supplies(rdev);
3571 : : list_del(&rdev->list);
3572 : 0 : kfree(rdev->constraints);
3573 : 0 : regulator_ena_gpio_free(rdev);
3574 : 0 : device_unregister(&rdev->dev);
3575 : 0 : mutex_unlock(®ulator_list_mutex);
3576 : : }
3577 : : EXPORT_SYMBOL_GPL(regulator_unregister);
3578 : :
3579 : : /**
3580 : : * regulator_suspend_prepare - prepare regulators for system wide suspend
3581 : : * @state: system suspend state
3582 : : *
3583 : : * Configure each regulator with it's suspend operating parameters for state.
3584 : : * This will usually be called by machine suspend code prior to supending.
3585 : : */
3586 : 0 : int regulator_suspend_prepare(suspend_state_t state)
3587 : : {
3588 : 0 : struct regulator_dev *rdev;
3589 : : int ret = 0;
3590 : :
3591 : : /* ON is handled by regulator active state */
3592 [ # # ]: 0 : if (state == PM_SUSPEND_ON)
3593 : : return -EINVAL;
3594 : :
3595 : 0 : mutex_lock(®ulator_list_mutex);
3596 [ # # ]: 0 : list_for_each_entry(rdev, ®ulator_list, list) {
3597 : :
3598 : 0 : mutex_lock(&rdev->mutex);
3599 : 0 : ret = suspend_prepare(rdev, state);
3600 : 0 : mutex_unlock(&rdev->mutex);
3601 : :
3602 [ # # ]: 0 : if (ret < 0) {
3603 : 0 : rdev_err(rdev, "failed to prepare\n");
3604 : 0 : goto out;
3605 : : }
3606 : : }
3607 : : out:
3608 : 0 : mutex_unlock(®ulator_list_mutex);
3609 : 0 : return ret;
3610 : : }
3611 : : EXPORT_SYMBOL_GPL(regulator_suspend_prepare);
3612 : :
3613 : : /**
3614 : : * regulator_suspend_finish - resume regulators from system wide suspend
3615 : : *
3616 : : * Turn on regulators that might be turned off by regulator_suspend_prepare
3617 : : * and that should be turned on according to the regulators properties.
3618 : : */
3619 : 0 : int regulator_suspend_finish(void)
3620 : : {
3621 : : struct regulator_dev *rdev;
3622 : : int ret = 0, error;
3623 : :
3624 : 0 : mutex_lock(®ulator_list_mutex);
3625 [ # # ]: 0 : list_for_each_entry(rdev, ®ulator_list, list) {
3626 : 0 : struct regulator_ops *ops = rdev->desc->ops;
3627 : :
3628 : 0 : mutex_lock(&rdev->mutex);
3629 [ # # ][ # # ]: 0 : if ((rdev->use_count > 0 || rdev->constraints->always_on) &&
[ # # ]
3630 : 0 : ops->enable) {
3631 : 0 : error = ops->enable(rdev);
3632 [ # # ]: 0 : if (error)
3633 : : ret = error;
3634 : : } else {
3635 [ # # ]: 0 : if (!have_full_constraints())
3636 : : goto unlock;
3637 [ # # ]: 0 : if (!ops->disable)
3638 : : goto unlock;
3639 [ # # ]: 0 : if (!_regulator_is_enabled(rdev))
3640 : : goto unlock;
3641 : :
3642 : 0 : error = ops->disable(rdev);
3643 [ # # ]: 0 : if (error)
3644 : : ret = error;
3645 : : }
3646 : : unlock:
3647 : 0 : mutex_unlock(&rdev->mutex);
3648 : : }
3649 : 0 : mutex_unlock(®ulator_list_mutex);
3650 : 0 : return ret;
3651 : : }
3652 : : EXPORT_SYMBOL_GPL(regulator_suspend_finish);
3653 : :
3654 : : /**
3655 : : * regulator_has_full_constraints - the system has fully specified constraints
3656 : : *
3657 : : * Calling this function will cause the regulator API to disable all
3658 : : * regulators which have a zero use count and don't have an always_on
3659 : : * constraint in a late_initcall.
3660 : : *
3661 : : * The intention is that this will become the default behaviour in a
3662 : : * future kernel release so users are encouraged to use this facility
3663 : : * now.
3664 : : */
3665 : 0 : void regulator_has_full_constraints(void)
3666 : : {
3667 : 0 : has_full_constraints = 1;
3668 : 0 : }
3669 : : EXPORT_SYMBOL_GPL(regulator_has_full_constraints);
3670 : :
3671 : : /**
3672 : : * rdev_get_drvdata - get rdev regulator driver data
3673 : : * @rdev: regulator
3674 : : *
3675 : : * Get rdev regulator driver private data. This call can be used in the
3676 : : * regulator driver context.
3677 : : */
3678 : 0 : void *rdev_get_drvdata(struct regulator_dev *rdev)
3679 : : {
3680 : 0 : return rdev->reg_data;
3681 : : }
3682 : : EXPORT_SYMBOL_GPL(rdev_get_drvdata);
3683 : :
3684 : : /**
3685 : : * regulator_get_drvdata - get regulator driver data
3686 : : * @regulator: regulator
3687 : : *
3688 : : * Get regulator driver private data. This call can be used in the consumer
3689 : : * driver context when non API regulator specific functions need to be called.
3690 : : */
3691 : 0 : void *regulator_get_drvdata(struct regulator *regulator)
3692 : : {
3693 : 0 : return regulator->rdev->reg_data;
3694 : : }
3695 : : EXPORT_SYMBOL_GPL(regulator_get_drvdata);
3696 : :
3697 : : /**
3698 : : * regulator_set_drvdata - set regulator driver data
3699 : : * @regulator: regulator
3700 : : * @data: data
3701 : : */
3702 : 0 : void regulator_set_drvdata(struct regulator *regulator, void *data)
3703 : : {
3704 : 0 : regulator->rdev->reg_data = data;
3705 : 0 : }
3706 : : EXPORT_SYMBOL_GPL(regulator_set_drvdata);
3707 : :
3708 : : /**
3709 : : * regulator_get_id - get regulator ID
3710 : : * @rdev: regulator
3711 : : */
3712 : 0 : int rdev_get_id(struct regulator_dev *rdev)
3713 : : {
3714 : 0 : return rdev->desc->id;
3715 : : }
3716 : : EXPORT_SYMBOL_GPL(rdev_get_id);
3717 : :
3718 : 0 : struct device *rdev_get_dev(struct regulator_dev *rdev)
3719 : : {
3720 : 0 : return &rdev->dev;
3721 : : }
3722 : : EXPORT_SYMBOL_GPL(rdev_get_dev);
3723 : :
3724 : 0 : void *regulator_get_init_drvdata(struct regulator_init_data *reg_init_data)
3725 : : {
3726 : 0 : return reg_init_data->driver_data;
3727 : : }
3728 : : EXPORT_SYMBOL_GPL(regulator_get_init_drvdata);
3729 : :
3730 : : #ifdef CONFIG_DEBUG_FS
3731 : 0 : static ssize_t supply_map_read_file(struct file *file, char __user *user_buf,
3732 : : size_t count, loff_t *ppos)
3733 : : {
3734 : : char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
3735 : : ssize_t len, ret = 0;
3736 : : struct regulator_map *map;
3737 : :
3738 [ # # ]: 0 : if (!buf)
3739 : : return -ENOMEM;
3740 : :
3741 [ # # ]: 0 : list_for_each_entry(map, ®ulator_map_list, list) {
3742 : 0 : len = snprintf(buf + ret, PAGE_SIZE - ret,
3743 : : "%s -> %s.%s\n",
3744 : : rdev_get_name(map->regulator), map->dev_name,
3745 : : map->supply);
3746 [ # # ]: 0 : if (len >= 0)
3747 : 0 : ret += len;
3748 [ # # ]: 0 : if (ret > PAGE_SIZE) {
3749 : : ret = PAGE_SIZE;
3750 : : break;
3751 : : }
3752 : : }
3753 : :
3754 : 0 : ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
3755 : :
3756 : 0 : kfree(buf);
3757 : :
3758 : 0 : return ret;
3759 : : }
3760 : : #endif
3761 : :
3762 : : static const struct file_operations supply_map_fops = {
3763 : : #ifdef CONFIG_DEBUG_FS
3764 : : .read = supply_map_read_file,
3765 : : .llseek = default_llseek,
3766 : : #endif
3767 : : };
3768 : :
3769 : 0 : static int __init regulator_init(void)
3770 : : {
3771 : : int ret;
3772 : :
3773 : 0 : ret = class_register(®ulator_class);
3774 : :
3775 : 0 : debugfs_root = debugfs_create_dir("regulator", NULL);
3776 [ # # ]: 0 : if (!debugfs_root)
3777 : 0 : pr_warn("regulator: Failed to create debugfs directory\n");
3778 : :
3779 : 0 : debugfs_create_file("supply_map", 0444, debugfs_root, NULL,
3780 : : &supply_map_fops);
3781 : :
3782 : 0 : regulator_dummy_init();
3783 : :
3784 : 0 : return ret;
3785 : : }
3786 : :
3787 : : /* init early to allow our consumers to complete system booting */
3788 : : core_initcall(regulator_init);
3789 : :
3790 : 0 : static int __init regulator_init_complete(void)
3791 : : {
3792 : 0 : struct regulator_dev *rdev;
3793 : : struct regulator_ops *ops;
3794 : : struct regulation_constraints *c;
3795 : : int enabled, ret;
3796 : :
3797 : : /*
3798 : : * Since DT doesn't provide an idiomatic mechanism for
3799 : : * enabling full constraints and since it's much more natural
3800 : : * with DT to provide them just assume that a DT enabled
3801 : : * system has full constraints.
3802 : : */
3803 [ # # ]: 0 : if (of_have_populated_dt())
3804 : 0 : has_full_constraints = true;
3805 : :
3806 : 0 : mutex_lock(®ulator_list_mutex);
3807 : :
3808 : : /* If we have a full configuration then disable any regulators
3809 : : * which are not in use or always_on. This will become the
3810 : : * default behaviour in the future.
3811 : : */
3812 [ # # ]: 0 : list_for_each_entry(rdev, ®ulator_list, list) {
3813 : 0 : ops = rdev->desc->ops;
3814 : 0 : c = rdev->constraints;
3815 : :
3816 [ # # ][ # # ]: 0 : if (!ops->disable || (c && c->always_on))
[ # # ]
3817 : 0 : continue;
3818 : :
3819 : 0 : mutex_lock(&rdev->mutex);
3820 : :
3821 [ # # ]: 0 : if (rdev->use_count)
3822 : : goto unlock;
3823 : :
3824 : : /* If we can't read the status assume it's on. */
3825 [ # # ]: 0 : if (ops->is_enabled)
3826 : 0 : enabled = ops->is_enabled(rdev);
3827 : : else
3828 : : enabled = 1;
3829 : :
3830 [ # # ]: 0 : if (!enabled)
3831 : : goto unlock;
3832 : :
3833 [ # # ]: 0 : if (have_full_constraints()) {
3834 : : /* We log since this may kill the system if it
3835 : : * goes wrong. */
3836 : 0 : rdev_info(rdev, "disabling\n");
3837 : 0 : ret = ops->disable(rdev);
3838 [ # # ]: 0 : if (ret != 0) {
3839 : 0 : rdev_err(rdev, "couldn't disable: %d\n", ret);
3840 : : }
3841 : : } else {
3842 : : /* The intention is that in future we will
3843 : : * assume that full constraints are provided
3844 : : * so warn even if we aren't going to do
3845 : : * anything here.
3846 : : */
3847 : 0 : rdev_warn(rdev, "incomplete constraints, leaving on\n");
3848 : : }
3849 : :
3850 : : unlock:
3851 : 0 : mutex_unlock(&rdev->mutex);
3852 : : }
3853 : :
3854 : 0 : mutex_unlock(®ulator_list_mutex);
3855 : :
3856 : 0 : return 0;
3857 : : }
3858 : : late_initcall(regulator_init_complete);
|
