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