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 : : static int _regulator_do_enable(struct regulator_dev *rdev);
957 : :
958 : : /**
959 : : * set_machine_constraints - sets regulator constraints
960 : : * @rdev: regulator source
961 : : * @constraints: constraints to apply
962 : : *
963 : : * Allows platform initialisation code to define and constrain
964 : : * regulator circuits e.g. valid voltage/current ranges, etc. NOTE:
965 : : * Constraints *must* be set by platform code in order for some
966 : : * regulator operations to proceed i.e. set_voltage, set_current_limit,
967 : : * set_mode.
968 : : */
969 : 0 : static int set_machine_constraints(struct regulator_dev *rdev,
970 : : const struct regulation_constraints *constraints)
971 : : {
972 : : int ret = 0;
973 : 0 : struct regulator_ops *ops = rdev->desc->ops;
974 : :
975 [ # # ]: 0 : if (constraints)
976 : 0 : rdev->constraints = kmemdup(constraints, sizeof(*constraints),
977 : : GFP_KERNEL);
978 : : else
979 : 0 : rdev->constraints = kzalloc(sizeof(*constraints),
980 : : GFP_KERNEL);
981 [ # # ]: 0 : if (!rdev->constraints)
982 : : return -ENOMEM;
983 : :
984 : 0 : ret = machine_constraints_voltage(rdev, rdev->constraints);
985 [ # # ]: 0 : if (ret != 0)
986 : : goto out;
987 : :
988 : 0 : ret = machine_constraints_current(rdev, rdev->constraints);
989 [ # # ]: 0 : if (ret != 0)
990 : : goto out;
991 : :
992 : : /* do we need to setup our suspend state */
993 [ # # ]: 0 : if (rdev->constraints->initial_state) {
994 : 0 : ret = suspend_prepare(rdev, rdev->constraints->initial_state);
995 [ # # ]: 0 : if (ret < 0) {
996 : 0 : rdev_err(rdev, "failed to set suspend state\n");
997 : 0 : goto out;
998 : : }
999 : : }
1000 : :
1001 [ # # ]: 0 : if (rdev->constraints->initial_mode) {
1002 [ # # ]: 0 : if (!ops->set_mode) {
1003 : 0 : rdev_err(rdev, "no set_mode operation\n");
1004 : : ret = -EINVAL;
1005 : 0 : goto out;
1006 : : }
1007 : :
1008 : 0 : ret = ops->set_mode(rdev, rdev->constraints->initial_mode);
1009 [ # # ]: 0 : if (ret < 0) {
1010 : 0 : rdev_err(rdev, "failed to set initial mode: %d\n", ret);
1011 : 0 : goto out;
1012 : : }
1013 : : }
1014 : :
1015 : : /* If the constraints say the regulator should be on at this point
1016 : : * and we have control then make sure it is enabled.
1017 : : */
1018 [ # # ]: 0 : if (rdev->constraints->always_on || rdev->constraints->boot_on) {
1019 : 0 : ret = _regulator_do_enable(rdev);
1020 [ # # ]: 0 : if (ret < 0 && ret != -EINVAL) {
1021 : 0 : rdev_err(rdev, "failed to enable\n");
1022 : 0 : goto out;
1023 : : }
1024 : : }
1025 : :
1026 [ # # ][ # # ]: 0 : if ((rdev->constraints->ramp_delay || rdev->constraints->ramp_disable)
1027 [ # # ]: 0 : && ops->set_ramp_delay) {
1028 : 0 : ret = ops->set_ramp_delay(rdev, rdev->constraints->ramp_delay);
1029 [ # # ]: 0 : if (ret < 0) {
1030 : 0 : rdev_err(rdev, "failed to set ramp_delay\n");
1031 : 0 : goto out;
1032 : : }
1033 : : }
1034 : :
1035 : 0 : print_constraints(rdev);
1036 : 0 : return 0;
1037 : : out:
1038 : 0 : kfree(rdev->constraints);
1039 : 0 : rdev->constraints = NULL;
1040 : 0 : return ret;
1041 : : }
1042 : :
1043 : : /**
1044 : : * set_supply - set regulator supply regulator
1045 : : * @rdev: regulator name
1046 : : * @supply_rdev: supply regulator name
1047 : : *
1048 : : * Called by platform initialisation code to set the supply regulator for this
1049 : : * regulator. This ensures that a regulators supply will also be enabled by the
1050 : : * core if it's child is enabled.
1051 : : */
1052 : 0 : static int set_supply(struct regulator_dev *rdev,
1053 : 0 : struct regulator_dev *supply_rdev)
1054 : : {
1055 : : int err;
1056 : :
1057 : 0 : rdev_info(rdev, "supplied by %s\n", rdev_get_name(supply_rdev));
1058 : :
1059 : 0 : rdev->supply = create_regulator(supply_rdev, &rdev->dev, "SUPPLY");
1060 [ # # ]: 0 : if (rdev->supply == NULL) {
1061 : : err = -ENOMEM;
1062 : : return err;
1063 : : }
1064 : 0 : supply_rdev->open_count++;
1065 : :
1066 : 0 : return 0;
1067 : : }
1068 : :
1069 : : /**
1070 : : * set_consumer_device_supply - Bind a regulator to a symbolic supply
1071 : : * @rdev: regulator source
1072 : : * @consumer_dev_name: dev_name() string for device supply applies to
1073 : : * @supply: symbolic name for supply
1074 : : *
1075 : : * Allows platform initialisation code to map physical regulator
1076 : : * sources to symbolic names for supplies for use by devices. Devices
1077 : : * should use these symbolic names to request regulators, avoiding the
1078 : : * need to provide board-specific regulator names as platform data.
1079 : : */
1080 : 0 : static int set_consumer_device_supply(struct regulator_dev *rdev,
1081 : : const char *consumer_dev_name,
1082 : : const char *supply)
1083 : : {
1084 : : struct regulator_map *node;
1085 : : int has_dev;
1086 : :
1087 [ # # ]: 0 : if (supply == NULL)
1088 : : return -EINVAL;
1089 : :
1090 [ # # ]: 0 : if (consumer_dev_name != NULL)
1091 : : has_dev = 1;
1092 : : else
1093 : : has_dev = 0;
1094 : :
1095 [ # # ]: 0 : list_for_each_entry(node, ®ulator_map_list, list) {
1096 [ # # ][ # # ]: 0 : if (node->dev_name && consumer_dev_name) {
1097 [ # # ]: 0 : if (strcmp(node->dev_name, consumer_dev_name) != 0)
1098 : 0 : continue;
1099 [ # # ][ # # ]: 0 : } else if (node->dev_name || consumer_dev_name) {
1100 : 0 : continue;
1101 : : }
1102 : :
1103 [ # # ]: 0 : if (strcmp(node->supply, supply) != 0)
1104 : 0 : continue;
1105 : :
1106 : : pr_debug("%s: %s/%s is '%s' supply; fail %s/%s\n",
1107 : : consumer_dev_name,
1108 : : dev_name(&node->regulator->dev),
1109 : : node->regulator->desc->name,
1110 : : supply,
1111 : : dev_name(&rdev->dev), rdev_get_name(rdev));
1112 : : return -EBUSY;
1113 : : }
1114 : :
1115 : : node = kzalloc(sizeof(struct regulator_map), GFP_KERNEL);
1116 [ # # ]: 0 : if (node == NULL)
1117 : : return -ENOMEM;
1118 : :
1119 : 0 : node->regulator = rdev;
1120 : 0 : node->supply = supply;
1121 : :
1122 [ # # ]: 0 : if (has_dev) {
1123 : 0 : node->dev_name = kstrdup(consumer_dev_name, GFP_KERNEL);
1124 [ # # ]: 0 : if (node->dev_name == NULL) {
1125 : 0 : kfree(node);
1126 : 0 : return -ENOMEM;
1127 : : }
1128 : : }
1129 : :
1130 : 0 : list_add(&node->list, ®ulator_map_list);
1131 : 0 : return 0;
1132 : : }
1133 : :
1134 : 0 : static void unset_regulator_supplies(struct regulator_dev *rdev)
1135 : : {
1136 : : struct regulator_map *node, *n;
1137 : :
1138 [ # # ]: 0 : list_for_each_entry_safe(node, n, ®ulator_map_list, list) {
1139 [ # # ]: 0 : if (rdev == node->regulator) {
1140 : : list_del(&node->list);
1141 : 0 : kfree(node->dev_name);
1142 : 0 : kfree(node);
1143 : : }
1144 : : }
1145 : 0 : }
1146 : :
1147 : : #define REG_STR_SIZE 64
1148 : :
1149 : 0 : static struct regulator *create_regulator(struct regulator_dev *rdev,
1150 : : struct device *dev,
1151 : : const char *supply_name)
1152 : : {
1153 : : struct regulator *regulator;
1154 : : char buf[REG_STR_SIZE];
1155 : : int err, size;
1156 : :
1157 : : regulator = kzalloc(sizeof(*regulator), GFP_KERNEL);
1158 [ # # ]: 0 : if (regulator == NULL)
1159 : : return NULL;
1160 : :
1161 : 0 : mutex_lock(&rdev->mutex);
1162 : 0 : regulator->rdev = rdev;
1163 : 0 : list_add(®ulator->list, &rdev->consumer_list);
1164 : :
1165 [ # # ]: 0 : if (dev) {
1166 : 0 : regulator->dev = dev;
1167 : :
1168 : : /* Add a link to the device sysfs entry */
1169 : 0 : size = scnprintf(buf, REG_STR_SIZE, "%s-%s",
1170 : : dev->kobj.name, supply_name);
1171 [ # # ]: 0 : if (size >= REG_STR_SIZE)
1172 : : goto overflow_err;
1173 : :
1174 : 0 : regulator->supply_name = kstrdup(buf, GFP_KERNEL);
1175 [ # # ]: 0 : if (regulator->supply_name == NULL)
1176 : : goto overflow_err;
1177 : :
1178 : 0 : err = sysfs_create_link(&rdev->dev.kobj, &dev->kobj,
1179 : : buf);
1180 [ # # ]: 0 : if (err) {
1181 : 0 : rdev_warn(rdev, "could not add device link %s err %d\n",
1182 : : dev->kobj.name, err);
1183 : : /* non-fatal */
1184 : : }
1185 : : } else {
1186 : 0 : regulator->supply_name = kstrdup(supply_name, GFP_KERNEL);
1187 [ # # ]: 0 : if (regulator->supply_name == NULL)
1188 : : goto overflow_err;
1189 : : }
1190 : :
1191 : 0 : regulator->debugfs = debugfs_create_dir(regulator->supply_name,
1192 : : rdev->debugfs);
1193 [ # # ]: 0 : if (!regulator->debugfs) {
1194 : 0 : rdev_warn(rdev, "Failed to create debugfs directory\n");
1195 : : } else {
1196 : 0 : debugfs_create_u32("uA_load", 0444, regulator->debugfs,
1197 : 0 : ®ulator->uA_load);
1198 : 0 : debugfs_create_u32("min_uV", 0444, regulator->debugfs,
1199 : 0 : ®ulator->min_uV);
1200 : 0 : debugfs_create_u32("max_uV", 0444, regulator->debugfs,
1201 : 0 : ®ulator->max_uV);
1202 : : }
1203 : :
1204 : : /*
1205 : : * Check now if the regulator is an always on regulator - if
1206 : : * it is then we don't need to do nearly so much work for
1207 : : * enable/disable calls.
1208 : : */
1209 [ # # ][ # # ]: 0 : if (!_regulator_can_change_status(rdev) &&
1210 : : _regulator_is_enabled(rdev))
1211 : 0 : regulator->always_on = true;
1212 : :
1213 : 0 : mutex_unlock(&rdev->mutex);
1214 : 0 : return regulator;
1215 : : overflow_err:
1216 : : list_del(®ulator->list);
1217 : 0 : kfree(regulator);
1218 : 0 : mutex_unlock(&rdev->mutex);
1219 : 0 : return NULL;
1220 : : }
1221 : :
1222 : 0 : static int _regulator_get_enable_time(struct regulator_dev *rdev)
1223 : : {
1224 [ # # ][ # # ]: 0 : if (rdev->constraints && rdev->constraints->enable_time)
1225 : 0 : return rdev->constraints->enable_time;
1226 [ # # ]: 0 : if (!rdev->desc->ops->enable_time)
1227 : 0 : return rdev->desc->enable_time;
1228 : 0 : return rdev->desc->ops->enable_time(rdev);
1229 : : }
1230 : :
1231 : 0 : static struct regulator_supply_alias *regulator_find_supply_alias(
1232 : : struct device *dev, const char *supply)
1233 : : {
1234 : : struct regulator_supply_alias *map;
1235 : :
1236 [ # # ]: 0 : list_for_each_entry(map, ®ulator_supply_alias_list, list)
1237 [ # # ][ # # ]: 0 : if (map->src_dev == dev && strcmp(map->src_supply, supply) == 0)
1238 : : return map;
1239 : :
1240 : : return NULL;
1241 : : }
1242 : :
1243 : 0 : static void regulator_supply_alias(struct device **dev, const char **supply)
1244 : : {
1245 : : struct regulator_supply_alias *map;
1246 : :
1247 : 0 : map = regulator_find_supply_alias(*dev, *supply);
1248 [ # # ]: 0 : if (map) {
1249 : : dev_dbg(*dev, "Mapping supply %s to %s,%s\n",
1250 : : *supply, map->alias_supply,
1251 : : dev_name(map->alias_dev));
1252 : 0 : *dev = map->alias_dev;
1253 : 0 : *supply = map->alias_supply;
1254 : : }
1255 : 0 : }
1256 : :
1257 : 0 : static struct regulator_dev *regulator_dev_lookup(struct device *dev,
1258 : : const char *supply,
1259 : : int *ret)
1260 : : {
1261 : 0 : struct regulator_dev *r;
1262 : : struct device_node *node;
1263 : : struct regulator_map *map;
1264 : : const char *devname = NULL;
1265 : :
1266 : 0 : regulator_supply_alias(&dev, &supply);
1267 : :
1268 : : /* first do a dt based lookup */
1269 [ # # ][ # # ]: 0 : if (dev && dev->of_node) {
1270 : 0 : node = of_get_regulator(dev, supply);
1271 [ # # ]: 0 : if (node) {
1272 [ # # ]: 0 : list_for_each_entry(r, ®ulator_list, list)
1273 [ # # ][ # # ]: 0 : if (r->dev.parent &&
1274 : 0 : node == r->dev.of_node)
1275 : : return r;
1276 : 0 : *ret = -EPROBE_DEFER;
1277 : 0 : return NULL;
1278 : : } else {
1279 : : /*
1280 : : * If we couldn't even get the node then it's
1281 : : * not just that the device didn't register
1282 : : * yet, there's no node and we'll never
1283 : : * succeed.
1284 : : */
1285 : 0 : *ret = -ENODEV;
1286 : : }
1287 : : }
1288 : :
1289 : : /* if not found, try doing it non-dt way */
1290 [ # # ]: 0 : if (dev)
1291 : : devname = dev_name(dev);
1292 : :
1293 [ # # ]: 0 : list_for_each_entry(r, ®ulator_list, list)
1294 [ # # ]: 0 : if (strcmp(rdev_get_name(r), supply) == 0)
1295 : : return r;
1296 : :
1297 [ # # ]: 0 : list_for_each_entry(map, ®ulator_map_list, list) {
1298 : : /* If the mapping has a device set up it must match */
1299 [ # # ][ # # ]: 0 : if (map->dev_name &&
1300 [ # # ]: 0 : (!devname || strcmp(map->dev_name, devname)))
1301 : 0 : continue;
1302 : :
1303 [ # # ]: 0 : if (strcmp(map->supply, supply) == 0)
1304 : 0 : return map->regulator;
1305 : : }
1306 : :
1307 : :
1308 : : return NULL;
1309 : : }
1310 : :
1311 : : /* Internal regulator request function */
1312 : 0 : static struct regulator *_regulator_get(struct device *dev, const char *id,
1313 : : bool exclusive, bool allow_dummy)
1314 : : {
1315 : : struct regulator_dev *rdev;
1316 : : struct regulator *regulator = ERR_PTR(-EPROBE_DEFER);
1317 : : const char *devname = NULL;
1318 : : int ret;
1319 : :
1320 [ # # ]: 0 : if (id == NULL) {
1321 : 0 : pr_err("get() with no identifier\n");
1322 : 0 : return ERR_PTR(-EINVAL);
1323 : : }
1324 : :
1325 [ # # ]: 0 : if (dev)
1326 : : devname = dev_name(dev);
1327 : :
1328 [ # # ]: 0 : if (have_full_constraints())
1329 : 0 : ret = -ENODEV;
1330 : : else
1331 : 0 : ret = -EPROBE_DEFER;
1332 : :
1333 : 0 : mutex_lock(®ulator_list_mutex);
1334 : :
1335 : 0 : rdev = regulator_dev_lookup(dev, id, &ret);
1336 [ # # ]: 0 : if (rdev)
1337 : : goto found;
1338 : :
1339 : 0 : regulator = ERR_PTR(ret);
1340 : :
1341 : : /*
1342 : : * If we have return value from dev_lookup fail, we do not expect to
1343 : : * succeed, so, quit with appropriate error value
1344 : : */
1345 [ # # ]: 0 : if (ret && ret != -ENODEV)
1346 : : goto out;
1347 : :
1348 [ # # ]: 0 : if (!devname)
1349 : : devname = "deviceless";
1350 : :
1351 : : /*
1352 : : * Assume that a regulator is physically present and enabled
1353 : : * even if it isn't hooked up and just provide a dummy.
1354 : : */
1355 [ # # ][ # # ]: 0 : if (have_full_constraints() && allow_dummy) {
1356 : 0 : pr_warn("%s supply %s not found, using dummy regulator\n",
1357 : : devname, id);
1358 : :
1359 : 0 : rdev = dummy_regulator_rdev;
1360 : 0 : goto found;
1361 : : /* Don't log an error when called from regulator_get_optional() */
1362 [ # # ][ # # ]: 0 : } else if (!have_full_constraints() || exclusive) {
1363 : 0 : dev_warn(dev, "dummy supplies not allowed\n");
1364 : : }
1365 : :
1366 : 0 : mutex_unlock(®ulator_list_mutex);
1367 : 0 : return regulator;
1368 : :
1369 : : found:
1370 [ # # ]: 0 : if (rdev->exclusive) {
1371 : : regulator = ERR_PTR(-EPERM);
1372 : : goto out;
1373 : : }
1374 : :
1375 [ # # ][ # # ]: 0 : if (exclusive && rdev->open_count) {
1376 : : regulator = ERR_PTR(-EBUSY);
1377 : : goto out;
1378 : : }
1379 : :
1380 [ # # ]: 0 : if (!try_module_get(rdev->owner))
1381 : : goto out;
1382 : :
1383 : 0 : regulator = create_regulator(rdev, dev, id);
1384 [ # # ]: 0 : if (regulator == NULL) {
1385 : : regulator = ERR_PTR(-ENOMEM);
1386 : 0 : module_put(rdev->owner);
1387 : 0 : goto out;
1388 : : }
1389 : :
1390 : 0 : rdev->open_count++;
1391 [ # # ]: 0 : if (exclusive) {
1392 : 0 : rdev->exclusive = 1;
1393 : :
1394 : 0 : ret = _regulator_is_enabled(rdev);
1395 [ # # ]: 0 : if (ret > 0)
1396 : 0 : rdev->use_count = 1;
1397 : : else
1398 : 0 : rdev->use_count = 0;
1399 : : }
1400 : :
1401 : : out:
1402 : 0 : mutex_unlock(®ulator_list_mutex);
1403 : :
1404 : 0 : return regulator;
1405 : : }
1406 : :
1407 : : /**
1408 : : * regulator_get - lookup and obtain a reference to a regulator.
1409 : : * @dev: device for regulator "consumer"
1410 : : * @id: Supply name or regulator ID.
1411 : : *
1412 : : * Returns a struct regulator corresponding to the regulator producer,
1413 : : * or IS_ERR() condition containing errno.
1414 : : *
1415 : : * Use of supply names configured via regulator_set_device_supply() is
1416 : : * strongly encouraged. It is recommended that the supply name used
1417 : : * should match the name used for the supply and/or the relevant
1418 : : * device pins in the datasheet.
1419 : : */
1420 : 0 : struct regulator *regulator_get(struct device *dev, const char *id)
1421 : : {
1422 : 0 : return _regulator_get(dev, id, false, true);
1423 : : }
1424 : : EXPORT_SYMBOL_GPL(regulator_get);
1425 : :
1426 : : /**
1427 : : * regulator_get_exclusive - obtain exclusive access to a regulator.
1428 : : * @dev: device for regulator "consumer"
1429 : : * @id: Supply name or regulator ID.
1430 : : *
1431 : : * Returns a struct regulator corresponding to the regulator producer,
1432 : : * or IS_ERR() condition containing errno. Other consumers will be
1433 : : * unable to obtain this reference is held and the use count for the
1434 : : * regulator will be initialised to reflect the current state of the
1435 : : * regulator.
1436 : : *
1437 : : * This is intended for use by consumers which cannot tolerate shared
1438 : : * use of the regulator such as those which need to force the
1439 : : * regulator off for correct operation of the hardware they are
1440 : : * controlling.
1441 : : *
1442 : : * Use of supply names configured via regulator_set_device_supply() is
1443 : : * strongly encouraged. It is recommended that the supply name used
1444 : : * should match the name used for the supply and/or the relevant
1445 : : * device pins in the datasheet.
1446 : : */
1447 : 0 : struct regulator *regulator_get_exclusive(struct device *dev, const char *id)
1448 : : {
1449 : 0 : return _regulator_get(dev, id, true, false);
1450 : : }
1451 : : EXPORT_SYMBOL_GPL(regulator_get_exclusive);
1452 : :
1453 : : /**
1454 : : * regulator_get_optional - obtain optional access to a regulator.
1455 : : * @dev: device for regulator "consumer"
1456 : : * @id: Supply name or regulator ID.
1457 : : *
1458 : : * Returns a struct regulator corresponding to the regulator producer,
1459 : : * or IS_ERR() condition containing errno. Other consumers will be
1460 : : * unable to obtain this reference is held and the use count for the
1461 : : * regulator will be initialised to reflect the current state of the
1462 : : * regulator.
1463 : : *
1464 : : * This is intended for use by consumers for devices which can have
1465 : : * some supplies unconnected in normal use, such as some MMC devices.
1466 : : * It can allow the regulator core to provide stub supplies for other
1467 : : * supplies requested using normal regulator_get() calls without
1468 : : * disrupting the operation of drivers that can handle absent
1469 : : * supplies.
1470 : : *
1471 : : * Use of supply names configured via regulator_set_device_supply() is
1472 : : * strongly encouraged. It is recommended that the supply name used
1473 : : * should match the name used for the supply and/or the relevant
1474 : : * device pins in the datasheet.
1475 : : */
1476 : 0 : struct regulator *regulator_get_optional(struct device *dev, const char *id)
1477 : : {
1478 : 0 : return _regulator_get(dev, id, false, false);
1479 : : }
1480 : : EXPORT_SYMBOL_GPL(regulator_get_optional);
1481 : :
1482 : : /* Locks held by regulator_put() */
1483 : 0 : static void _regulator_put(struct regulator *regulator)
1484 : : {
1485 : : struct regulator_dev *rdev;
1486 : :
1487 [ # # ][ # # ]: 0 : if (regulator == NULL || IS_ERR(regulator))
1488 : 0 : return;
1489 : :
1490 : 0 : rdev = regulator->rdev;
1491 : :
1492 : 0 : debugfs_remove_recursive(regulator->debugfs);
1493 : :
1494 : : /* remove any sysfs entries */
1495 [ # # ]: 0 : if (regulator->dev)
1496 : 0 : sysfs_remove_link(&rdev->dev.kobj, regulator->supply_name);
1497 : 0 : kfree(regulator->supply_name);
1498 : : list_del(®ulator->list);
1499 : 0 : kfree(regulator);
1500 : :
1501 : 0 : rdev->open_count--;
1502 : 0 : rdev->exclusive = 0;
1503 : :
1504 : 0 : module_put(rdev->owner);
1505 : : }
1506 : :
1507 : : /**
1508 : : * regulator_put - "free" the regulator source
1509 : : * @regulator: regulator source
1510 : : *
1511 : : * Note: drivers must ensure that all regulator_enable calls made on this
1512 : : * regulator source are balanced by regulator_disable calls prior to calling
1513 : : * this function.
1514 : : */
1515 : 0 : void regulator_put(struct regulator *regulator)
1516 : : {
1517 : 0 : mutex_lock(®ulator_list_mutex);
1518 : 0 : _regulator_put(regulator);
1519 : 0 : mutex_unlock(®ulator_list_mutex);
1520 : 0 : }
1521 : : EXPORT_SYMBOL_GPL(regulator_put);
1522 : :
1523 : : /**
1524 : : * regulator_register_supply_alias - Provide device alias for supply lookup
1525 : : *
1526 : : * @dev: device that will be given as the regulator "consumer"
1527 : : * @id: Supply name or regulator ID
1528 : : * @alias_dev: device that should be used to lookup the supply
1529 : : * @alias_id: Supply name or regulator ID that should be used to lookup the
1530 : : * supply
1531 : : *
1532 : : * All lookups for id on dev will instead be conducted for alias_id on
1533 : : * alias_dev.
1534 : : */
1535 : 0 : int regulator_register_supply_alias(struct device *dev, const char *id,
1536 : : struct device *alias_dev,
1537 : : const char *alias_id)
1538 : : {
1539 : : struct regulator_supply_alias *map;
1540 : :
1541 : 0 : map = regulator_find_supply_alias(dev, id);
1542 [ # # ]: 0 : if (map)
1543 : : return -EEXIST;
1544 : :
1545 : : map = kzalloc(sizeof(struct regulator_supply_alias), GFP_KERNEL);
1546 [ # # ]: 0 : if (!map)
1547 : : return -ENOMEM;
1548 : :
1549 : 0 : map->src_dev = dev;
1550 : 0 : map->src_supply = id;
1551 : 0 : map->alias_dev = alias_dev;
1552 : 0 : map->alias_supply = alias_id;
1553 : :
1554 : 0 : list_add(&map->list, ®ulator_supply_alias_list);
1555 : :
1556 : 0 : pr_info("Adding alias for supply %s,%s -> %s,%s\n",
1557 : : id, dev_name(dev), alias_id, dev_name(alias_dev));
1558 : :
1559 : 0 : return 0;
1560 : : }
1561 : : EXPORT_SYMBOL_GPL(regulator_register_supply_alias);
1562 : :
1563 : : /**
1564 : : * regulator_unregister_supply_alias - Remove device alias
1565 : : *
1566 : : * @dev: device that will be given as the regulator "consumer"
1567 : : * @id: Supply name or regulator ID
1568 : : *
1569 : : * Remove a lookup alias if one exists for id on dev.
1570 : : */
1571 : 0 : void regulator_unregister_supply_alias(struct device *dev, const char *id)
1572 : : {
1573 : : struct regulator_supply_alias *map;
1574 : :
1575 : 0 : map = regulator_find_supply_alias(dev, id);
1576 [ # # ]: 0 : if (map) {
1577 : : list_del(&map->list);
1578 : 0 : kfree(map);
1579 : : }
1580 : 0 : }
1581 : : EXPORT_SYMBOL_GPL(regulator_unregister_supply_alias);
1582 : :
1583 : : /**
1584 : : * regulator_bulk_register_supply_alias - register multiple aliases
1585 : : *
1586 : : * @dev: device that will be given as the regulator "consumer"
1587 : : * @id: List of supply names or regulator IDs
1588 : : * @alias_dev: device that should be used to lookup the supply
1589 : : * @alias_id: List of supply names or regulator IDs that should be used to
1590 : : * lookup the supply
1591 : : * @num_id: Number of aliases to register
1592 : : *
1593 : : * @return 0 on success, an errno on failure.
1594 : : *
1595 : : * This helper function allows drivers to register several supply
1596 : : * aliases in one operation. If any of the aliases cannot be
1597 : : * registered any aliases that were registered will be removed
1598 : : * before returning to the caller.
1599 : : */
1600 : 0 : int regulator_bulk_register_supply_alias(struct device *dev, const char **id,
1601 : : struct device *alias_dev,
1602 : : const char **alias_id,
1603 : : int num_id)
1604 : : {
1605 : : int i;
1606 : : int ret;
1607 : :
1608 [ # # ]: 0 : for (i = 0; i < num_id; ++i) {
1609 : 0 : ret = regulator_register_supply_alias(dev, id[i], alias_dev,
1610 : 0 : alias_id[i]);
1611 [ # # ]: 0 : if (ret < 0)
1612 : : goto err;
1613 : : }
1614 : :
1615 : : return 0;
1616 : :
1617 : : err:
1618 : 0 : dev_err(dev,
1619 : : "Failed to create supply alias %s,%s -> %s,%s\n",
1620 : : id[i], dev_name(dev), alias_id[i], dev_name(alias_dev));
1621 : :
1622 [ # # ]: 0 : while (--i >= 0)
1623 : 0 : regulator_unregister_supply_alias(dev, id[i]);
1624 : :
1625 : : return ret;
1626 : : }
1627 : : EXPORT_SYMBOL_GPL(regulator_bulk_register_supply_alias);
1628 : :
1629 : : /**
1630 : : * regulator_bulk_unregister_supply_alias - unregister multiple aliases
1631 : : *
1632 : : * @dev: device that will be given as the regulator "consumer"
1633 : : * @id: List of supply names or regulator IDs
1634 : : * @num_id: Number of aliases to unregister
1635 : : *
1636 : : * This helper function allows drivers to unregister several supply
1637 : : * aliases in one operation.
1638 : : */
1639 : 0 : void regulator_bulk_unregister_supply_alias(struct device *dev,
1640 : : const char **id,
1641 : : int num_id)
1642 : : {
1643 : : int i;
1644 : :
1645 [ # # ]: 0 : for (i = 0; i < num_id; ++i)
1646 : 0 : regulator_unregister_supply_alias(dev, id[i]);
1647 : 0 : }
1648 : : EXPORT_SYMBOL_GPL(regulator_bulk_unregister_supply_alias);
1649 : :
1650 : :
1651 : : /* Manage enable GPIO list. Same GPIO pin can be shared among regulators */
1652 : 0 : static int regulator_ena_gpio_request(struct regulator_dev *rdev,
1653 : : const struct regulator_config *config)
1654 : : {
1655 : : struct regulator_enable_gpio *pin;
1656 : : int ret;
1657 : :
1658 [ # # ]: 0 : list_for_each_entry(pin, ®ulator_ena_gpio_list, list) {
1659 [ # # ]: 0 : if (pin->gpio == config->ena_gpio) {
1660 : : rdev_dbg(rdev, "GPIO %d is already used\n",
1661 : : config->ena_gpio);
1662 : : goto update_ena_gpio_to_rdev;
1663 : : }
1664 : : }
1665 : :
1666 : 0 : ret = gpio_request_one(config->ena_gpio,
1667 : 0 : GPIOF_DIR_OUT | config->ena_gpio_flags,
1668 : : rdev_get_name(rdev));
1669 [ # # ]: 0 : if (ret)
1670 : : return ret;
1671 : :
1672 : : pin = kzalloc(sizeof(struct regulator_enable_gpio), GFP_KERNEL);
1673 [ # # ]: 0 : if (pin == NULL) {
1674 : 0 : gpio_free(config->ena_gpio);
1675 : 0 : return -ENOMEM;
1676 : : }
1677 : :
1678 : 0 : pin->gpio = config->ena_gpio;
1679 : 0 : pin->ena_gpio_invert = config->ena_gpio_invert;
1680 : 0 : list_add(&pin->list, ®ulator_ena_gpio_list);
1681 : :
1682 : : update_ena_gpio_to_rdev:
1683 : 0 : pin->request_count++;
1684 : 0 : rdev->ena_pin = pin;
1685 : 0 : return 0;
1686 : : }
1687 : :
1688 : 0 : static void regulator_ena_gpio_free(struct regulator_dev *rdev)
1689 : : {
1690 : : struct regulator_enable_gpio *pin, *n;
1691 : :
1692 [ # # ]: 0 : if (!rdev->ena_pin)
1693 : 0 : return;
1694 : :
1695 : : /* Free the GPIO only in case of no use */
1696 [ # # ]: 0 : list_for_each_entry_safe(pin, n, ®ulator_ena_gpio_list, list) {
1697 [ # # ]: 0 : if (pin->gpio == rdev->ena_pin->gpio) {
1698 [ # # ]: 0 : if (pin->request_count <= 1) {
1699 : 0 : pin->request_count = 0;
1700 : 0 : gpio_free(pin->gpio);
1701 : : list_del(&pin->list);
1702 : 0 : kfree(pin);
1703 : : } else {
1704 : 0 : pin->request_count--;
1705 : : }
1706 : : }
1707 : : }
1708 : : }
1709 : :
1710 : : /**
1711 : : * regulator_ena_gpio_ctrl - balance enable_count of each GPIO and actual GPIO pin control
1712 : : * @rdev: regulator_dev structure
1713 : : * @enable: enable GPIO at initial use?
1714 : : *
1715 : : * GPIO is enabled in case of initial use. (enable_count is 0)
1716 : : * GPIO is disabled when it is not shared any more. (enable_count <= 1)
1717 : : */
1718 : 0 : static int regulator_ena_gpio_ctrl(struct regulator_dev *rdev, bool enable)
1719 : : {
1720 : 0 : struct regulator_enable_gpio *pin = rdev->ena_pin;
1721 : :
1722 [ # # ]: 0 : if (!pin)
1723 : : return -EINVAL;
1724 : :
1725 [ # # ]: 0 : if (enable) {
1726 : : /* Enable GPIO at initial use */
1727 [ # # ]: 0 : if (pin->enable_count == 0)
1728 : 0 : gpio_set_value_cansleep(pin->gpio,
1729 : 0 : !pin->ena_gpio_invert);
1730 : :
1731 : 0 : pin->enable_count++;
1732 : : } else {
1733 [ # # ]: 0 : if (pin->enable_count > 1) {
1734 : 0 : pin->enable_count--;
1735 : : return 0;
1736 : : }
1737 : :
1738 : : /* Disable GPIO if not used */
1739 [ # # ]: 0 : if (pin->enable_count <= 1) {
1740 : 0 : gpio_set_value_cansleep(pin->gpio,
1741 : 0 : pin->ena_gpio_invert);
1742 : 0 : pin->enable_count = 0;
1743 : : }
1744 : : }
1745 : :
1746 : : return 0;
1747 : : }
1748 : :
1749 : 0 : static int _regulator_do_enable(struct regulator_dev *rdev)
1750 : : {
1751 : : int ret, delay;
1752 : :
1753 : : /* Query before enabling in case configuration dependent. */
1754 : 0 : ret = _regulator_get_enable_time(rdev);
1755 [ # # ]: 0 : if (ret >= 0) {
1756 : : delay = ret;
1757 : : } else {
1758 : 0 : rdev_warn(rdev, "enable_time() failed: %d\n", ret);
1759 : : delay = 0;
1760 : : }
1761 : :
1762 : : trace_regulator_enable(rdev_get_name(rdev));
1763 : :
1764 [ # # ]: 0 : if (rdev->ena_pin) {
1765 : 0 : ret = regulator_ena_gpio_ctrl(rdev, true);
1766 [ # # ]: 0 : if (ret < 0)
1767 : : return ret;
1768 : 0 : rdev->ena_gpio_state = 1;
1769 [ # # ]: 0 : } else if (rdev->desc->ops->enable) {
1770 : 0 : ret = rdev->desc->ops->enable(rdev);
1771 [ # # ]: 0 : if (ret < 0)
1772 : : return ret;
1773 : : } else {
1774 : : return -EINVAL;
1775 : : }
1776 : :
1777 : : /* Allow the regulator to ramp; it would be useful to extend
1778 : : * this for bulk operations so that the regulators can ramp
1779 : : * together. */
1780 : : trace_regulator_enable_delay(rdev_get_name(rdev));
1781 : :
1782 : : /*
1783 : : * Delay for the requested amount of time as per the guidelines in:
1784 : : *
1785 : : * Documentation/timers/timers-howto.txt
1786 : : *
1787 : : * The assumption here is that regulators will never be enabled in
1788 : : * atomic context and therefore sleeping functions can be used.
1789 : : */
1790 [ # # ]: 0 : if (delay) {
1791 : 0 : unsigned int ms = delay / 1000;
1792 : 0 : unsigned int us = delay % 1000;
1793 : :
1794 [ # # ]: 0 : if (ms > 0) {
1795 : : /*
1796 : : * For small enough values, handle super-millisecond
1797 : : * delays in the usleep_range() call below.
1798 : : */
1799 [ # # ]: 0 : if (ms < 20)
1800 : 0 : us += ms * 1000;
1801 : : else
1802 : 0 : msleep(ms);
1803 : : }
1804 : :
1805 : : /*
1806 : : * Give the scheduler some room to coalesce with any other
1807 : : * wakeup sources. For delays shorter than 10 us, don't even
1808 : : * bother setting up high-resolution timers and just busy-
1809 : : * loop.
1810 : : */
1811 [ # # ]: 0 : if (us >= 10)
1812 : 0 : usleep_range(us, us + 100);
1813 : : else
1814 [ # # ][ # # ]: 0 : udelay(us);
1815 : : }
1816 : :
1817 : : trace_regulator_enable_complete(rdev_get_name(rdev));
1818 : :
1819 : : return 0;
1820 : : }
1821 : :
1822 : : /* locks held by regulator_enable() */
1823 : 0 : static int _regulator_enable(struct regulator_dev *rdev)
1824 : : {
1825 : : int ret;
1826 : :
1827 : : /* check voltage and requested load before enabling */
1828 [ # # ][ # # ]: 0 : if (rdev->constraints &&
1829 : 0 : (rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_DRMS))
1830 : 0 : drms_uA_update(rdev);
1831 : :
1832 [ # # ]: 0 : if (rdev->use_count == 0) {
1833 : : /* The regulator may on if it's not switchable or left on */
1834 : : ret = _regulator_is_enabled(rdev);
1835 [ # # ]: 0 : if (ret == -EINVAL || ret == 0) {
1836 [ # # ]: 0 : if (!_regulator_can_change_status(rdev))
1837 : : return -EPERM;
1838 : :
1839 : 0 : ret = _regulator_do_enable(rdev);
1840 [ # # ]: 0 : if (ret < 0)
1841 : : return ret;
1842 : :
1843 [ # # ]: 0 : } else if (ret < 0) {
1844 : 0 : rdev_err(rdev, "is_enabled() failed: %d\n", ret);
1845 : 0 : return ret;
1846 : : }
1847 : : /* Fallthrough on positive return values - already enabled */
1848 : : }
1849 : :
1850 : 0 : rdev->use_count++;
1851 : :
1852 : 0 : return 0;
1853 : : }
1854 : :
1855 : : /**
1856 : : * regulator_enable - enable regulator output
1857 : : * @regulator: regulator source
1858 : : *
1859 : : * Request that the regulator be enabled with the regulator output at
1860 : : * the predefined voltage or current value. Calls to regulator_enable()
1861 : : * must be balanced with calls to regulator_disable().
1862 : : *
1863 : : * NOTE: the output value can be set by other drivers, boot loader or may be
1864 : : * hardwired in the regulator.
1865 : : */
1866 : 0 : int regulator_enable(struct regulator *regulator)
1867 : : {
1868 : 0 : struct regulator_dev *rdev = regulator->rdev;
1869 : : int ret = 0;
1870 : :
1871 [ # # ]: 0 : if (regulator->always_on)
1872 : : return 0;
1873 : :
1874 [ # # ]: 0 : if (rdev->supply) {
1875 : 0 : ret = regulator_enable(rdev->supply);
1876 [ # # ]: 0 : if (ret != 0)
1877 : : return ret;
1878 : : }
1879 : :
1880 : 0 : mutex_lock(&rdev->mutex);
1881 : 0 : ret = _regulator_enable(rdev);
1882 : 0 : mutex_unlock(&rdev->mutex);
1883 : :
1884 [ # # ][ # # ]: 0 : if (ret != 0 && rdev->supply)
1885 : 0 : regulator_disable(rdev->supply);
1886 : :
1887 : 0 : return ret;
1888 : : }
1889 : : EXPORT_SYMBOL_GPL(regulator_enable);
1890 : :
1891 : 0 : static int _regulator_do_disable(struct regulator_dev *rdev)
1892 : : {
1893 : : int ret;
1894 : :
1895 : : trace_regulator_disable(rdev_get_name(rdev));
1896 : :
1897 [ # # ]: 0 : if (rdev->ena_pin) {
1898 : 0 : ret = regulator_ena_gpio_ctrl(rdev, false);
1899 [ # # ]: 0 : if (ret < 0)
1900 : : return ret;
1901 : 0 : rdev->ena_gpio_state = 0;
1902 : :
1903 [ # # ]: 0 : } else if (rdev->desc->ops->disable) {
1904 : 0 : ret = rdev->desc->ops->disable(rdev);
1905 [ # # ]: 0 : if (ret != 0)
1906 : : return ret;
1907 : : }
1908 : :
1909 : : trace_regulator_disable_complete(rdev_get_name(rdev));
1910 : :
1911 : : return 0;
1912 : : }
1913 : :
1914 : : /* locks held by regulator_disable() */
1915 : 0 : static int _regulator_disable(struct regulator_dev *rdev)
1916 : : {
1917 : : int ret = 0;
1918 : :
1919 [ # # ][ # # ]: 0 : if (WARN(rdev->use_count <= 0,
1920 : : "unbalanced disables for %s\n", rdev_get_name(rdev)))
1921 : : return -EIO;
1922 : :
1923 : : /* are we the last user and permitted to disable ? */
1924 [ # # ][ # # ]: 0 : if (rdev->use_count == 1 &&
1925 [ # # ]: 0 : (rdev->constraints && !rdev->constraints->always_on)) {
1926 : :
1927 : : /* we are last user */
1928 [ # # ]: 0 : if (_regulator_can_change_status(rdev)) {
1929 : 0 : ret = _regulator_do_disable(rdev);
1930 [ # # ]: 0 : if (ret < 0) {
1931 : 0 : rdev_err(rdev, "failed to disable\n");
1932 : 0 : return ret;
1933 : : }
1934 : : _notifier_call_chain(rdev, REGULATOR_EVENT_DISABLE,
1935 : : NULL);
1936 : : }
1937 : :
1938 : 0 : rdev->use_count = 0;
1939 [ # # ]: 0 : } else if (rdev->use_count > 1) {
1940 : :
1941 [ # # ][ # # ]: 0 : if (rdev->constraints &&
1942 : 0 : (rdev->constraints->valid_ops_mask &
1943 : : REGULATOR_CHANGE_DRMS))
1944 : 0 : drms_uA_update(rdev);
1945 : :
1946 : 0 : rdev->use_count--;
1947 : : }
1948 : :
1949 : 0 : return ret;
1950 : : }
1951 : :
1952 : : /**
1953 : : * regulator_disable - disable regulator output
1954 : : * @regulator: regulator source
1955 : : *
1956 : : * Disable the regulator output voltage or current. Calls to
1957 : : * regulator_enable() must be balanced with calls to
1958 : : * regulator_disable().
1959 : : *
1960 : : * NOTE: this will only disable the regulator output if no other consumer
1961 : : * devices have it enabled, the regulator device supports disabling and
1962 : : * machine constraints permit this operation.
1963 : : */
1964 : 0 : int regulator_disable(struct regulator *regulator)
1965 : : {
1966 : 0 : struct regulator_dev *rdev = regulator->rdev;
1967 : : int ret = 0;
1968 : :
1969 [ # # ]: 0 : if (regulator->always_on)
1970 : : return 0;
1971 : :
1972 : 0 : mutex_lock(&rdev->mutex);
1973 : 0 : ret = _regulator_disable(rdev);
1974 : 0 : mutex_unlock(&rdev->mutex);
1975 : :
1976 [ # # ][ # # ]: 0 : if (ret == 0 && rdev->supply)
1977 : 0 : regulator_disable(rdev->supply);
1978 : :
1979 : 0 : return ret;
1980 : : }
1981 : : EXPORT_SYMBOL_GPL(regulator_disable);
1982 : :
1983 : : /* locks held by regulator_force_disable() */
1984 : 0 : static int _regulator_force_disable(struct regulator_dev *rdev)
1985 : : {
1986 : : int ret = 0;
1987 : :
1988 : 0 : ret = _regulator_do_disable(rdev);
1989 [ # # ]: 0 : if (ret < 0) {
1990 : 0 : rdev_err(rdev, "failed to force disable\n");
1991 : 0 : return ret;
1992 : : }
1993 : :
1994 : : _notifier_call_chain(rdev, REGULATOR_EVENT_FORCE_DISABLE |
1995 : : REGULATOR_EVENT_DISABLE, NULL);
1996 : :
1997 : 0 : return 0;
1998 : : }
1999 : :
2000 : : /**
2001 : : * regulator_force_disable - force disable regulator output
2002 : : * @regulator: regulator source
2003 : : *
2004 : : * Forcibly disable the regulator output voltage or current.
2005 : : * NOTE: this *will* disable the regulator output even if other consumer
2006 : : * devices have it enabled. This should be used for situations when device
2007 : : * damage will likely occur if the regulator is not disabled (e.g. over temp).
2008 : : */
2009 : 0 : int regulator_force_disable(struct regulator *regulator)
2010 : : {
2011 : 0 : struct regulator_dev *rdev = regulator->rdev;
2012 : : int ret;
2013 : :
2014 : 0 : mutex_lock(&rdev->mutex);
2015 : 0 : regulator->uA_load = 0;
2016 : 0 : ret = _regulator_force_disable(regulator->rdev);
2017 : 0 : mutex_unlock(&rdev->mutex);
2018 : :
2019 [ # # ]: 0 : if (rdev->supply)
2020 [ # # ]: 0 : while (rdev->open_count--)
2021 : 0 : regulator_disable(rdev->supply);
2022 : :
2023 : 0 : return ret;
2024 : : }
2025 : : EXPORT_SYMBOL_GPL(regulator_force_disable);
2026 : :
2027 : 0 : static void regulator_disable_work(struct work_struct *work)
2028 : : {
2029 : 0 : struct regulator_dev *rdev = container_of(work, struct regulator_dev,
2030 : : disable_work.work);
2031 : : int count, i, ret;
2032 : :
2033 : 0 : mutex_lock(&rdev->mutex);
2034 : :
2035 [ # # ]: 0 : BUG_ON(!rdev->deferred_disables);
2036 : :
2037 : : count = rdev->deferred_disables;
2038 : 0 : rdev->deferred_disables = 0;
2039 : :
2040 [ # # ]: 0 : for (i = 0; i < count; i++) {
2041 : 0 : ret = _regulator_disable(rdev);
2042 [ # # ]: 0 : if (ret != 0)
2043 : 0 : rdev_err(rdev, "Deferred disable failed: %d\n", ret);
2044 : : }
2045 : :
2046 : 0 : mutex_unlock(&rdev->mutex);
2047 : :
2048 [ # # ]: 0 : if (rdev->supply) {
2049 [ # # ]: 0 : for (i = 0; i < count; i++) {
2050 : 0 : ret = regulator_disable(rdev->supply);
2051 [ # # ]: 0 : if (ret != 0) {
2052 : 0 : rdev_err(rdev,
2053 : : "Supply disable failed: %d\n", ret);
2054 : : }
2055 : : }
2056 : : }
2057 : 0 : }
2058 : :
2059 : : /**
2060 : : * regulator_disable_deferred - disable regulator output with delay
2061 : : * @regulator: regulator source
2062 : : * @ms: miliseconds until the regulator is disabled
2063 : : *
2064 : : * Execute regulator_disable() on the regulator after a delay. This
2065 : : * is intended for use with devices that require some time to quiesce.
2066 : : *
2067 : : * NOTE: this will only disable the regulator output if no other consumer
2068 : : * devices have it enabled, the regulator device supports disabling and
2069 : : * machine constraints permit this operation.
2070 : : */
2071 : 0 : int regulator_disable_deferred(struct regulator *regulator, int ms)
2072 : : {
2073 : 0 : struct regulator_dev *rdev = regulator->rdev;
2074 : : int ret;
2075 : :
2076 [ # # ]: 0 : if (regulator->always_on)
2077 : : return 0;
2078 : :
2079 [ # # ]: 0 : if (!ms)
2080 : 0 : return regulator_disable(regulator);
2081 : :
2082 : 0 : mutex_lock(&rdev->mutex);
2083 : 0 : rdev->deferred_disables++;
2084 : 0 : mutex_unlock(&rdev->mutex);
2085 : :
2086 : 0 : ret = queue_delayed_work(system_power_efficient_wq,
2087 : : &rdev->disable_work,
2088 : : msecs_to_jiffies(ms));
2089 [ # # ]: 0 : if (ret < 0)
2090 : 0 : return ret;
2091 : : else
2092 : : return 0;
2093 : : }
2094 : : EXPORT_SYMBOL_GPL(regulator_disable_deferred);
2095 : :
2096 : : static int _regulator_is_enabled(struct regulator_dev *rdev)
2097 : : {
2098 : : /* A GPIO control always takes precedence */
2099 [ # # ][ # # ]: 0 : if (rdev->ena_pin)
[ # # # # ]
[ # # ][ # # ]
[ # # # # ]
2100 : 0 : return rdev->ena_gpio_state;
2101 : :
2102 : : /* If we don't know then assume that the regulator is always on */
2103 [ # # ][ # # ]: 0 : if (!rdev->desc->ops->is_enabled)
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
2104 : : return 1;
2105 : :
2106 : 0 : return rdev->desc->ops->is_enabled(rdev);
2107 : : }
2108 : :
2109 : : /**
2110 : : * regulator_is_enabled - is the regulator output enabled
2111 : : * @regulator: regulator source
2112 : : *
2113 : : * Returns positive if the regulator driver backing the source/client
2114 : : * has requested that the device be enabled, zero if it hasn't, else a
2115 : : * negative errno code.
2116 : : *
2117 : : * Note that the device backing this regulator handle can have multiple
2118 : : * users, so it might be enabled even if regulator_enable() was never
2119 : : * called for this particular source.
2120 : : */
2121 : 0 : int regulator_is_enabled(struct regulator *regulator)
2122 : : {
2123 : : int ret;
2124 : :
2125 [ # # ]: 0 : if (regulator->always_on)
2126 : : return 1;
2127 : :
2128 : 0 : mutex_lock(®ulator->rdev->mutex);
2129 : 0 : ret = _regulator_is_enabled(regulator->rdev);
2130 : 0 : mutex_unlock(®ulator->rdev->mutex);
2131 : :
2132 : 0 : return ret;
2133 : : }
2134 : : EXPORT_SYMBOL_GPL(regulator_is_enabled);
2135 : :
2136 : : /**
2137 : : * regulator_can_change_voltage - check if regulator can change voltage
2138 : : * @regulator: regulator source
2139 : : *
2140 : : * Returns positive if the regulator driver backing the source/client
2141 : : * can change its voltage, false otherwise. Usefull for detecting fixed
2142 : : * or dummy regulators and disabling voltage change logic in the client
2143 : : * driver.
2144 : : */
2145 : 0 : int regulator_can_change_voltage(struct regulator *regulator)
2146 : : {
2147 : 0 : struct regulator_dev *rdev = regulator->rdev;
2148 : :
2149 [ # # ][ # # ]: 0 : if (rdev->constraints &&
2150 : 0 : (rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) {
2151 [ # # ]: 0 : if (rdev->desc->n_voltages - rdev->desc->linear_min_sel > 1)
2152 : : return 1;
2153 : :
2154 [ # # ][ # # ]: 0 : if (rdev->desc->continuous_voltage_range &&
2155 [ # # ][ # # ]: 0 : rdev->constraints->min_uV && rdev->constraints->max_uV &&
2156 : : rdev->constraints->min_uV != rdev->constraints->max_uV)
2157 : : return 1;
2158 : : }
2159 : :
2160 : 0 : return 0;
2161 : : }
2162 : : EXPORT_SYMBOL_GPL(regulator_can_change_voltage);
2163 : :
2164 : : /**
2165 : : * regulator_count_voltages - count regulator_list_voltage() selectors
2166 : : * @regulator: regulator source
2167 : : *
2168 : : * Returns number of selectors, or negative errno. Selectors are
2169 : : * numbered starting at zero, and typically correspond to bitfields
2170 : : * in hardware registers.
2171 : : */
2172 : 0 : int regulator_count_voltages(struct regulator *regulator)
2173 : : {
2174 : 0 : struct regulator_dev *rdev = regulator->rdev;
2175 : :
2176 [ # # ][ # # ]: 0 : return rdev->desc->n_voltages ? : -EINVAL;
2177 : : }
2178 : : EXPORT_SYMBOL_GPL(regulator_count_voltages);
2179 : :
2180 : : /**
2181 : : * regulator_list_voltage - enumerate supported voltages
2182 : : * @regulator: regulator source
2183 : : * @selector: identify voltage to list
2184 : : * Context: can sleep
2185 : : *
2186 : : * Returns a voltage that can be passed to @regulator_set_voltage(),
2187 : : * zero if this selector code can't be used on this system, or a
2188 : : * negative errno.
2189 : : */
2190 : 0 : int regulator_list_voltage(struct regulator *regulator, unsigned selector)
2191 : : {
2192 : 0 : struct regulator_dev *rdev = regulator->rdev;
2193 : 0 : struct regulator_ops *ops = rdev->desc->ops;
2194 : : int ret;
2195 : :
2196 [ # # ][ # # ]: 0 : if (rdev->desc->fixed_uV && rdev->desc->n_voltages == 1 && !selector)
[ # # ]
2197 : : return rdev->desc->fixed_uV;
2198 : :
2199 [ # # ][ # # ]: 0 : if (!ops->list_voltage || selector >= rdev->desc->n_voltages)
2200 : : return -EINVAL;
2201 : :
2202 : 0 : mutex_lock(&rdev->mutex);
2203 : 0 : ret = ops->list_voltage(rdev, selector);
2204 : 0 : mutex_unlock(&rdev->mutex);
2205 : :
2206 [ # # ]: 0 : if (ret > 0) {
2207 [ # # ]: 0 : if (ret < rdev->constraints->min_uV)
2208 : : ret = 0;
2209 [ # # ]: 0 : else if (ret > rdev->constraints->max_uV)
2210 : : ret = 0;
2211 : : }
2212 : :
2213 : 0 : return ret;
2214 : : }
2215 : : EXPORT_SYMBOL_GPL(regulator_list_voltage);
2216 : :
2217 : : /**
2218 : : * regulator_get_linear_step - return the voltage step size between VSEL values
2219 : : * @regulator: regulator source
2220 : : *
2221 : : * Returns the voltage step size between VSEL values for linear
2222 : : * regulators, or return 0 if the regulator isn't a linear regulator.
2223 : : */
2224 : 0 : unsigned int regulator_get_linear_step(struct regulator *regulator)
2225 : : {
2226 : 0 : struct regulator_dev *rdev = regulator->rdev;
2227 : :
2228 : 0 : return rdev->desc->uV_step;
2229 : : }
2230 : : EXPORT_SYMBOL_GPL(regulator_get_linear_step);
2231 : :
2232 : : /**
2233 : : * regulator_is_supported_voltage - check if a voltage range can be supported
2234 : : *
2235 : : * @regulator: Regulator to check.
2236 : : * @min_uV: Minimum required voltage in uV.
2237 : : * @max_uV: Maximum required voltage in uV.
2238 : : *
2239 : : * Returns a boolean or a negative error code.
2240 : : */
2241 : 0 : int regulator_is_supported_voltage(struct regulator *regulator,
2242 : : int min_uV, int max_uV)
2243 : : {
2244 : 0 : struct regulator_dev *rdev = regulator->rdev;
2245 : : int i, voltages, ret;
2246 : :
2247 : : /* If we can't change voltage check the current voltage */
2248 [ # # ]: 0 : if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) {
2249 : 0 : ret = regulator_get_voltage(regulator);
2250 [ # # ]: 0 : if (ret >= 0)
2251 : 0 : return min_uV <= ret && ret <= max_uV;
2252 : : else
2253 : : return ret;
2254 : : }
2255 : :
2256 : : /* Any voltage within constrains range is fine? */
2257 [ # # ]: 0 : if (rdev->desc->continuous_voltage_range)
2258 [ # # ][ # # ]: 0 : return min_uV >= rdev->constraints->min_uV &&
2259 : 0 : max_uV <= rdev->constraints->max_uV;
2260 : :
2261 : : ret = regulator_count_voltages(regulator);
2262 [ # # ]: 0 : if (ret < 0)
2263 : : return ret;
2264 : : voltages = ret;
2265 : :
2266 [ # # ]: 0 : for (i = 0; i < voltages; i++) {
2267 : 0 : ret = regulator_list_voltage(regulator, i);
2268 : :
2269 [ # # ]: 0 : if (ret >= min_uV && ret <= max_uV)
2270 : : return 1;
2271 : : }
2272 : :
2273 : : return 0;
2274 : : }
2275 : : EXPORT_SYMBOL_GPL(regulator_is_supported_voltage);
2276 : :
2277 : 0 : static int _regulator_do_set_voltage(struct regulator_dev *rdev,
2278 : : int min_uV, int max_uV)
2279 : : {
2280 : : int ret;
2281 : : int delay = 0;
2282 : : int best_val = 0;
2283 : : unsigned int selector;
2284 : : int old_selector = -1;
2285 : :
2286 : : trace_regulator_set_voltage(rdev_get_name(rdev), min_uV, max_uV);
2287 : :
2288 : 0 : min_uV += rdev->constraints->uV_offset;
2289 : 0 : max_uV += rdev->constraints->uV_offset;
2290 : :
2291 : : /*
2292 : : * If we can't obtain the old selector there is not enough
2293 : : * info to call set_voltage_time_sel().
2294 : : */
2295 [ # # ][ # # ]: 0 : if (_regulator_is_enabled(rdev) &&
2296 [ # # ]: 0 : rdev->desc->ops->set_voltage_time_sel &&
2297 : 0 : rdev->desc->ops->get_voltage_sel) {
2298 : 0 : old_selector = rdev->desc->ops->get_voltage_sel(rdev);
2299 [ # # ]: 0 : if (old_selector < 0)
2300 : : return old_selector;
2301 : : }
2302 : :
2303 [ # # ]: 0 : if (rdev->desc->ops->set_voltage) {
2304 : 0 : ret = rdev->desc->ops->set_voltage(rdev, min_uV, max_uV,
2305 : : &selector);
2306 : :
2307 [ # # ]: 0 : if (ret >= 0) {
2308 [ # # ]: 0 : if (rdev->desc->ops->list_voltage)
2309 : 0 : best_val = rdev->desc->ops->list_voltage(rdev,
2310 : : selector);
2311 : : else
2312 : 0 : best_val = _regulator_get_voltage(rdev);
2313 : : }
2314 : :
2315 [ # # ]: 0 : } else if (rdev->desc->ops->set_voltage_sel) {
2316 [ # # ]: 0 : if (rdev->desc->ops->map_voltage) {
2317 : 0 : ret = rdev->desc->ops->map_voltage(rdev, min_uV,
2318 : : max_uV);
2319 : : } else {
2320 [ # # ]: 0 : if (rdev->desc->ops->list_voltage ==
2321 : : regulator_list_voltage_linear)
2322 : 0 : ret = regulator_map_voltage_linear(rdev,
2323 : : min_uV, max_uV);
2324 : : else
2325 : 0 : ret = regulator_map_voltage_iterate(rdev,
2326 : : min_uV, max_uV);
2327 : : }
2328 : :
2329 [ # # ]: 0 : if (ret >= 0) {
2330 : 0 : best_val = rdev->desc->ops->list_voltage(rdev, ret);
2331 [ # # ]: 0 : if (min_uV <= best_val && max_uV >= best_val) {
2332 : 0 : selector = ret;
2333 [ # # ]: 0 : if (old_selector == selector)
2334 : : ret = 0;
2335 : : else
2336 : 0 : ret = rdev->desc->ops->set_voltage_sel(
2337 : : rdev, ret);
2338 : : } else {
2339 : : ret = -EINVAL;
2340 : : }
2341 : : }
2342 : : } else {
2343 : : ret = -EINVAL;
2344 : : }
2345 : :
2346 : : /* Call set_voltage_time_sel if successfully obtained old_selector */
2347 [ # # ][ # # ]: 0 : if (ret == 0 && !rdev->constraints->ramp_disable && old_selector >= 0
[ # # ]
2348 [ # # ]: 0 : && old_selector != selector) {
2349 : :
2350 : 0 : delay = rdev->desc->ops->set_voltage_time_sel(rdev,
2351 : : old_selector, selector);
2352 [ # # ]: 0 : if (delay < 0) {
2353 : 0 : rdev_warn(rdev, "set_voltage_time_sel() failed: %d\n",
2354 : : delay);
2355 : : delay = 0;
2356 : : }
2357 : :
2358 : : /* Insert any necessary delays */
2359 [ # # ]: 0 : if (delay >= 1000) {
2360 [ # # ][ # # ]: 0 : mdelay(delay / 1000);
[ # # ][ # # ]
[ # # ]
2361 [ # # ][ # # ]: 0 : udelay(delay % 1000);
2362 [ # # ]: 0 : } else if (delay) {
2363 [ # # ][ # # ]: 0 : udelay(delay);
2364 : : }
2365 : : }
2366 : :
2367 [ # # ]: 0 : if (ret == 0 && best_val >= 0) {
2368 : : unsigned long data = best_val;
2369 : :
2370 : 0 : _notifier_call_chain(rdev, REGULATOR_EVENT_VOLTAGE_CHANGE,
2371 : : (void *)data);
2372 : : }
2373 : :
2374 : 0 : trace_regulator_set_voltage_complete(rdev_get_name(rdev), best_val);
2375 : :
2376 : 0 : return ret;
2377 : : }
2378 : :
2379 : : /**
2380 : : * regulator_set_voltage - set regulator output voltage
2381 : : * @regulator: regulator source
2382 : : * @min_uV: Minimum required voltage in uV
2383 : : * @max_uV: Maximum acceptable voltage in uV
2384 : : *
2385 : : * Sets a voltage regulator to the desired output voltage. This can be set
2386 : : * during any regulator state. IOW, regulator can be disabled or enabled.
2387 : : *
2388 : : * If the regulator is enabled then the voltage will change to the new value
2389 : : * immediately otherwise if the regulator is disabled the regulator will
2390 : : * output at the new voltage when enabled.
2391 : : *
2392 : : * NOTE: If the regulator is shared between several devices then the lowest
2393 : : * request voltage that meets the system constraints will be used.
2394 : : * Regulator system constraints must be set for this regulator before
2395 : : * calling this function otherwise this call will fail.
2396 : : */
2397 : 0 : int regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV)
2398 : : {
2399 : 0 : struct regulator_dev *rdev = regulator->rdev;
2400 : : int ret = 0;
2401 : : int old_min_uV, old_max_uV;
2402 : :
2403 : 0 : mutex_lock(&rdev->mutex);
2404 : :
2405 : : /* If we're setting the same range as last time the change
2406 : : * should be a noop (some cpufreq implementations use the same
2407 : : * voltage for multiple frequencies, for example).
2408 : : */
2409 [ # # ][ # # ]: 0 : if (regulator->min_uV == min_uV && regulator->max_uV == max_uV)
2410 : : goto out;
2411 : :
2412 : : /* sanity check */
2413 [ # # ][ # # ]: 0 : if (!rdev->desc->ops->set_voltage &&
2414 : 0 : !rdev->desc->ops->set_voltage_sel) {
2415 : : ret = -EINVAL;
2416 : : goto out;
2417 : : }
2418 : :
2419 : : /* constraints check */
2420 : 0 : ret = regulator_check_voltage(rdev, &min_uV, &max_uV);
2421 [ # # ]: 0 : if (ret < 0)
2422 : : goto out;
2423 : :
2424 : : /* restore original values in case of error */
2425 : 0 : old_min_uV = regulator->min_uV;
2426 : 0 : old_max_uV = regulator->max_uV;
2427 : 0 : regulator->min_uV = min_uV;
2428 : 0 : regulator->max_uV = max_uV;
2429 : :
2430 : 0 : ret = regulator_check_consumers(rdev, &min_uV, &max_uV);
2431 [ # # ]: 0 : if (ret < 0)
2432 : : goto out2;
2433 : :
2434 : 0 : ret = _regulator_do_set_voltage(rdev, min_uV, max_uV);
2435 [ # # ]: 0 : if (ret < 0)
2436 : : goto out2;
2437 : :
2438 : : out:
2439 : 0 : mutex_unlock(&rdev->mutex);
2440 : 0 : return ret;
2441 : : out2:
2442 : 0 : regulator->min_uV = old_min_uV;
2443 : 0 : regulator->max_uV = old_max_uV;
2444 : 0 : mutex_unlock(&rdev->mutex);
2445 : 0 : return ret;
2446 : : }
2447 : : EXPORT_SYMBOL_GPL(regulator_set_voltage);
2448 : :
2449 : : /**
2450 : : * regulator_set_voltage_time - get raise/fall time
2451 : : * @regulator: regulator source
2452 : : * @old_uV: starting voltage in microvolts
2453 : : * @new_uV: target voltage in microvolts
2454 : : *
2455 : : * Provided with the starting and ending voltage, this function attempts to
2456 : : * calculate the time in microseconds required to rise or fall to this new
2457 : : * voltage.
2458 : : */
2459 : 0 : int regulator_set_voltage_time(struct regulator *regulator,
2460 : : int old_uV, int new_uV)
2461 : : {
2462 : 0 : struct regulator_dev *rdev = regulator->rdev;
2463 : 0 : struct regulator_ops *ops = rdev->desc->ops;
2464 : : int old_sel = -1;
2465 : : int new_sel = -1;
2466 : : int voltage;
2467 : : int i;
2468 : :
2469 : : /* Currently requires operations to do this */
2470 [ # # ][ # # ]: 0 : if (!ops->list_voltage || !ops->set_voltage_time_sel
2471 [ # # ]: 0 : || !rdev->desc->n_voltages)
2472 : : return -EINVAL;
2473 : :
2474 [ # # ]: 0 : for (i = 0; i < rdev->desc->n_voltages; i++) {
2475 : : /* We only look for exact voltage matches here */
2476 : 0 : voltage = regulator_list_voltage(regulator, i);
2477 [ # # ]: 0 : if (voltage < 0)
2478 : : return -EINVAL;
2479 [ # # ]: 0 : if (voltage == 0)
2480 : 0 : continue;
2481 [ # # ]: 0 : if (voltage == old_uV)
2482 : : old_sel = i;
2483 [ # # ]: 0 : if (voltage == new_uV)
2484 : : new_sel = i;
2485 : : }
2486 : :
2487 [ # # ]: 0 : if (old_sel < 0 || new_sel < 0)
2488 : : return -EINVAL;
2489 : :
2490 : 0 : return ops->set_voltage_time_sel(rdev, old_sel, new_sel);
2491 : : }
2492 : : EXPORT_SYMBOL_GPL(regulator_set_voltage_time);
2493 : :
2494 : : /**
2495 : : * regulator_set_voltage_time_sel - get raise/fall time
2496 : : * @rdev: regulator source device
2497 : : * @old_selector: selector for starting voltage
2498 : : * @new_selector: selector for target voltage
2499 : : *
2500 : : * Provided with the starting and target voltage selectors, this function
2501 : : * returns time in microseconds required to rise or fall to this new voltage
2502 : : *
2503 : : * Drivers providing ramp_delay in regulation_constraints can use this as their
2504 : : * set_voltage_time_sel() operation.
2505 : : */
2506 : 0 : int regulator_set_voltage_time_sel(struct regulator_dev *rdev,
2507 : : unsigned int old_selector,
2508 : : unsigned int new_selector)
2509 : : {
2510 : : unsigned int ramp_delay = 0;
2511 : : int old_volt, new_volt;
2512 : :
2513 [ # # ]: 0 : if (rdev->constraints->ramp_delay)
2514 : : ramp_delay = rdev->constraints->ramp_delay;
2515 [ # # ]: 0 : else if (rdev->desc->ramp_delay)
2516 : : ramp_delay = rdev->desc->ramp_delay;
2517 : :
2518 [ # # ]: 0 : if (ramp_delay == 0) {
2519 : 0 : rdev_warn(rdev, "ramp_delay not set\n");
2520 : 0 : return 0;
2521 : : }
2522 : :
2523 : : /* sanity check */
2524 [ # # ]: 0 : if (!rdev->desc->ops->list_voltage)
2525 : : return -EINVAL;
2526 : :
2527 : 0 : old_volt = rdev->desc->ops->list_voltage(rdev, old_selector);
2528 : 0 : new_volt = rdev->desc->ops->list_voltage(rdev, new_selector);
2529 : :
2530 : 0 : return DIV_ROUND_UP(abs(new_volt - old_volt), ramp_delay);
2531 : : }
2532 : : EXPORT_SYMBOL_GPL(regulator_set_voltage_time_sel);
2533 : :
2534 : : /**
2535 : : * regulator_sync_voltage - re-apply last regulator output voltage
2536 : : * @regulator: regulator source
2537 : : *
2538 : : * Re-apply the last configured voltage. This is intended to be used
2539 : : * where some external control source the consumer is cooperating with
2540 : : * has caused the configured voltage to change.
2541 : : */
2542 : 0 : int regulator_sync_voltage(struct regulator *regulator)
2543 : : {
2544 : 0 : struct regulator_dev *rdev = regulator->rdev;
2545 : : int ret, min_uV, max_uV;
2546 : :
2547 : 0 : mutex_lock(&rdev->mutex);
2548 : :
2549 [ # # ][ # # ]: 0 : if (!rdev->desc->ops->set_voltage &&
2550 : 0 : !rdev->desc->ops->set_voltage_sel) {
2551 : : ret = -EINVAL;
2552 : : goto out;
2553 : : }
2554 : :
2555 : : /* This is only going to work if we've had a voltage configured. */
2556 [ # # ][ # # ]: 0 : if (!regulator->min_uV && !regulator->max_uV) {
2557 : : ret = -EINVAL;
2558 : : goto out;
2559 : : }
2560 : :
2561 : 0 : min_uV = regulator->min_uV;
2562 : 0 : max_uV = regulator->max_uV;
2563 : :
2564 : : /* This should be a paranoia check... */
2565 : 0 : ret = regulator_check_voltage(rdev, &min_uV, &max_uV);
2566 [ # # ]: 0 : if (ret < 0)
2567 : : goto out;
2568 : :
2569 : 0 : ret = regulator_check_consumers(rdev, &min_uV, &max_uV);
2570 [ # # ]: 0 : if (ret < 0)
2571 : : goto out;
2572 : :
2573 : 0 : ret = _regulator_do_set_voltage(rdev, min_uV, max_uV);
2574 : :
2575 : : out:
2576 : 0 : mutex_unlock(&rdev->mutex);
2577 : 0 : return ret;
2578 : : }
2579 : : EXPORT_SYMBOL_GPL(regulator_sync_voltage);
2580 : :
2581 : 0 : static int _regulator_get_voltage(struct regulator_dev *rdev)
2582 : : {
2583 : : int sel, ret;
2584 : :
2585 [ # # ]: 0 : if (rdev->desc->ops->get_voltage_sel) {
2586 : 0 : sel = rdev->desc->ops->get_voltage_sel(rdev);
2587 [ # # ]: 0 : if (sel < 0)
2588 : : return sel;
2589 : 0 : ret = rdev->desc->ops->list_voltage(rdev, sel);
2590 [ # # ]: 0 : } else if (rdev->desc->ops->get_voltage) {
2591 : 0 : ret = rdev->desc->ops->get_voltage(rdev);
2592 [ # # ]: 0 : } else if (rdev->desc->ops->list_voltage) {
2593 : 0 : ret = rdev->desc->ops->list_voltage(rdev, 0);
2594 [ # # ][ # # ]: 0 : } else if (rdev->desc->fixed_uV && (rdev->desc->n_voltages == 1)) {
2595 : : ret = rdev->desc->fixed_uV;
2596 : : } else {
2597 : : return -EINVAL;
2598 : : }
2599 : :
2600 [ # # ]: 0 : if (ret < 0)
2601 : : return ret;
2602 : 0 : return ret - rdev->constraints->uV_offset;
2603 : : }
2604 : :
2605 : : /**
2606 : : * regulator_get_voltage - get regulator output voltage
2607 : : * @regulator: regulator source
2608 : : *
2609 : : * This returns the current regulator voltage in uV.
2610 : : *
2611 : : * NOTE: If the regulator is disabled it will return the voltage value. This
2612 : : * function should not be used to determine regulator state.
2613 : : */
2614 : 0 : int regulator_get_voltage(struct regulator *regulator)
2615 : : {
2616 : : int ret;
2617 : :
2618 : 0 : mutex_lock(®ulator->rdev->mutex);
2619 : :
2620 : 0 : ret = _regulator_get_voltage(regulator->rdev);
2621 : :
2622 : 0 : mutex_unlock(®ulator->rdev->mutex);
2623 : :
2624 : 0 : return ret;
2625 : : }
2626 : : EXPORT_SYMBOL_GPL(regulator_get_voltage);
2627 : :
2628 : : /**
2629 : : * regulator_set_current_limit - set regulator output current limit
2630 : : * @regulator: regulator source
2631 : : * @min_uA: Minimum supported current in uA
2632 : : * @max_uA: Maximum supported current in uA
2633 : : *
2634 : : * Sets current sink to the desired output current. This can be set during
2635 : : * any regulator state. IOW, regulator can be disabled or enabled.
2636 : : *
2637 : : * If the regulator is enabled then the current will change to the new value
2638 : : * immediately otherwise if the regulator is disabled the regulator will
2639 : : * output at the new current when enabled.
2640 : : *
2641 : : * NOTE: Regulator system constraints must be set for this regulator before
2642 : : * calling this function otherwise this call will fail.
2643 : : */
2644 : 0 : int regulator_set_current_limit(struct regulator *regulator,
2645 : : int min_uA, int max_uA)
2646 : : {
2647 : 0 : struct regulator_dev *rdev = regulator->rdev;
2648 : : int ret;
2649 : :
2650 : 0 : mutex_lock(&rdev->mutex);
2651 : :
2652 : : /* sanity check */
2653 [ # # ]: 0 : if (!rdev->desc->ops->set_current_limit) {
2654 : : ret = -EINVAL;
2655 : : goto out;
2656 : : }
2657 : :
2658 : : /* constraints check */
2659 : 0 : ret = regulator_check_current_limit(rdev, &min_uA, &max_uA);
2660 [ # # ]: 0 : if (ret < 0)
2661 : : goto out;
2662 : :
2663 : 0 : ret = rdev->desc->ops->set_current_limit(rdev, min_uA, max_uA);
2664 : : out:
2665 : 0 : mutex_unlock(&rdev->mutex);
2666 : 0 : return ret;
2667 : : }
2668 : : EXPORT_SYMBOL_GPL(regulator_set_current_limit);
2669 : :
2670 : 0 : static int _regulator_get_current_limit(struct regulator_dev *rdev)
2671 : : {
2672 : : int ret;
2673 : :
2674 : 0 : mutex_lock(&rdev->mutex);
2675 : :
2676 : : /* sanity check */
2677 [ # # ]: 0 : if (!rdev->desc->ops->get_current_limit) {
2678 : : ret = -EINVAL;
2679 : : goto out;
2680 : : }
2681 : :
2682 : 0 : ret = rdev->desc->ops->get_current_limit(rdev);
2683 : : out:
2684 : 0 : mutex_unlock(&rdev->mutex);
2685 : 0 : return ret;
2686 : : }
2687 : :
2688 : : /**
2689 : : * regulator_get_current_limit - get regulator output current
2690 : : * @regulator: regulator source
2691 : : *
2692 : : * This returns the current supplied by the specified current sink in uA.
2693 : : *
2694 : : * NOTE: If the regulator is disabled it will return the current value. This
2695 : : * function should not be used to determine regulator state.
2696 : : */
2697 : 0 : int regulator_get_current_limit(struct regulator *regulator)
2698 : : {
2699 : 0 : return _regulator_get_current_limit(regulator->rdev);
2700 : : }
2701 : : EXPORT_SYMBOL_GPL(regulator_get_current_limit);
2702 : :
2703 : : /**
2704 : : * regulator_set_mode - set regulator operating mode
2705 : : * @regulator: regulator source
2706 : : * @mode: operating mode - one of the REGULATOR_MODE constants
2707 : : *
2708 : : * Set regulator operating mode to increase regulator efficiency or improve
2709 : : * regulation performance.
2710 : : *
2711 : : * NOTE: Regulator system constraints must be set for this regulator before
2712 : : * calling this function otherwise this call will fail.
2713 : : */
2714 : 0 : int regulator_set_mode(struct regulator *regulator, unsigned int mode)
2715 : : {
2716 : 0 : struct regulator_dev *rdev = regulator->rdev;
2717 : : int ret;
2718 : : int regulator_curr_mode;
2719 : :
2720 : 0 : mutex_lock(&rdev->mutex);
2721 : :
2722 : : /* sanity check */
2723 [ # # ]: 0 : if (!rdev->desc->ops->set_mode) {
2724 : : ret = -EINVAL;
2725 : : goto out;
2726 : : }
2727 : :
2728 : : /* return if the same mode is requested */
2729 [ # # ]: 0 : if (rdev->desc->ops->get_mode) {
2730 : 0 : regulator_curr_mode = rdev->desc->ops->get_mode(rdev);
2731 [ # # ]: 0 : if (regulator_curr_mode == mode) {
2732 : : ret = 0;
2733 : : goto out;
2734 : : }
2735 : : }
2736 : :
2737 : : /* constraints check */
2738 : 0 : ret = regulator_mode_constrain(rdev, &mode);
2739 [ # # ]: 0 : if (ret < 0)
2740 : : goto out;
2741 : :
2742 : 0 : ret = rdev->desc->ops->set_mode(rdev, mode);
2743 : : out:
2744 : 0 : mutex_unlock(&rdev->mutex);
2745 : 0 : return ret;
2746 : : }
2747 : : EXPORT_SYMBOL_GPL(regulator_set_mode);
2748 : :
2749 : 0 : static unsigned int _regulator_get_mode(struct regulator_dev *rdev)
2750 : : {
2751 : : int ret;
2752 : :
2753 : 0 : mutex_lock(&rdev->mutex);
2754 : :
2755 : : /* sanity check */
2756 [ # # ]: 0 : if (!rdev->desc->ops->get_mode) {
2757 : : ret = -EINVAL;
2758 : : goto out;
2759 : : }
2760 : :
2761 : 0 : ret = rdev->desc->ops->get_mode(rdev);
2762 : : out:
2763 : 0 : mutex_unlock(&rdev->mutex);
2764 : 0 : return ret;
2765 : : }
2766 : :
2767 : : /**
2768 : : * regulator_get_mode - get regulator operating mode
2769 : : * @regulator: regulator source
2770 : : *
2771 : : * Get the current regulator operating mode.
2772 : : */
2773 : 0 : unsigned int regulator_get_mode(struct regulator *regulator)
2774 : : {
2775 : 0 : return _regulator_get_mode(regulator->rdev);
2776 : : }
2777 : : EXPORT_SYMBOL_GPL(regulator_get_mode);
2778 : :
2779 : : /**
2780 : : * regulator_set_optimum_mode - set regulator optimum operating mode
2781 : : * @regulator: regulator source
2782 : : * @uA_load: load current
2783 : : *
2784 : : * Notifies the regulator core of a new device load. This is then used by
2785 : : * DRMS (if enabled by constraints) to set the most efficient regulator
2786 : : * operating mode for the new regulator loading.
2787 : : *
2788 : : * Consumer devices notify their supply regulator of the maximum power
2789 : : * they will require (can be taken from device datasheet in the power
2790 : : * consumption tables) when they change operational status and hence power
2791 : : * state. Examples of operational state changes that can affect power
2792 : : * consumption are :-
2793 : : *
2794 : : * o Device is opened / closed.
2795 : : * o Device I/O is about to begin or has just finished.
2796 : : * o Device is idling in between work.
2797 : : *
2798 : : * This information is also exported via sysfs to userspace.
2799 : : *
2800 : : * DRMS will sum the total requested load on the regulator and change
2801 : : * to the most efficient operating mode if platform constraints allow.
2802 : : *
2803 : : * Returns the new regulator mode or error.
2804 : : */
2805 : 0 : int regulator_set_optimum_mode(struct regulator *regulator, int uA_load)
2806 : : {
2807 : 0 : struct regulator_dev *rdev = regulator->rdev;
2808 : : struct regulator *consumer;
2809 : : int ret, output_uV, input_uV = 0, total_uA_load = 0;
2810 : : unsigned int mode;
2811 : :
2812 [ # # ]: 0 : if (rdev->supply)
2813 : 0 : input_uV = regulator_get_voltage(rdev->supply);
2814 : :
2815 : 0 : mutex_lock(&rdev->mutex);
2816 : :
2817 : : /*
2818 : : * first check to see if we can set modes at all, otherwise just
2819 : : * tell the consumer everything is OK.
2820 : : */
2821 : 0 : regulator->uA_load = uA_load;
2822 : 0 : ret = regulator_check_drms(rdev);
2823 [ # # ]: 0 : if (ret < 0) {
2824 : : ret = 0;
2825 : : goto out;
2826 : : }
2827 : :
2828 [ # # ]: 0 : if (!rdev->desc->ops->get_optimum_mode)
2829 : : goto out;
2830 : :
2831 : : /*
2832 : : * we can actually do this so any errors are indicators of
2833 : : * potential real failure.
2834 : : */
2835 : : ret = -EINVAL;
2836 : :
2837 [ # # ]: 0 : if (!rdev->desc->ops->set_mode)
2838 : : goto out;
2839 : :
2840 : : /* get output voltage */
2841 : 0 : output_uV = _regulator_get_voltage(rdev);
2842 [ # # ]: 0 : if (output_uV <= 0) {
2843 : 0 : rdev_err(rdev, "invalid output voltage found\n");
2844 : 0 : goto out;
2845 : : }
2846 : :
2847 : : /* No supply? Use constraint voltage */
2848 [ # # ]: 0 : if (input_uV <= 0)
2849 : 0 : input_uV = rdev->constraints->input_uV;
2850 [ # # ]: 0 : if (input_uV <= 0) {
2851 : 0 : rdev_err(rdev, "invalid input voltage found\n");
2852 : 0 : goto out;
2853 : : }
2854 : :
2855 : : /* calc total requested load for this regulator */
2856 [ # # ]: 0 : list_for_each_entry(consumer, &rdev->consumer_list, list)
2857 : 0 : total_uA_load += consumer->uA_load;
2858 : :
2859 : 0 : mode = rdev->desc->ops->get_optimum_mode(rdev,
2860 : : input_uV, output_uV,
2861 : : total_uA_load);
2862 : 0 : ret = regulator_mode_constrain(rdev, &mode);
2863 [ # # ]: 0 : if (ret < 0) {
2864 : 0 : rdev_err(rdev, "failed to get optimum mode @ %d uA %d -> %d uV\n",
2865 : : total_uA_load, input_uV, output_uV);
2866 : 0 : goto out;
2867 : : }
2868 : :
2869 : 0 : ret = rdev->desc->ops->set_mode(rdev, mode);
2870 [ # # ]: 0 : if (ret < 0) {
2871 : 0 : rdev_err(rdev, "failed to set optimum mode %x\n", mode);
2872 : 0 : goto out;
2873 : : }
2874 : 0 : ret = mode;
2875 : : out:
2876 : 0 : mutex_unlock(&rdev->mutex);
2877 : 0 : return ret;
2878 : : }
2879 : : EXPORT_SYMBOL_GPL(regulator_set_optimum_mode);
2880 : :
2881 : : /**
2882 : : * regulator_allow_bypass - allow the regulator to go into bypass mode
2883 : : *
2884 : : * @regulator: Regulator to configure
2885 : : * @enable: enable or disable bypass mode
2886 : : *
2887 : : * Allow the regulator to go into bypass mode if all other consumers
2888 : : * for the regulator also enable bypass mode and the machine
2889 : : * constraints allow this. Bypass mode means that the regulator is
2890 : : * simply passing the input directly to the output with no regulation.
2891 : : */
2892 : 0 : int regulator_allow_bypass(struct regulator *regulator, bool enable)
2893 : : {
2894 : 0 : struct regulator_dev *rdev = regulator->rdev;
2895 : : int ret = 0;
2896 : :
2897 [ # # ]: 0 : if (!rdev->desc->ops->set_bypass)
2898 : : return 0;
2899 : :
2900 [ # # ][ # # ]: 0 : if (rdev->constraints &&
2901 : 0 : !(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_BYPASS))
2902 : : return 0;
2903 : :
2904 : 0 : mutex_lock(&rdev->mutex);
2905 : :
2906 [ # # ][ # # ]: 0 : if (enable && !regulator->bypass) {
2907 : 0 : rdev->bypass_count++;
2908 : :
2909 [ # # ]: 0 : if (rdev->bypass_count == rdev->open_count) {
2910 : 0 : ret = rdev->desc->ops->set_bypass(rdev, enable);
2911 [ # # ]: 0 : if (ret != 0)
2912 : 0 : rdev->bypass_count--;
2913 : : }
2914 : :
2915 [ # # ][ # # ]: 0 : } else if (!enable && regulator->bypass) {
2916 : 0 : rdev->bypass_count--;
2917 : :
2918 [ # # ]: 0 : if (rdev->bypass_count != rdev->open_count) {
2919 : 0 : ret = rdev->desc->ops->set_bypass(rdev, enable);
2920 [ # # ]: 0 : if (ret != 0)
2921 : 0 : rdev->bypass_count++;
2922 : : }
2923 : : }
2924 : :
2925 [ # # ]: 0 : if (ret == 0)
2926 : 0 : regulator->bypass = enable;
2927 : :
2928 : 0 : mutex_unlock(&rdev->mutex);
2929 : :
2930 : 0 : return ret;
2931 : : }
2932 : : EXPORT_SYMBOL_GPL(regulator_allow_bypass);
2933 : :
2934 : : /**
2935 : : * regulator_register_notifier - register regulator event notifier
2936 : : * @regulator: regulator source
2937 : : * @nb: notifier block
2938 : : *
2939 : : * Register notifier block to receive regulator events.
2940 : : */
2941 : 0 : int regulator_register_notifier(struct regulator *regulator,
2942 : : struct notifier_block *nb)
2943 : : {
2944 : 0 : return blocking_notifier_chain_register(®ulator->rdev->notifier,
2945 : : nb);
2946 : : }
2947 : : EXPORT_SYMBOL_GPL(regulator_register_notifier);
2948 : :
2949 : : /**
2950 : : * regulator_unregister_notifier - unregister regulator event notifier
2951 : : * @regulator: regulator source
2952 : : * @nb: notifier block
2953 : : *
2954 : : * Unregister regulator event notifier block.
2955 : : */
2956 : 0 : int regulator_unregister_notifier(struct regulator *regulator,
2957 : : struct notifier_block *nb)
2958 : : {
2959 : 0 : return blocking_notifier_chain_unregister(®ulator->rdev->notifier,
2960 : : nb);
2961 : : }
2962 : : EXPORT_SYMBOL_GPL(regulator_unregister_notifier);
2963 : :
2964 : : /* notify regulator consumers and downstream regulator consumers.
2965 : : * Note mutex must be held by caller.
2966 : : */
2967 : : static void _notifier_call_chain(struct regulator_dev *rdev,
2968 : : unsigned long event, void *data)
2969 : : {
2970 : : /* call rdev chain first */
2971 : 0 : blocking_notifier_call_chain(&rdev->notifier, event, data);
2972 : : }
2973 : :
2974 : : /**
2975 : : * regulator_bulk_get - get multiple regulator consumers
2976 : : *
2977 : : * @dev: Device to supply
2978 : : * @num_consumers: Number of consumers to register
2979 : : * @consumers: Configuration of consumers; clients are stored here.
2980 : : *
2981 : : * @return 0 on success, an errno on failure.
2982 : : *
2983 : : * This helper function allows drivers to get several regulator
2984 : : * consumers in one operation. If any of the regulators cannot be
2985 : : * acquired then any regulators that were allocated will be freed
2986 : : * before returning to the caller.
2987 : : */
2988 : 0 : int regulator_bulk_get(struct device *dev, int num_consumers,
2989 : : struct regulator_bulk_data *consumers)
2990 : : {
2991 : : int i;
2992 : : int ret;
2993 : :
2994 [ # # ]: 0 : for (i = 0; i < num_consumers; i++)
2995 : 0 : consumers[i].consumer = NULL;
2996 : :
2997 [ # # ]: 0 : for (i = 0; i < num_consumers; i++) {
2998 : 0 : consumers[i].consumer = regulator_get(dev,
2999 : 0 : consumers[i].supply);
3000 [ # # ]: 0 : if (IS_ERR(consumers[i].consumer)) {
3001 : : ret = PTR_ERR(consumers[i].consumer);
3002 : 0 : dev_err(dev, "Failed to get supply '%s': %d\n",
3003 : : consumers[i].supply, ret);
3004 : 0 : consumers[i].consumer = NULL;
3005 : : goto err;
3006 : : }
3007 : : }
3008 : :
3009 : : return 0;
3010 : :
3011 : : err:
3012 [ # # ]: 0 : while (--i >= 0)
3013 : 0 : regulator_put(consumers[i].consumer);
3014 : :
3015 : : return ret;
3016 : : }
3017 : : EXPORT_SYMBOL_GPL(regulator_bulk_get);
3018 : :
3019 : 0 : static void regulator_bulk_enable_async(void *data, async_cookie_t cookie)
3020 : : {
3021 : : struct regulator_bulk_data *bulk = data;
3022 : :
3023 : 0 : bulk->ret = regulator_enable(bulk->consumer);
3024 : 0 : }
3025 : :
3026 : : /**
3027 : : * regulator_bulk_enable - enable multiple regulator consumers
3028 : : *
3029 : : * @num_consumers: Number of consumers
3030 : : * @consumers: Consumer data; clients are stored here.
3031 : : * @return 0 on success, an errno on failure
3032 : : *
3033 : : * This convenience API allows consumers to enable multiple regulator
3034 : : * clients in a single API call. If any consumers cannot be enabled
3035 : : * then any others that were enabled will be disabled again prior to
3036 : : * return.
3037 : : */
3038 : 0 : int regulator_bulk_enable(int num_consumers,
3039 : : struct regulator_bulk_data *consumers)
3040 : : {
3041 : 0 : ASYNC_DOMAIN_EXCLUSIVE(async_domain);
3042 : : int i;
3043 : : int ret = 0;
3044 : :
3045 [ # # ]: 0 : for (i = 0; i < num_consumers; i++) {
3046 [ # # ]: 0 : if (consumers[i].consumer->always_on)
3047 : 0 : consumers[i].ret = 0;
3048 : : else
3049 : 0 : async_schedule_domain(regulator_bulk_enable_async,
3050 : : &consumers[i], &async_domain);
3051 : : }
3052 : :
3053 : 0 : async_synchronize_full_domain(&async_domain);
3054 : :
3055 : : /* If any consumer failed we need to unwind any that succeeded */
3056 [ # # ]: 0 : for (i = 0; i < num_consumers; i++) {
3057 [ # # ]: 0 : if (consumers[i].ret != 0) {
3058 : : ret = consumers[i].ret;
3059 : : goto err;
3060 : : }
3061 : : }
3062 : :
3063 : : return 0;
3064 : :
3065 : : err:
3066 [ # # ]: 0 : for (i = 0; i < num_consumers; i++) {
3067 [ # # ]: 0 : if (consumers[i].ret < 0)
3068 : 0 : pr_err("Failed to enable %s: %d\n", consumers[i].supply,
3069 : : consumers[i].ret);
3070 : : else
3071 : 0 : regulator_disable(consumers[i].consumer);
3072 : : }
3073 : :
3074 : : return ret;
3075 : : }
3076 : : EXPORT_SYMBOL_GPL(regulator_bulk_enable);
3077 : :
3078 : : /**
3079 : : * regulator_bulk_disable - disable multiple regulator consumers
3080 : : *
3081 : : * @num_consumers: Number of consumers
3082 : : * @consumers: Consumer data; clients are stored here.
3083 : : * @return 0 on success, an errno on failure
3084 : : *
3085 : : * This convenience API allows consumers to disable multiple regulator
3086 : : * clients in a single API call. If any consumers cannot be disabled
3087 : : * then any others that were disabled will be enabled again prior to
3088 : : * return.
3089 : : */
3090 : 0 : int regulator_bulk_disable(int num_consumers,
3091 : : struct regulator_bulk_data *consumers)
3092 : : {
3093 : : int i;
3094 : : int ret, r;
3095 : :
3096 [ # # ]: 0 : for (i = num_consumers - 1; i >= 0; --i) {
3097 : 0 : ret = regulator_disable(consumers[i].consumer);
3098 [ # # ]: 0 : if (ret != 0)
3099 : : goto err;
3100 : : }
3101 : :
3102 : : return 0;
3103 : :
3104 : : err:
3105 : 0 : pr_err("Failed to disable %s: %d\n", consumers[i].supply, ret);
3106 [ # # ]: 0 : for (++i; i < num_consumers; ++i) {
3107 : 0 : r = regulator_enable(consumers[i].consumer);
3108 [ # # ]: 0 : if (r != 0)
3109 : 0 : pr_err("Failed to reename %s: %d\n",
3110 : : consumers[i].supply, r);
3111 : : }
3112 : :
3113 : : return ret;
3114 : : }
3115 : : EXPORT_SYMBOL_GPL(regulator_bulk_disable);
3116 : :
3117 : : /**
3118 : : * regulator_bulk_force_disable - force disable multiple regulator consumers
3119 : : *
3120 : : * @num_consumers: Number of consumers
3121 : : * @consumers: Consumer data; clients are stored here.
3122 : : * @return 0 on success, an errno on failure
3123 : : *
3124 : : * This convenience API allows consumers to forcibly disable multiple regulator
3125 : : * clients in a single API call.
3126 : : * NOTE: This should be used for situations when device damage will
3127 : : * likely occur if the regulators are not disabled (e.g. over temp).
3128 : : * Although regulator_force_disable function call for some consumers can
3129 : : * return error numbers, the function is called for all consumers.
3130 : : */
3131 : 0 : int regulator_bulk_force_disable(int num_consumers,
3132 : : struct regulator_bulk_data *consumers)
3133 : : {
3134 : : int i;
3135 : : int ret;
3136 : :
3137 [ # # ]: 0 : for (i = 0; i < num_consumers; i++)
3138 : 0 : consumers[i].ret =
3139 : 0 : regulator_force_disable(consumers[i].consumer);
3140 : :
3141 [ # # ]: 0 : for (i = 0; i < num_consumers; i++) {
3142 [ # # ]: 0 : if (consumers[i].ret != 0) {
3143 : : ret = consumers[i].ret;
3144 : : goto out;
3145 : : }
3146 : : }
3147 : :
3148 : : return 0;
3149 : : out:
3150 : : return ret;
3151 : : }
3152 : : EXPORT_SYMBOL_GPL(regulator_bulk_force_disable);
3153 : :
3154 : : /**
3155 : : * regulator_bulk_free - free multiple regulator consumers
3156 : : *
3157 : : * @num_consumers: Number of consumers
3158 : : * @consumers: Consumer data; clients are stored here.
3159 : : *
3160 : : * This convenience API allows consumers to free multiple regulator
3161 : : * clients in a single API call.
3162 : : */
3163 : 0 : void regulator_bulk_free(int num_consumers,
3164 : : struct regulator_bulk_data *consumers)
3165 : : {
3166 : : int i;
3167 : :
3168 [ # # ]: 0 : for (i = 0; i < num_consumers; i++) {
3169 : 0 : regulator_put(consumers[i].consumer);
3170 : 0 : consumers[i].consumer = NULL;
3171 : : }
3172 : 0 : }
3173 : : EXPORT_SYMBOL_GPL(regulator_bulk_free);
3174 : :
3175 : : /**
3176 : : * regulator_notifier_call_chain - call regulator event notifier
3177 : : * @rdev: regulator source
3178 : : * @event: notifier block
3179 : : * @data: callback-specific data.
3180 : : *
3181 : : * Called by regulator drivers to notify clients a regulator event has
3182 : : * occurred. We also notify regulator clients downstream.
3183 : : * Note lock must be held by caller.
3184 : : */
3185 : 0 : int regulator_notifier_call_chain(struct regulator_dev *rdev,
3186 : : unsigned long event, void *data)
3187 : : {
3188 : : _notifier_call_chain(rdev, event, data);
3189 : 0 : return NOTIFY_DONE;
3190 : :
3191 : : }
3192 : : EXPORT_SYMBOL_GPL(regulator_notifier_call_chain);
3193 : :
3194 : : /**
3195 : : * regulator_mode_to_status - convert a regulator mode into a status
3196 : : *
3197 : : * @mode: Mode to convert
3198 : : *
3199 : : * Convert a regulator mode into a status.
3200 : : */
3201 [ # # ]: 0 : int regulator_mode_to_status(unsigned int mode)
3202 : : {
3203 : : switch (mode) {
3204 : : case REGULATOR_MODE_FAST:
3205 : : return REGULATOR_STATUS_FAST;
3206 : : case REGULATOR_MODE_NORMAL:
3207 : : return REGULATOR_STATUS_NORMAL;
3208 : : case REGULATOR_MODE_IDLE:
3209 : : return REGULATOR_STATUS_IDLE;
3210 : : case REGULATOR_MODE_STANDBY:
3211 : : return REGULATOR_STATUS_STANDBY;
3212 : : default:
3213 : : return REGULATOR_STATUS_UNDEFINED;
3214 : : }
3215 : : }
3216 : : EXPORT_SYMBOL_GPL(regulator_mode_to_status);
3217 : :
3218 : : /*
3219 : : * To avoid cluttering sysfs (and memory) with useless state, only
3220 : : * create attributes that can be meaningfully displayed.
3221 : : */
3222 : 0 : static int add_regulator_attributes(struct regulator_dev *rdev)
3223 : : {
3224 : 0 : struct device *dev = &rdev->dev;
3225 : 0 : struct regulator_ops *ops = rdev->desc->ops;
3226 : : int status = 0;
3227 : :
3228 : : /* some attributes need specific methods to be displayed */
3229 [ # # ][ # # ]: 0 : if ((ops->get_voltage && ops->get_voltage(rdev) >= 0) ||
[ # # ]
3230 [ # # ][ # # ]: 0 : (ops->get_voltage_sel && ops->get_voltage_sel(rdev) >= 0) ||
3231 [ # # ][ # # ]: 0 : (ops->list_voltage && ops->list_voltage(rdev, 0) >= 0) ||
3232 [ # # ]: 0 : (rdev->desc->fixed_uV && (rdev->desc->n_voltages == 1))) {
3233 : 0 : status = device_create_file(dev, &dev_attr_microvolts);
3234 [ # # ]: 0 : if (status < 0)
3235 : : return status;
3236 : : }
3237 [ # # ]: 0 : if (ops->get_current_limit) {
3238 : 0 : status = device_create_file(dev, &dev_attr_microamps);
3239 [ # # ]: 0 : if (status < 0)
3240 : : return status;
3241 : : }
3242 [ # # ]: 0 : if (ops->get_mode) {
3243 : 0 : status = device_create_file(dev, &dev_attr_opmode);
3244 [ # # ]: 0 : if (status < 0)
3245 : : return status;
3246 : : }
3247 [ # # ][ # # ]: 0 : if (rdev->ena_pin || ops->is_enabled) {
3248 : 0 : status = device_create_file(dev, &dev_attr_state);
3249 [ # # ]: 0 : if (status < 0)
3250 : : return status;
3251 : : }
3252 [ # # ]: 0 : if (ops->get_status) {
3253 : 0 : status = device_create_file(dev, &dev_attr_status);
3254 [ # # ]: 0 : if (status < 0)
3255 : : return status;
3256 : : }
3257 [ # # ]: 0 : if (ops->get_bypass) {
3258 : 0 : status = device_create_file(dev, &dev_attr_bypass);
3259 [ # # ]: 0 : if (status < 0)
3260 : : return status;
3261 : : }
3262 : :
3263 : : /* some attributes are type-specific */
3264 [ # # ]: 0 : if (rdev->desc->type == REGULATOR_CURRENT) {
3265 : 0 : status = device_create_file(dev, &dev_attr_requested_microamps);
3266 [ # # ]: 0 : if (status < 0)
3267 : : return status;
3268 : : }
3269 : :
3270 : : /* all the other attributes exist to support constraints;
3271 : : * don't show them if there are no constraints, or if the
3272 : : * relevant supporting methods are missing.
3273 : : */
3274 [ # # ]: 0 : if (!rdev->constraints)
3275 : : return status;
3276 : :
3277 : : /* constraints need specific supporting methods */
3278 [ # # ][ # # ]: 0 : if (ops->set_voltage || ops->set_voltage_sel) {
3279 : 0 : status = device_create_file(dev, &dev_attr_min_microvolts);
3280 [ # # ]: 0 : if (status < 0)
3281 : : return status;
3282 : 0 : status = device_create_file(dev, &dev_attr_max_microvolts);
3283 [ # # ]: 0 : if (status < 0)
3284 : : return status;
3285 : : }
3286 [ # # ]: 0 : if (ops->set_current_limit) {
3287 : 0 : status = device_create_file(dev, &dev_attr_min_microamps);
3288 [ # # ]: 0 : if (status < 0)
3289 : : return status;
3290 : 0 : status = device_create_file(dev, &dev_attr_max_microamps);
3291 [ # # ]: 0 : if (status < 0)
3292 : : return status;
3293 : : }
3294 : :
3295 : 0 : status = device_create_file(dev, &dev_attr_suspend_standby_state);
3296 [ # # ]: 0 : if (status < 0)
3297 : : return status;
3298 : 0 : status = device_create_file(dev, &dev_attr_suspend_mem_state);
3299 [ # # ]: 0 : if (status < 0)
3300 : : return status;
3301 : 0 : status = device_create_file(dev, &dev_attr_suspend_disk_state);
3302 [ # # ]: 0 : if (status < 0)
3303 : : return status;
3304 : :
3305 [ # # ]: 0 : if (ops->set_suspend_voltage) {
3306 : 0 : status = device_create_file(dev,
3307 : : &dev_attr_suspend_standby_microvolts);
3308 [ # # ]: 0 : if (status < 0)
3309 : : return status;
3310 : 0 : status = device_create_file(dev,
3311 : : &dev_attr_suspend_mem_microvolts);
3312 [ # # ]: 0 : if (status < 0)
3313 : : return status;
3314 : 0 : status = device_create_file(dev,
3315 : : &dev_attr_suspend_disk_microvolts);
3316 [ # # ]: 0 : if (status < 0)
3317 : : return status;
3318 : : }
3319 : :
3320 [ # # ]: 0 : if (ops->set_suspend_mode) {
3321 : 0 : status = device_create_file(dev,
3322 : : &dev_attr_suspend_standby_mode);
3323 [ # # ]: 0 : if (status < 0)
3324 : : return status;
3325 : 0 : status = device_create_file(dev,
3326 : : &dev_attr_suspend_mem_mode);
3327 [ # # ]: 0 : if (status < 0)
3328 : : return status;
3329 : 0 : status = device_create_file(dev,
3330 : : &dev_attr_suspend_disk_mode);
3331 [ # # ]: 0 : if (status < 0)
3332 : : return status;
3333 : : }
3334 : :
3335 : 0 : return status;
3336 : : }
3337 : :
3338 : 0 : static void rdev_init_debugfs(struct regulator_dev *rdev)
3339 : : {
3340 : 0 : rdev->debugfs = debugfs_create_dir(rdev_get_name(rdev), debugfs_root);
3341 [ # # ]: 0 : if (!rdev->debugfs) {
3342 : 0 : rdev_warn(rdev, "Failed to create debugfs directory\n");
3343 : 0 : return;
3344 : : }
3345 : :
3346 : 0 : debugfs_create_u32("use_count", 0444, rdev->debugfs,
3347 : : &rdev->use_count);
3348 : 0 : debugfs_create_u32("open_count", 0444, rdev->debugfs,
3349 : : &rdev->open_count);
3350 : 0 : debugfs_create_u32("bypass_count", 0444, rdev->debugfs,
3351 : : &rdev->bypass_count);
3352 : : }
3353 : :
3354 : : /**
3355 : : * regulator_register - register regulator
3356 : : * @regulator_desc: regulator to register
3357 : : * @config: runtime configuration for regulator
3358 : : *
3359 : : * Called by regulator drivers to register a regulator.
3360 : : * Returns a valid pointer to struct regulator_dev on success
3361 : : * or an ERR_PTR() on error.
3362 : : */
3363 : : struct regulator_dev *
3364 : 0 : regulator_register(const struct regulator_desc *regulator_desc,
3365 : : const struct regulator_config *config)
3366 : : {
3367 : : const struct regulation_constraints *constraints = NULL;
3368 : : const struct regulator_init_data *init_data;
3369 : : static atomic_t regulator_no = ATOMIC_INIT(0);
3370 : 0 : struct regulator_dev *rdev;
3371 : : struct device *dev;
3372 : : int ret, i;
3373 : : const char *supply = NULL;
3374 : :
3375 [ # # ]: 0 : if (regulator_desc == NULL || config == NULL)
3376 : : return ERR_PTR(-EINVAL);
3377 : :
3378 : 0 : dev = config->dev;
3379 [ # # ]: 0 : WARN_ON(!dev);
3380 : :
3381 [ # # ][ # # ]: 0 : if (regulator_desc->name == NULL || regulator_desc->ops == NULL)
3382 : : return ERR_PTR(-EINVAL);
3383 : :
3384 [ # # ]: 0 : if (regulator_desc->type != REGULATOR_VOLTAGE &&
3385 : : regulator_desc->type != REGULATOR_CURRENT)
3386 : : return ERR_PTR(-EINVAL);
3387 : :
3388 : : /* Only one of each should be implemented */
3389 [ # # ][ # # ]: 0 : WARN_ON(regulator_desc->ops->get_voltage &&
[ # # ]
3390 : : regulator_desc->ops->get_voltage_sel);
3391 [ # # ][ # # ]: 0 : WARN_ON(regulator_desc->ops->set_voltage &&
[ # # ]
3392 : : regulator_desc->ops->set_voltage_sel);
3393 : :
3394 : : /* If we're using selectors we must implement list_voltage. */
3395 [ # # ][ # # ]: 0 : if (regulator_desc->ops->get_voltage_sel &&
3396 : 0 : !regulator_desc->ops->list_voltage) {
3397 : : return ERR_PTR(-EINVAL);
3398 : : }
3399 [ # # ][ # # ]: 0 : if (regulator_desc->ops->set_voltage_sel &&
3400 : 0 : !regulator_desc->ops->list_voltage) {
3401 : : return ERR_PTR(-EINVAL);
3402 : : }
3403 : :
3404 : 0 : init_data = config->init_data;
3405 : :
3406 : : rdev = kzalloc(sizeof(struct regulator_dev), GFP_KERNEL);
3407 [ # # ]: 0 : if (rdev == NULL)
3408 : : return ERR_PTR(-ENOMEM);
3409 : :
3410 : 0 : mutex_lock(®ulator_list_mutex);
3411 : :
3412 : 0 : mutex_init(&rdev->mutex);
3413 : 0 : rdev->reg_data = config->driver_data;
3414 : 0 : rdev->owner = regulator_desc->owner;
3415 : 0 : rdev->desc = regulator_desc;
3416 [ # # ]: 0 : if (config->regmap)
3417 : 0 : rdev->regmap = config->regmap;
3418 : : else if (dev_get_regmap(dev, NULL))
3419 : : rdev->regmap = dev_get_regmap(dev, NULL);
3420 [ # # ]: 0 : else if (dev->parent)
3421 : 0 : rdev->regmap = dev_get_regmap(dev->parent, NULL);
3422 : 0 : INIT_LIST_HEAD(&rdev->consumer_list);
3423 : 0 : INIT_LIST_HEAD(&rdev->list);
3424 : 0 : BLOCKING_INIT_NOTIFIER_HEAD(&rdev->notifier);
3425 : 0 : INIT_DELAYED_WORK(&rdev->disable_work, regulator_disable_work);
3426 : :
3427 : : /* preform any regulator specific init */
3428 [ # # ][ # # ]: 0 : if (init_data && init_data->regulator_init) {
3429 : 0 : ret = init_data->regulator_init(rdev->reg_data);
3430 [ # # ]: 0 : if (ret < 0)
3431 : : goto clean;
3432 : : }
3433 : :
3434 : : /* register with sysfs */
3435 : 0 : rdev->dev.class = ®ulator_class;
3436 : 0 : rdev->dev.of_node = config->of_node;
3437 : 0 : rdev->dev.parent = dev;
3438 : 0 : dev_set_name(&rdev->dev, "regulator.%d",
3439 : : atomic_inc_return(®ulator_no) - 1);
3440 : 0 : ret = device_register(&rdev->dev);
3441 [ # # ]: 0 : if (ret != 0) {
3442 : 0 : put_device(&rdev->dev);
3443 : 0 : goto clean;
3444 : : }
3445 : :
3446 : 0 : dev_set_drvdata(&rdev->dev, rdev);
3447 : :
3448 [ # # ][ # # ]: 0 : if (config->ena_gpio && gpio_is_valid(config->ena_gpio)) {
3449 : 0 : ret = regulator_ena_gpio_request(rdev, config);
3450 [ # # ]: 0 : if (ret != 0) {
3451 : 0 : rdev_err(rdev, "Failed to request enable GPIO%d: %d\n",
3452 : : config->ena_gpio, ret);
3453 : 0 : goto wash;
3454 : : }
3455 : :
3456 [ # # ]: 0 : if (config->ena_gpio_flags & GPIOF_OUT_INIT_HIGH)
3457 : 0 : rdev->ena_gpio_state = 1;
3458 : :
3459 [ # # ]: 0 : if (config->ena_gpio_invert)
3460 : 0 : rdev->ena_gpio_state = !rdev->ena_gpio_state;
3461 : : }
3462 : :
3463 : : /* set regulator constraints */
3464 [ # # ]: 0 : if (init_data)
3465 : 0 : constraints = &init_data->constraints;
3466 : :
3467 : 0 : ret = set_machine_constraints(rdev, constraints);
3468 [ # # ]: 0 : if (ret < 0)
3469 : : goto scrub;
3470 : :
3471 : : /* add attributes supported by this regulator */
3472 : 0 : ret = add_regulator_attributes(rdev);
3473 [ # # ]: 0 : if (ret < 0)
3474 : : goto scrub;
3475 : :
3476 [ # # ][ # # ]: 0 : if (init_data && init_data->supply_regulator)
3477 : : supply = init_data->supply_regulator;
3478 [ # # ]: 0 : else if (regulator_desc->supply_name)
3479 : : supply = regulator_desc->supply_name;
3480 : :
3481 [ # # ]: 0 : if (supply) {
3482 : : struct regulator_dev *r;
3483 : :
3484 : 0 : r = regulator_dev_lookup(dev, supply, &ret);
3485 : :
3486 [ # # ]: 0 : if (ret == -ENODEV) {
3487 : : /*
3488 : : * No supply was specified for this regulator and
3489 : : * there will never be one.
3490 : : */
3491 : 0 : ret = 0;
3492 : 0 : goto add_dev;
3493 [ # # ]: 0 : } else if (!r) {
3494 : 0 : dev_err(dev, "Failed to find supply %s\n", supply);
3495 : 0 : ret = -EPROBE_DEFER;
3496 : 0 : goto scrub;
3497 : : }
3498 : :
3499 : 0 : ret = set_supply(rdev, r);
3500 [ # # ]: 0 : if (ret < 0)
3501 : : goto scrub;
3502 : :
3503 : : /* Enable supply if rail is enabled */
3504 [ # # ]: 0 : if (_regulator_is_enabled(rdev)) {
3505 : 0 : ret = regulator_enable(rdev->supply);
3506 [ # # ]: 0 : if (ret < 0)
3507 : : goto scrub;
3508 : : }
3509 : : }
3510 : :
3511 : : add_dev:
3512 : : /* add consumers devices */
3513 [ # # ]: 0 : if (init_data) {
3514 [ # # ]: 0 : for (i = 0; i < init_data->num_consumer_supplies; i++) {
3515 : 0 : ret = set_consumer_device_supply(rdev,
3516 : 0 : init_data->consumer_supplies[i].dev_name,
3517 : : init_data->consumer_supplies[i].supply);
3518 [ # # ]: 0 : if (ret < 0) {
3519 : 0 : dev_err(dev, "Failed to set supply %s\n",
3520 : 0 : init_data->consumer_supplies[i].supply);
3521 : : goto unset_supplies;
3522 : : }
3523 : : }
3524 : : }
3525 : :
3526 : : list_add(&rdev->list, ®ulator_list);
3527 : :
3528 : 0 : rdev_init_debugfs(rdev);
3529 : : out:
3530 : 0 : mutex_unlock(®ulator_list_mutex);
3531 : 0 : return rdev;
3532 : :
3533 : : unset_supplies:
3534 : 0 : unset_regulator_supplies(rdev);
3535 : :
3536 : : scrub:
3537 [ # # ]: 0 : if (rdev->supply)
3538 : 0 : _regulator_put(rdev->supply);
3539 : 0 : regulator_ena_gpio_free(rdev);
3540 : 0 : kfree(rdev->constraints);
3541 : : wash:
3542 : 0 : device_unregister(&rdev->dev);
3543 : : /* device core frees rdev */
3544 : 0 : rdev = ERR_PTR(ret);
3545 : 0 : goto out;
3546 : :
3547 : : clean:
3548 : 0 : kfree(rdev);
3549 : 0 : rdev = ERR_PTR(ret);
3550 : 0 : goto out;
3551 : : }
3552 : : EXPORT_SYMBOL_GPL(regulator_register);
3553 : :
3554 : : /**
3555 : : * regulator_unregister - unregister regulator
3556 : : * @rdev: regulator to unregister
3557 : : *
3558 : : * Called by regulator drivers to unregister a regulator.
3559 : : */
3560 : 0 : void regulator_unregister(struct regulator_dev *rdev)
3561 : : {
3562 [ # # ]: 0 : if (rdev == NULL)
3563 : 0 : return;
3564 : :
3565 [ # # ]: 0 : if (rdev->supply) {
3566 [ # # ]: 0 : while (rdev->use_count--)
3567 : 0 : regulator_disable(rdev->supply);
3568 : 0 : regulator_put(rdev->supply);
3569 : : }
3570 : 0 : mutex_lock(®ulator_list_mutex);
3571 : 0 : debugfs_remove_recursive(rdev->debugfs);
3572 : 0 : flush_work(&rdev->disable_work.work);
3573 [ # # ]: 0 : WARN_ON(rdev->open_count);
3574 : 0 : unset_regulator_supplies(rdev);
3575 : : list_del(&rdev->list);
3576 : 0 : kfree(rdev->constraints);
3577 : 0 : regulator_ena_gpio_free(rdev);
3578 : 0 : device_unregister(&rdev->dev);
3579 : 0 : mutex_unlock(®ulator_list_mutex);
3580 : : }
3581 : : EXPORT_SYMBOL_GPL(regulator_unregister);
3582 : :
3583 : : /**
3584 : : * regulator_suspend_prepare - prepare regulators for system wide suspend
3585 : : * @state: system suspend state
3586 : : *
3587 : : * Configure each regulator with it's suspend operating parameters for state.
3588 : : * This will usually be called by machine suspend code prior to supending.
3589 : : */
3590 : 0 : int regulator_suspend_prepare(suspend_state_t state)
3591 : : {
3592 : 0 : struct regulator_dev *rdev;
3593 : : int ret = 0;
3594 : :
3595 : : /* ON is handled by regulator active state */
3596 [ # # ]: 0 : if (state == PM_SUSPEND_ON)
3597 : : return -EINVAL;
3598 : :
3599 : 0 : mutex_lock(®ulator_list_mutex);
3600 [ # # ]: 0 : list_for_each_entry(rdev, ®ulator_list, list) {
3601 : :
3602 : 0 : mutex_lock(&rdev->mutex);
3603 : 0 : ret = suspend_prepare(rdev, state);
3604 : 0 : mutex_unlock(&rdev->mutex);
3605 : :
3606 [ # # ]: 0 : if (ret < 0) {
3607 : 0 : rdev_err(rdev, "failed to prepare\n");
3608 : 0 : goto out;
3609 : : }
3610 : : }
3611 : : out:
3612 : 0 : mutex_unlock(®ulator_list_mutex);
3613 : 0 : return ret;
3614 : : }
3615 : : EXPORT_SYMBOL_GPL(regulator_suspend_prepare);
3616 : :
3617 : : /**
3618 : : * regulator_suspend_finish - resume regulators from system wide suspend
3619 : : *
3620 : : * Turn on regulators that might be turned off by regulator_suspend_prepare
3621 : : * and that should be turned on according to the regulators properties.
3622 : : */
3623 : 0 : int regulator_suspend_finish(void)
3624 : : {
3625 : : struct regulator_dev *rdev;
3626 : : int ret = 0, error;
3627 : :
3628 : 0 : mutex_lock(®ulator_list_mutex);
3629 [ # # ]: 0 : list_for_each_entry(rdev, ®ulator_list, list) {
3630 : 0 : mutex_lock(&rdev->mutex);
3631 [ # # ][ # # ]: 0 : if (rdev->use_count > 0 || rdev->constraints->always_on) {
3632 : 0 : error = _regulator_do_enable(rdev);
3633 [ # # ]: 0 : if (error)
3634 : : ret = error;
3635 : : } else {
3636 [ # # ]: 0 : if (!have_full_constraints())
3637 : : goto unlock;
3638 [ # # ]: 0 : if (!_regulator_is_enabled(rdev))
3639 : : goto unlock;
3640 : :
3641 : 0 : error = _regulator_do_disable(rdev);
3642 [ # # ]: 0 : if (error)
3643 : : ret = error;
3644 : : }
3645 : : unlock:
3646 : 0 : mutex_unlock(&rdev->mutex);
3647 : : }
3648 : 0 : mutex_unlock(®ulator_list_mutex);
3649 : 0 : return ret;
3650 : : }
3651 : : EXPORT_SYMBOL_GPL(regulator_suspend_finish);
3652 : :
3653 : : /**
3654 : : * regulator_has_full_constraints - the system has fully specified constraints
3655 : : *
3656 : : * Calling this function will cause the regulator API to disable all
3657 : : * regulators which have a zero use count and don't have an always_on
3658 : : * constraint in a late_initcall.
3659 : : *
3660 : : * The intention is that this will become the default behaviour in a
3661 : : * future kernel release so users are encouraged to use this facility
3662 : : * now.
3663 : : */
3664 : 0 : void regulator_has_full_constraints(void)
3665 : : {
3666 : 0 : has_full_constraints = 1;
3667 : 0 : }
3668 : : EXPORT_SYMBOL_GPL(regulator_has_full_constraints);
3669 : :
3670 : : /**
3671 : : * rdev_get_drvdata - get rdev regulator driver data
3672 : : * @rdev: regulator
3673 : : *
3674 : : * Get rdev regulator driver private data. This call can be used in the
3675 : : * regulator driver context.
3676 : : */
3677 : 0 : void *rdev_get_drvdata(struct regulator_dev *rdev)
3678 : : {
3679 : 0 : return rdev->reg_data;
3680 : : }
3681 : : EXPORT_SYMBOL_GPL(rdev_get_drvdata);
3682 : :
3683 : : /**
3684 : : * regulator_get_drvdata - get regulator driver data
3685 : : * @regulator: regulator
3686 : : *
3687 : : * Get regulator driver private data. This call can be used in the consumer
3688 : : * driver context when non API regulator specific functions need to be called.
3689 : : */
3690 : 0 : void *regulator_get_drvdata(struct regulator *regulator)
3691 : : {
3692 : 0 : return regulator->rdev->reg_data;
3693 : : }
3694 : : EXPORT_SYMBOL_GPL(regulator_get_drvdata);
3695 : :
3696 : : /**
3697 : : * regulator_set_drvdata - set regulator driver data
3698 : : * @regulator: regulator
3699 : : * @data: data
3700 : : */
3701 : 0 : void regulator_set_drvdata(struct regulator *regulator, void *data)
3702 : : {
3703 : 0 : regulator->rdev->reg_data = data;
3704 : 0 : }
3705 : : EXPORT_SYMBOL_GPL(regulator_set_drvdata);
3706 : :
3707 : : /**
3708 : : * regulator_get_id - get regulator ID
3709 : : * @rdev: regulator
3710 : : */
3711 : 0 : int rdev_get_id(struct regulator_dev *rdev)
3712 : : {
3713 : 0 : return rdev->desc->id;
3714 : : }
3715 : : EXPORT_SYMBOL_GPL(rdev_get_id);
3716 : :
3717 : 0 : struct device *rdev_get_dev(struct regulator_dev *rdev)
3718 : : {
3719 : 0 : return &rdev->dev;
3720 : : }
3721 : : EXPORT_SYMBOL_GPL(rdev_get_dev);
3722 : :
3723 : 0 : void *regulator_get_init_drvdata(struct regulator_init_data *reg_init_data)
3724 : : {
3725 : 0 : return reg_init_data->driver_data;
3726 : : }
3727 : : EXPORT_SYMBOL_GPL(regulator_get_init_drvdata);
3728 : :
3729 : : #ifdef CONFIG_DEBUG_FS
3730 : 0 : static ssize_t supply_map_read_file(struct file *file, char __user *user_buf,
3731 : : size_t count, loff_t *ppos)
3732 : : {
3733 : : char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
3734 : : ssize_t len, ret = 0;
3735 : : struct regulator_map *map;
3736 : :
3737 [ # # ]: 0 : if (!buf)
3738 : : return -ENOMEM;
3739 : :
3740 [ # # ]: 0 : list_for_each_entry(map, ®ulator_map_list, list) {
3741 : 0 : len = snprintf(buf + ret, PAGE_SIZE - ret,
3742 : : "%s -> %s.%s\n",
3743 : : rdev_get_name(map->regulator), map->dev_name,
3744 : : map->supply);
3745 [ # # ]: 0 : if (len >= 0)
3746 : 0 : ret += len;
3747 [ # # ]: 0 : if (ret > PAGE_SIZE) {
3748 : : ret = PAGE_SIZE;
3749 : : break;
3750 : : }
3751 : : }
3752 : :
3753 : 0 : ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
3754 : :
3755 : 0 : kfree(buf);
3756 : :
3757 : 0 : return ret;
3758 : : }
3759 : : #endif
3760 : :
3761 : : static const struct file_operations supply_map_fops = {
3762 : : #ifdef CONFIG_DEBUG_FS
3763 : : .read = supply_map_read_file,
3764 : : .llseek = default_llseek,
3765 : : #endif
3766 : : };
3767 : :
3768 : 0 : static int __init regulator_init(void)
3769 : : {
3770 : : int ret;
3771 : :
3772 : 0 : ret = class_register(®ulator_class);
3773 : :
3774 : 0 : debugfs_root = debugfs_create_dir("regulator", NULL);
3775 [ # # ]: 0 : if (!debugfs_root)
3776 : 0 : pr_warn("regulator: Failed to create debugfs directory\n");
3777 : :
3778 : 0 : debugfs_create_file("supply_map", 0444, debugfs_root, NULL,
3779 : : &supply_map_fops);
3780 : :
3781 : 0 : regulator_dummy_init();
3782 : :
3783 : 0 : return ret;
3784 : : }
3785 : :
3786 : : /* init early to allow our consumers to complete system booting */
3787 : : core_initcall(regulator_init);
3788 : :
3789 : 0 : static int __init regulator_init_complete(void)
3790 : : {
3791 : 0 : struct regulator_dev *rdev;
3792 : : struct regulator_ops *ops;
3793 : : struct regulation_constraints *c;
3794 : : int enabled, ret;
3795 : :
3796 : : /*
3797 : : * Since DT doesn't provide an idiomatic mechanism for
3798 : : * enabling full constraints and since it's much more natural
3799 : : * with DT to provide them just assume that a DT enabled
3800 : : * system has full constraints.
3801 : : */
3802 [ # # ]: 0 : if (of_have_populated_dt())
3803 : 0 : has_full_constraints = true;
3804 : :
3805 : 0 : mutex_lock(®ulator_list_mutex);
3806 : :
3807 : : /* If we have a full configuration then disable any regulators
3808 : : * which are not in use or always_on. This will become the
3809 : : * default behaviour in the future.
3810 : : */
3811 [ # # ]: 0 : list_for_each_entry(rdev, ®ulator_list, list) {
3812 : 0 : ops = rdev->desc->ops;
3813 : 0 : c = rdev->constraints;
3814 : :
3815 [ # # ][ # # ]: 0 : if (c && c->always_on)
3816 : 0 : continue;
3817 : :
3818 : 0 : mutex_lock(&rdev->mutex);
3819 : :
3820 [ # # ]: 0 : if (rdev->use_count)
3821 : : goto unlock;
3822 : :
3823 : : /* If we can't read the status assume it's on. */
3824 [ # # ]: 0 : if (ops->is_enabled)
3825 : 0 : enabled = ops->is_enabled(rdev);
3826 : : else
3827 : : enabled = 1;
3828 : :
3829 [ # # ]: 0 : if (!enabled)
3830 : : goto unlock;
3831 : :
3832 [ # # ]: 0 : if (have_full_constraints()) {
3833 : : /* We log since this may kill the system if it
3834 : : * goes wrong. */
3835 : 0 : rdev_info(rdev, "disabling\n");
3836 : 0 : ret = _regulator_do_disable(rdev);
3837 [ # # ]: 0 : if (ret != 0)
3838 : 0 : rdev_err(rdev, "couldn't disable: %d\n", ret);
3839 : : } else {
3840 : : /* The intention is that in future we will
3841 : : * assume that full constraints are provided
3842 : : * so warn even if we aren't going to do
3843 : : * anything here.
3844 : : */
3845 : 0 : rdev_warn(rdev, "incomplete constraints, leaving on\n");
3846 : : }
3847 : :
3848 : : unlock:
3849 : 0 : mutex_unlock(&rdev->mutex);
3850 : : }
3851 : :
3852 : 0 : mutex_unlock(®ulator_list_mutex);
3853 : :
3854 : 0 : return 0;
3855 : : }
3856 : : late_initcall(regulator_init_complete);
|
