Linux 4.1.16
[linux/fpc-iii.git] / drivers / regulator / of_regulator.c
blob24e812c48d93076a36039e991c51bb371fb26d6e
1 /*
2 * OF helpers for regulator framework
4 * Copyright (C) 2011 Texas Instruments, Inc.
5 * Rajendra Nayak <rnayak@ti.com>
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.
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>
20 #include "internal.h"
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",
27 static void of_get_regulation_constraints(struct device_node *np,
28 struct regulator_init_data **init_data,
29 const struct regulator_desc *desc)
31 const __be32 *min_uV, *max_uV;
32 struct regulation_constraints *constraints = &(*init_data)->constraints;
33 struct regulator_state *suspend_state;
34 struct device_node *suspend_np;
35 int ret, i;
36 u32 pval;
38 constraints->name = of_get_property(np, "regulator-name", NULL);
40 min_uV = of_get_property(np, "regulator-min-microvolt", NULL);
41 if (min_uV)
42 constraints->min_uV = be32_to_cpu(*min_uV);
43 max_uV = of_get_property(np, "regulator-max-microvolt", NULL);
44 if (max_uV)
45 constraints->max_uV = be32_to_cpu(*max_uV);
47 /* Voltage change possible? */
48 if (constraints->min_uV != constraints->max_uV)
49 constraints->valid_ops_mask |= REGULATOR_CHANGE_VOLTAGE;
50 /* Only one voltage? Then make sure it's set. */
51 if (min_uV && max_uV && constraints->min_uV == constraints->max_uV)
52 constraints->apply_uV = true;
54 if (!of_property_read_u32(np, "regulator-microvolt-offset", &pval))
55 constraints->uV_offset = pval;
56 if (!of_property_read_u32(np, "regulator-min-microamp", &pval))
57 constraints->min_uA = pval;
58 if (!of_property_read_u32(np, "regulator-max-microamp", &pval))
59 constraints->max_uA = pval;
61 /* Current change possible? */
62 if (constraints->min_uA != constraints->max_uA)
63 constraints->valid_ops_mask |= REGULATOR_CHANGE_CURRENT;
65 constraints->boot_on = of_property_read_bool(np, "regulator-boot-on");
66 constraints->always_on = of_property_read_bool(np, "regulator-always-on");
67 if (!constraints->always_on) /* status change should be possible. */
68 constraints->valid_ops_mask |= REGULATOR_CHANGE_STATUS;
70 if (of_property_read_bool(np, "regulator-allow-bypass"))
71 constraints->valid_ops_mask |= REGULATOR_CHANGE_BYPASS;
73 ret = of_property_read_u32(np, "regulator-ramp-delay", &pval);
74 if (!ret) {
75 if (pval)
76 constraints->ramp_delay = pval;
77 else
78 constraints->ramp_disable = true;
81 ret = of_property_read_u32(np, "regulator-enable-ramp-delay", &pval);
82 if (!ret)
83 constraints->enable_time = pval;
85 if (!of_property_read_u32(np, "regulator-initial-mode", &pval)) {
86 if (desc && desc->of_map_mode) {
87 ret = desc->of_map_mode(pval);
88 if (ret == -EINVAL)
89 pr_err("%s: invalid mode %u\n", np->name, pval);
90 else
91 constraints->initial_mode = ret;
92 } else {
93 pr_warn("%s: mapping for mode %d not defined\n",
94 np->name, pval);
98 for (i = 0; i < ARRAY_SIZE(regulator_states); i++) {
99 switch (i) {
100 case PM_SUSPEND_MEM:
101 suspend_state = &constraints->state_mem;
102 break;
103 case PM_SUSPEND_MAX:
104 suspend_state = &constraints->state_disk;
105 break;
106 case PM_SUSPEND_ON:
107 case PM_SUSPEND_FREEZE:
108 case PM_SUSPEND_STANDBY:
109 default:
110 continue;
113 suspend_np = of_get_child_by_name(np, regulator_states[i]);
114 if (!suspend_np || !suspend_state)
115 continue;
117 if (!of_property_read_u32(suspend_np, "regulator-mode",
118 &pval)) {
119 if (desc && desc->of_map_mode) {
120 ret = desc->of_map_mode(pval);
121 if (ret == -EINVAL)
122 pr_err("%s: invalid mode %u\n",
123 np->name, pval);
124 else
125 suspend_state->mode = ret;
126 } else {
127 pr_warn("%s: mapping for mode %d not defined\n",
128 np->name, pval);
132 if (of_property_read_bool(suspend_np,
133 "regulator-on-in-suspend"))
134 suspend_state->enabled = true;
135 else if (of_property_read_bool(suspend_np,
136 "regulator-off-in-suspend"))
137 suspend_state->disabled = true;
139 if (!of_property_read_u32(suspend_np,
140 "regulator-suspend-microvolt", &pval))
141 suspend_state->uV = pval;
143 of_node_put(suspend_np);
144 suspend_state = NULL;
145 suspend_np = NULL;
150 * of_get_regulator_init_data - extract regulator_init_data structure info
151 * @dev: device requesting for regulator_init_data
152 * @node: regulator device node
153 * @desc: regulator description
155 * Populates regulator_init_data structure by extracting data from device
156 * tree node, returns a pointer to the populated struture or NULL if memory
157 * alloc fails.
159 struct regulator_init_data *of_get_regulator_init_data(struct device *dev,
160 struct device_node *node,
161 const struct regulator_desc *desc)
163 struct regulator_init_data *init_data;
165 if (!node)
166 return NULL;
168 init_data = devm_kzalloc(dev, sizeof(*init_data), GFP_KERNEL);
169 if (!init_data)
170 return NULL; /* Out of memory? */
172 of_get_regulation_constraints(node, &init_data, desc);
173 return init_data;
175 EXPORT_SYMBOL_GPL(of_get_regulator_init_data);
177 struct devm_of_regulator_matches {
178 struct of_regulator_match *matches;
179 unsigned int num_matches;
182 static void devm_of_regulator_put_matches(struct device *dev, void *res)
184 struct devm_of_regulator_matches *devm_matches = res;
185 int i;
187 for (i = 0; i < devm_matches->num_matches; i++)
188 of_node_put(devm_matches->matches[i].of_node);
192 * of_regulator_match - extract multiple regulator init data from device tree.
193 * @dev: device requesting the data
194 * @node: parent device node of the regulators
195 * @matches: match table for the regulators
196 * @num_matches: number of entries in match table
198 * This function uses a match table specified by the regulator driver to
199 * parse regulator init data from the device tree. @node is expected to
200 * contain a set of child nodes, each providing the init data for one
201 * regulator. The data parsed from a child node will be matched to a regulator
202 * based on either the deprecated property regulator-compatible if present,
203 * or otherwise the child node's name. Note that the match table is modified
204 * in place and an additional of_node reference is taken for each matched
205 * regulator.
207 * Returns the number of matches found or a negative error code on failure.
209 int of_regulator_match(struct device *dev, struct device_node *node,
210 struct of_regulator_match *matches,
211 unsigned int num_matches)
213 unsigned int count = 0;
214 unsigned int i;
215 const char *name;
216 struct device_node *child;
217 struct devm_of_regulator_matches *devm_matches;
219 if (!dev || !node)
220 return -EINVAL;
222 devm_matches = devres_alloc(devm_of_regulator_put_matches,
223 sizeof(struct devm_of_regulator_matches),
224 GFP_KERNEL);
225 if (!devm_matches)
226 return -ENOMEM;
228 devm_matches->matches = matches;
229 devm_matches->num_matches = num_matches;
231 devres_add(dev, devm_matches);
233 for (i = 0; i < num_matches; i++) {
234 struct of_regulator_match *match = &matches[i];
235 match->init_data = NULL;
236 match->of_node = NULL;
239 for_each_child_of_node(node, child) {
240 name = of_get_property(child,
241 "regulator-compatible", NULL);
242 if (!name)
243 name = child->name;
244 for (i = 0; i < num_matches; i++) {
245 struct of_regulator_match *match = &matches[i];
246 if (match->of_node)
247 continue;
249 if (strcmp(match->name, name))
250 continue;
252 match->init_data =
253 of_get_regulator_init_data(dev, child,
254 match->desc);
255 if (!match->init_data) {
256 dev_err(dev,
257 "failed to parse DT for regulator %s\n",
258 child->name);
259 return -EINVAL;
261 match->of_node = of_node_get(child);
262 count++;
263 break;
267 return count;
269 EXPORT_SYMBOL_GPL(of_regulator_match);
271 struct regulator_init_data *regulator_of_get_init_data(struct device *dev,
272 const struct regulator_desc *desc,
273 struct regulator_config *config,
274 struct device_node **node)
276 struct device_node *search, *child;
277 struct regulator_init_data *init_data = NULL;
278 const char *name;
280 if (!dev->of_node || !desc->of_match)
281 return NULL;
283 if (desc->regulators_node)
284 search = of_get_child_by_name(dev->of_node,
285 desc->regulators_node);
286 else
287 search = dev->of_node;
289 if (!search) {
290 dev_dbg(dev, "Failed to find regulator container node '%s'\n",
291 desc->regulators_node);
292 return NULL;
295 for_each_child_of_node(search, child) {
296 name = of_get_property(child, "regulator-compatible", NULL);
297 if (!name)
298 name = child->name;
300 if (strcmp(desc->of_match, name))
301 continue;
303 init_data = of_get_regulator_init_data(dev, child, desc);
304 if (!init_data) {
305 dev_err(dev,
306 "failed to parse DT for regulator %s\n",
307 child->name);
308 break;
311 if (desc->of_parse_cb) {
312 if (desc->of_parse_cb(child, desc, config)) {
313 dev_err(dev,
314 "driver callback failed to parse DT for regulator %s\n",
315 child->name);
316 init_data = NULL;
317 break;
321 of_node_get(child);
322 *node = child;
323 break;
326 of_node_put(search);
328 return init_data;