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
of_get_regulation_constraints(struct device_node * np,struct regulator_init_data ** init_data,const struct regulator_desc * desc)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 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;
37
38 constraints->name = of_get_property(np, "regulator-name", NULL);
39
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);
46
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;
53
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;
60
61 if (!of_property_read_u32(np, "regulator-input-current-limit-microamp",
62 &pval))
63 constraints->ilim_uA = pval;
64
65 /* Current change possible? */
66 if (constraints->min_uA != constraints->max_uA)
67 constraints->valid_ops_mask |= REGULATOR_CHANGE_CURRENT;
68
69 constraints->boot_on = of_property_read_bool(np, "regulator-boot-on");
70 constraints->always_on = of_property_read_bool(np, "regulator-always-on");
71 if (!constraints->always_on) /* status change should be possible. */
72 constraints->valid_ops_mask |= REGULATOR_CHANGE_STATUS;
73
74 constraints->pull_down = of_property_read_bool(np, "regulator-pull-down");
75
76 if (of_property_read_bool(np, "regulator-allow-bypass"))
77 constraints->valid_ops_mask |= REGULATOR_CHANGE_BYPASS;
78
79 if (of_property_read_bool(np, "regulator-allow-set-load"))
80 constraints->valid_ops_mask |= REGULATOR_CHANGE_DRMS;
81
82 ret = of_property_read_u32(np, "regulator-ramp-delay", &pval);
83 if (!ret) {
84 if (pval)
85 constraints->ramp_delay = pval;
86 else
87 constraints->ramp_disable = true;
88 }
89
90 ret = of_property_read_u32(np, "regulator-enable-ramp-delay", &pval);
91 if (!ret)
92 constraints->enable_time = pval;
93
94 constraints->soft_start = of_property_read_bool(np,
95 "regulator-soft-start");
96
97 if (!of_property_read_u32(np, "regulator-initial-mode", &pval)) {
98 if (desc && desc->of_map_mode) {
99 ret = desc->of_map_mode(pval);
100 if (ret == -EINVAL)
101 pr_err("%s: invalid mode %u\n", np->name, pval);
102 else
103 constraints->initial_mode = ret;
104 } else {
105 pr_warn("%s: mapping for mode %d not defined\n",
106 np->name, pval);
107 }
108 }
109
110 if (!of_property_read_u32(np, "regulator-system-load", &pval))
111 constraints->system_load = pval;
112
113 constraints->over_current_protection = of_property_read_bool(np,
114 "regulator-over-current-protection");
115
116 for (i = 0; i < ARRAY_SIZE(regulator_states); i++) {
117 switch (i) {
118 case PM_SUSPEND_MEM:
119 suspend_state = &constraints->state_mem;
120 break;
121 case PM_SUSPEND_MAX:
122 suspend_state = &constraints->state_disk;
123 break;
124 case PM_SUSPEND_ON:
125 case PM_SUSPEND_FREEZE:
126 case PM_SUSPEND_STANDBY:
127 default:
128 continue;
129 }
130
131 suspend_np = of_get_child_by_name(np, regulator_states[i]);
132 if (!suspend_np || !suspend_state)
133 continue;
134
135 if (!of_property_read_u32(suspend_np, "regulator-mode",
136 &pval)) {
137 if (desc && desc->of_map_mode) {
138 ret = desc->of_map_mode(pval);
139 if (ret == -EINVAL)
140 pr_err("%s: invalid mode %u\n",
141 np->name, pval);
142 else
143 suspend_state->mode = ret;
144 } else {
145 pr_warn("%s: mapping for mode %d not defined\n",
146 np->name, pval);
147 }
148 }
149
150 if (of_property_read_bool(suspend_np,
151 "regulator-on-in-suspend"))
152 suspend_state->enabled = true;
153 else if (of_property_read_bool(suspend_np,
154 "regulator-off-in-suspend"))
155 suspend_state->disabled = true;
156
157 if (!of_property_read_u32(suspend_np,
158 "regulator-suspend-microvolt", &pval))
159 suspend_state->uV = pval;
160
161 of_node_put(suspend_np);
162 suspend_state = NULL;
163 suspend_np = NULL;
164 }
165 }
166
167 /**
168 * of_get_regulator_init_data - extract regulator_init_data structure info
169 * @dev: device requesting for regulator_init_data
170 * @node: regulator device node
171 * @desc: regulator description
172 *
173 * Populates regulator_init_data structure by extracting data from device
174 * tree node, returns a pointer to the populated struture or NULL if memory
175 * alloc fails.
176 */
of_get_regulator_init_data(struct device * dev,struct device_node * node,const struct regulator_desc * desc)177 struct regulator_init_data *of_get_regulator_init_data(struct device *dev,
178 struct device_node *node,
179 const struct regulator_desc *desc)
180 {
181 struct regulator_init_data *init_data;
182
183 if (!node)
184 return NULL;
185
186 init_data = devm_kzalloc(dev, sizeof(*init_data), GFP_KERNEL);
187 if (!init_data)
188 return NULL; /* Out of memory? */
189
190 of_get_regulation_constraints(node, &init_data, desc);
191 return init_data;
192 }
193 EXPORT_SYMBOL_GPL(of_get_regulator_init_data);
194
195 struct devm_of_regulator_matches {
196 struct of_regulator_match *matches;
197 unsigned int num_matches;
198 };
199
devm_of_regulator_put_matches(struct device * dev,void * res)200 static void devm_of_regulator_put_matches(struct device *dev, void *res)
201 {
202 struct devm_of_regulator_matches *devm_matches = res;
203 int i;
204
205 for (i = 0; i < devm_matches->num_matches; i++)
206 of_node_put(devm_matches->matches[i].of_node);
207 }
208
209 /**
210 * of_regulator_match - extract multiple regulator init data from device tree.
211 * @dev: device requesting the data
212 * @node: parent device node of the regulators
213 * @matches: match table for the regulators
214 * @num_matches: number of entries in match table
215 *
216 * This function uses a match table specified by the regulator driver to
217 * parse regulator init data from the device tree. @node is expected to
218 * contain a set of child nodes, each providing the init data for one
219 * regulator. The data parsed from a child node will be matched to a regulator
220 * based on either the deprecated property regulator-compatible if present,
221 * or otherwise the child node's name. Note that the match table is modified
222 * in place and an additional of_node reference is taken for each matched
223 * regulator.
224 *
225 * Returns the number of matches found or a negative error code on failure.
226 */
of_regulator_match(struct device * dev,struct device_node * node,struct of_regulator_match * matches,unsigned int num_matches)227 int of_regulator_match(struct device *dev, struct device_node *node,
228 struct of_regulator_match *matches,
229 unsigned int num_matches)
230 {
231 unsigned int count = 0;
232 unsigned int i;
233 const char *name;
234 struct device_node *child;
235 struct devm_of_regulator_matches *devm_matches;
236
237 if (!dev || !node)
238 return -EINVAL;
239
240 devm_matches = devres_alloc(devm_of_regulator_put_matches,
241 sizeof(struct devm_of_regulator_matches),
242 GFP_KERNEL);
243 if (!devm_matches)
244 return -ENOMEM;
245
246 devm_matches->matches = matches;
247 devm_matches->num_matches = num_matches;
248
249 devres_add(dev, devm_matches);
250
251 for (i = 0; i < num_matches; i++) {
252 struct of_regulator_match *match = &matches[i];
253 match->init_data = NULL;
254 match->of_node = NULL;
255 }
256
257 for_each_child_of_node(node, child) {
258 name = of_get_property(child,
259 "regulator-compatible", NULL);
260 if (!name)
261 name = child->name;
262 for (i = 0; i < num_matches; i++) {
263 struct of_regulator_match *match = &matches[i];
264 if (match->of_node)
265 continue;
266
267 if (strcmp(match->name, name))
268 continue;
269
270 match->init_data =
271 of_get_regulator_init_data(dev, child,
272 match->desc);
273 if (!match->init_data) {
274 dev_err(dev,
275 "failed to parse DT for regulator %s\n",
276 child->name);
277 of_node_put(child);
278 return -EINVAL;
279 }
280 match->of_node = of_node_get(child);
281 count++;
282 break;
283 }
284 }
285
286 return count;
287 }
288 EXPORT_SYMBOL_GPL(of_regulator_match);
289
regulator_of_get_init_data(struct device * dev,const struct regulator_desc * desc,struct regulator_config * config,struct device_node ** node)290 struct regulator_init_data *regulator_of_get_init_data(struct device *dev,
291 const struct regulator_desc *desc,
292 struct regulator_config *config,
293 struct device_node **node)
294 {
295 struct device_node *search, *child;
296 struct regulator_init_data *init_data = NULL;
297 const char *name;
298
299 if (!dev->of_node || !desc->of_match)
300 return NULL;
301
302 if (desc->regulators_node)
303 search = of_get_child_by_name(dev->of_node,
304 desc->regulators_node);
305 else
306 search = dev->of_node;
307
308 if (!search) {
309 dev_dbg(dev, "Failed to find regulator container node '%s'\n",
310 desc->regulators_node);
311 return NULL;
312 }
313
314 for_each_available_child_of_node(search, child) {
315 name = of_get_property(child, "regulator-compatible", NULL);
316 if (!name)
317 name = child->name;
318
319 if (strcmp(desc->of_match, name))
320 continue;
321
322 init_data = of_get_regulator_init_data(dev, child, desc);
323 if (!init_data) {
324 dev_err(dev,
325 "failed to parse DT for regulator %s\n",
326 child->name);
327 break;
328 }
329
330 if (desc->of_parse_cb) {
331 if (desc->of_parse_cb(child, desc, config)) {
332 dev_err(dev,
333 "driver callback failed to parse DT for regulator %s\n",
334 child->name);
335 init_data = NULL;
336 break;
337 }
338 }
339
340 of_node_get(child);
341 *node = child;
342 break;
343 }
344
345 of_node_put(search);
346
347 return init_data;
348 }
349