Merge branch 'topic/suspend' of https://git.kernel.org/pub/scm/linux/kernel/git/broon...
[muen/linux.git] / drivers / regulator / of_regulator.c
1 /*
2  * OF helpers for regulator framework
3  *
4  * Copyright (C) 2011 Texas Instruments, Inc.
5  * Rajendra Nayak <rnayak@ti.com>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  */
12
13 #include <linux/module.h>
14 #include <linux/slab.h>
15 #include <linux/of.h>
16 #include <linux/regulator/machine.h>
17 #include <linux/regulator/driver.h>
18 #include <linux/regulator/of_regulator.h>
19
20 #include "internal.h"
21
22 static const char *const regulator_states[PM_SUSPEND_MAX + 1] = {
23         [PM_SUSPEND_MEM]        = "regulator-state-mem",
24         [PM_SUSPEND_MAX]        = "regulator-state-disk",
25 };
26
27 static void of_get_regulation_constraints(struct device_node *np,
28                                         struct regulator_init_data **init_data,
29                                         const struct regulator_desc *desc)
30 {
31         struct regulation_constraints *constraints = &(*init_data)->constraints;
32         struct regulator_state *suspend_state;
33         struct device_node *suspend_np;
34         int ret, i;
35         u32 pval;
36
37         constraints->name = of_get_property(np, "regulator-name", NULL);
38
39         if (!of_property_read_u32(np, "regulator-min-microvolt", &pval))
40                 constraints->min_uV = pval;
41
42         if (!of_property_read_u32(np, "regulator-max-microvolt", &pval))
43                 constraints->max_uV = pval;
44
45         /* Voltage change possible? */
46         if (constraints->min_uV != constraints->max_uV)
47                 constraints->valid_ops_mask |= REGULATOR_CHANGE_VOLTAGE;
48
49         /* Do we have a voltage range, if so try to apply it? */
50         if (constraints->min_uV && constraints->max_uV)
51                 constraints->apply_uV = true;
52
53         if (!of_property_read_u32(np, "regulator-microvolt-offset", &pval))
54                 constraints->uV_offset = pval;
55         if (!of_property_read_u32(np, "regulator-min-microamp", &pval))
56                 constraints->min_uA = pval;
57         if (!of_property_read_u32(np, "regulator-max-microamp", &pval))
58                 constraints->max_uA = pval;
59
60         if (!of_property_read_u32(np, "regulator-input-current-limit-microamp",
61                                   &pval))
62                 constraints->ilim_uA = pval;
63
64         /* Current change possible? */
65         if (constraints->min_uA != constraints->max_uA)
66                 constraints->valid_ops_mask |= REGULATOR_CHANGE_CURRENT;
67
68         constraints->boot_on = of_property_read_bool(np, "regulator-boot-on");
69         constraints->always_on = of_property_read_bool(np, "regulator-always-on");
70         if (!constraints->always_on) /* status change should be possible. */
71                 constraints->valid_ops_mask |= REGULATOR_CHANGE_STATUS;
72
73         constraints->pull_down = of_property_read_bool(np, "regulator-pull-down");
74
75         if (of_property_read_bool(np, "regulator-allow-bypass"))
76                 constraints->valid_ops_mask |= REGULATOR_CHANGE_BYPASS;
77
78         if (of_property_read_bool(np, "regulator-allow-set-load"))
79                 constraints->valid_ops_mask |= REGULATOR_CHANGE_DRMS;
80
81         ret = of_property_read_u32(np, "regulator-ramp-delay", &pval);
82         if (!ret) {
83                 if (pval)
84                         constraints->ramp_delay = pval;
85                 else
86                         constraints->ramp_disable = true;
87         }
88
89         ret = of_property_read_u32(np, "regulator-settling-time-us", &pval);
90         if (!ret)
91                 constraints->settling_time = pval;
92
93         ret = of_property_read_u32(np, "regulator-settling-time-up-us", &pval);
94         if (!ret)
95                 constraints->settling_time_up = pval;
96         if (constraints->settling_time_up && constraints->settling_time) {
97                 pr_warn("%s: ambiguous configuration for settling time, ignoring 'regulator-settling-time-up-us'\n",
98                         np->name);
99                 constraints->settling_time_up = 0;
100         }
101
102         ret = of_property_read_u32(np, "regulator-settling-time-down-us",
103                                    &pval);
104         if (!ret)
105                 constraints->settling_time_down = pval;
106         if (constraints->settling_time_down && constraints->settling_time) {
107                 pr_warn("%s: ambiguous configuration for settling time, ignoring 'regulator-settling-time-down-us'\n",
108                         np->name);
109                 constraints->settling_time_down = 0;
110         }
111
112         ret = of_property_read_u32(np, "regulator-enable-ramp-delay", &pval);
113         if (!ret)
114                 constraints->enable_time = pval;
115
116         constraints->soft_start = of_property_read_bool(np,
117                                         "regulator-soft-start");
118         ret = of_property_read_u32(np, "regulator-active-discharge", &pval);
119         if (!ret) {
120                 constraints->active_discharge =
121                                 (pval) ? REGULATOR_ACTIVE_DISCHARGE_ENABLE :
122                                         REGULATOR_ACTIVE_DISCHARGE_DISABLE;
123         }
124
125         if (!of_property_read_u32(np, "regulator-initial-mode", &pval)) {
126                 if (desc && desc->of_map_mode) {
127                         ret = desc->of_map_mode(pval);
128                         if (ret == -EINVAL)
129                                 pr_err("%s: invalid mode %u\n", np->name, pval);
130                         else
131                                 constraints->initial_mode = ret;
132                 } else {
133                         pr_warn("%s: mapping for mode %d not defined\n",
134                                 np->name, pval);
135                 }
136         }
137
138         if (!of_property_read_u32(np, "regulator-system-load", &pval))
139                 constraints->system_load = pval;
140
141         constraints->over_current_protection = of_property_read_bool(np,
142                                         "regulator-over-current-protection");
143
144         for (i = 0; i < ARRAY_SIZE(regulator_states); i++) {
145                 switch (i) {
146                 case PM_SUSPEND_MEM:
147                         suspend_state = &constraints->state_mem;
148                         break;
149                 case PM_SUSPEND_MAX:
150                         suspend_state = &constraints->state_disk;
151                         break;
152                 case PM_SUSPEND_ON:
153                 case PM_SUSPEND_TO_IDLE:
154                 case PM_SUSPEND_STANDBY:
155                 default:
156                         continue;
157                 }
158
159                 suspend_np = of_get_child_by_name(np, regulator_states[i]);
160                 if (!suspend_np || !suspend_state)
161                         continue;
162
163                 if (!of_property_read_u32(suspend_np, "regulator-mode",
164                                           &pval)) {
165                         if (desc && desc->of_map_mode) {
166                                 ret = desc->of_map_mode(pval);
167                                 if (ret == -EINVAL)
168                                         pr_err("%s: invalid mode %u\n",
169                                                np->name, pval);
170                                 else
171                                         suspend_state->mode = ret;
172                         } else {
173                                 pr_warn("%s: mapping for mode %d not defined\n",
174                                         np->name, pval);
175                         }
176                 }
177
178                 if (of_property_read_bool(suspend_np,
179                                         "regulator-on-in-suspend"))
180                         suspend_state->enabled = ENABLE_IN_SUSPEND;
181                 else if (of_property_read_bool(suspend_np,
182                                         "regulator-off-in-suspend"))
183                         suspend_state->enabled = DISABLE_IN_SUSPEND;
184                 else
185                         suspend_state->enabled = DO_NOTHING_IN_SUSPEND;
186
187                 if (!of_property_read_u32(np, "regulator-suspend-min-microvolt",
188                                           &pval))
189                         suspend_state->min_uV = pval;
190
191                 if (!of_property_read_u32(np, "regulator-suspend-max-microvolt",
192                                           &pval))
193                         suspend_state->max_uV = pval;
194
195                 if (!of_property_read_u32(suspend_np,
196                                         "regulator-suspend-microvolt", &pval))
197                         suspend_state->uV = pval;
198                 else /* otherwise use min_uV as default suspend voltage */
199                         suspend_state->uV = suspend_state->min_uV;
200
201                 if (of_property_read_bool(suspend_np,
202                                         "regulator-changeable-in-suspend"))
203                         suspend_state->changeable = true;
204
205                 if (i == PM_SUSPEND_MEM)
206                         constraints->initial_state = PM_SUSPEND_MEM;
207
208                 of_node_put(suspend_np);
209                 suspend_state = NULL;
210                 suspend_np = NULL;
211         }
212 }
213
214 /**
215  * of_get_regulator_init_data - extract regulator_init_data structure info
216  * @dev: device requesting for regulator_init_data
217  * @node: regulator device node
218  * @desc: regulator description
219  *
220  * Populates regulator_init_data structure by extracting data from device
221  * tree node, returns a pointer to the populated struture or NULL if memory
222  * alloc fails.
223  */
224 struct regulator_init_data *of_get_regulator_init_data(struct device *dev,
225                                           struct device_node *node,
226                                           const struct regulator_desc *desc)
227 {
228         struct regulator_init_data *init_data;
229
230         if (!node)
231                 return NULL;
232
233         init_data = devm_kzalloc(dev, sizeof(*init_data), GFP_KERNEL);
234         if (!init_data)
235                 return NULL; /* Out of memory? */
236
237         of_get_regulation_constraints(node, &init_data, desc);
238         return init_data;
239 }
240 EXPORT_SYMBOL_GPL(of_get_regulator_init_data);
241
242 struct devm_of_regulator_matches {
243         struct of_regulator_match *matches;
244         unsigned int num_matches;
245 };
246
247 static void devm_of_regulator_put_matches(struct device *dev, void *res)
248 {
249         struct devm_of_regulator_matches *devm_matches = res;
250         int i;
251
252         for (i = 0; i < devm_matches->num_matches; i++)
253                 of_node_put(devm_matches->matches[i].of_node);
254 }
255
256 /**
257  * of_regulator_match - extract multiple regulator init data from device tree.
258  * @dev: device requesting the data
259  * @node: parent device node of the regulators
260  * @matches: match table for the regulators
261  * @num_matches: number of entries in match table
262  *
263  * This function uses a match table specified by the regulator driver to
264  * parse regulator init data from the device tree. @node is expected to
265  * contain a set of child nodes, each providing the init data for one
266  * regulator. The data parsed from a child node will be matched to a regulator
267  * based on either the deprecated property regulator-compatible if present,
268  * or otherwise the child node's name. Note that the match table is modified
269  * in place and an additional of_node reference is taken for each matched
270  * regulator.
271  *
272  * Returns the number of matches found or a negative error code on failure.
273  */
274 int of_regulator_match(struct device *dev, struct device_node *node,
275                        struct of_regulator_match *matches,
276                        unsigned int num_matches)
277 {
278         unsigned int count = 0;
279         unsigned int i;
280         const char *name;
281         struct device_node *child;
282         struct devm_of_regulator_matches *devm_matches;
283
284         if (!dev || !node)
285                 return -EINVAL;
286
287         devm_matches = devres_alloc(devm_of_regulator_put_matches,
288                                     sizeof(struct devm_of_regulator_matches),
289                                     GFP_KERNEL);
290         if (!devm_matches)
291                 return -ENOMEM;
292
293         devm_matches->matches = matches;
294         devm_matches->num_matches = num_matches;
295
296         devres_add(dev, devm_matches);
297
298         for (i = 0; i < num_matches; i++) {
299                 struct of_regulator_match *match = &matches[i];
300                 match->init_data = NULL;
301                 match->of_node = NULL;
302         }
303
304         for_each_child_of_node(node, child) {
305                 name = of_get_property(child,
306                                         "regulator-compatible", NULL);
307                 if (!name)
308                         name = child->name;
309                 for (i = 0; i < num_matches; i++) {
310                         struct of_regulator_match *match = &matches[i];
311                         if (match->of_node)
312                                 continue;
313
314                         if (strcmp(match->name, name))
315                                 continue;
316
317                         match->init_data =
318                                 of_get_regulator_init_data(dev, child,
319                                                            match->desc);
320                         if (!match->init_data) {
321                                 dev_err(dev,
322                                         "failed to parse DT for regulator %s\n",
323                                         child->name);
324                                 return -EINVAL;
325                         }
326                         match->of_node = of_node_get(child);
327                         count++;
328                         break;
329                 }
330         }
331
332         return count;
333 }
334 EXPORT_SYMBOL_GPL(of_regulator_match);
335
336 struct regulator_init_data *regulator_of_get_init_data(struct device *dev,
337                                             const struct regulator_desc *desc,
338                                             struct regulator_config *config,
339                                             struct device_node **node)
340 {
341         struct device_node *search, *child;
342         struct regulator_init_data *init_data = NULL;
343         const char *name;
344
345         if (!dev->of_node || !desc->of_match)
346                 return NULL;
347
348         if (desc->regulators_node)
349                 search = of_get_child_by_name(dev->of_node,
350                                               desc->regulators_node);
351         else
352                 search = of_node_get(dev->of_node);
353
354         if (!search) {
355                 dev_dbg(dev, "Failed to find regulator container node '%s'\n",
356                         desc->regulators_node);
357                 return NULL;
358         }
359
360         for_each_available_child_of_node(search, child) {
361                 name = of_get_property(child, "regulator-compatible", NULL);
362                 if (!name)
363                         name = child->name;
364
365                 if (strcmp(desc->of_match, name))
366                         continue;
367
368                 init_data = of_get_regulator_init_data(dev, child, desc);
369                 if (!init_data) {
370                         dev_err(dev,
371                                 "failed to parse DT for regulator %s\n",
372                                 child->name);
373                         break;
374                 }
375
376                 if (desc->of_parse_cb) {
377                         if (desc->of_parse_cb(child, desc, config)) {
378                                 dev_err(dev,
379                                         "driver callback failed to parse DT for regulator %s\n",
380                                         child->name);
381                                 init_data = NULL;
382                                 break;
383                         }
384                 }
385
386                 of_node_get(child);
387                 *node = child;
388                 break;
389         }
390
391         of_node_put(search);
392
393         return init_data;
394 }
395
396 static int of_node_match(struct device *dev, const void *data)
397 {
398         return dev->of_node == data;
399 }
400
401 struct regulator_dev *of_find_regulator_by_node(struct device_node *np)
402 {
403         struct device *dev;
404
405         dev = class_find_device(&regulator_class, NULL, np, of_node_match);
406
407         return dev ? dev_to_rdev(dev) : NULL;
408 }