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
22static 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
27static 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	/* Current change possible? */
62	if (constraints->min_uA != constraints->max_uA)
63		constraints->valid_ops_mask |= REGULATOR_CHANGE_CURRENT;
64
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;
69
70	if (of_property_read_bool(np, "regulator-allow-bypass"))
71		constraints->valid_ops_mask |= REGULATOR_CHANGE_BYPASS;
72
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;
79	}
80
81	ret = of_property_read_u32(np, "regulator-enable-ramp-delay", &pval);
82	if (!ret)
83		constraints->enable_time = pval;
84
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);
95		}
96	}
97
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;
111		};
112
113		suspend_np = of_get_child_by_name(np, regulator_states[i]);
114		if (!suspend_np || !suspend_state)
115			continue;
116
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);
129			}
130		}
131
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;
138
139		if (!of_property_read_u32(suspend_np,
140					"regulator-suspend-microvolt", &pval))
141			suspend_state->uV = pval;
142
143		of_node_put(suspend_np);
144		suspend_state = NULL;
145		suspend_np = NULL;
146	}
147}
148
149/**
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
154 *
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.
158 */
159struct regulator_init_data *of_get_regulator_init_data(struct device *dev,
160					  struct device_node *node,
161					  const struct regulator_desc *desc)
162{
163	struct regulator_init_data *init_data;
164
165	if (!node)
166		return NULL;
167
168	init_data = devm_kzalloc(dev, sizeof(*init_data), GFP_KERNEL);
169	if (!init_data)
170		return NULL; /* Out of memory? */
171
172	of_get_regulation_constraints(node, &init_data, desc);
173	return init_data;
174}
175EXPORT_SYMBOL_GPL(of_get_regulator_init_data);
176
177struct devm_of_regulator_matches {
178	struct of_regulator_match *matches;
179	unsigned int num_matches;
180};
181
182static void devm_of_regulator_put_matches(struct device *dev, void *res)
183{
184	struct devm_of_regulator_matches *devm_matches = res;
185	int i;
186
187	for (i = 0; i < devm_matches->num_matches; i++)
188		of_node_put(devm_matches->matches[i].of_node);
189}
190
191/**
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
197 *
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.
206 *
207 * Returns the number of matches found or a negative error code on failure.
208 */
209int of_regulator_match(struct device *dev, struct device_node *node,
210		       struct of_regulator_match *matches,
211		       unsigned int num_matches)
212{
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;
218
219	if (!dev || !node)
220		return -EINVAL;
221
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;
227
228	devm_matches->matches = matches;
229	devm_matches->num_matches = num_matches;
230
231	devres_add(dev, devm_matches);
232
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;
237	}
238
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;
248
249			if (strcmp(match->name, name))
250				continue;
251
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;
260			}
261			match->of_node = of_node_get(child);
262			count++;
263			break;
264		}
265	}
266
267	return count;
268}
269EXPORT_SYMBOL_GPL(of_regulator_match);
270
271struct 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)
275{
276	struct device_node *search, *child;
277	struct regulator_init_data *init_data = NULL;
278	const char *name;
279
280	if (!dev->of_node || !desc->of_match)
281		return NULL;
282
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;
288
289	if (!search) {
290		dev_dbg(dev, "Failed to find regulator container node '%s'\n",
291			desc->regulators_node);
292		return NULL;
293	}
294
295	for_each_child_of_node(search, child) {
296		name = of_get_property(child, "regulator-compatible", NULL);
297		if (!name)
298			name = child->name;
299
300		if (strcmp(desc->of_match, name))
301			continue;
302
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;
309		}
310
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;
318			}
319		}
320
321		of_node_get(child);
322		*node = child;
323		break;
324	}
325
326	of_node_put(search);
327
328	return init_data;
329}
330