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	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 */
177struct 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}
193EXPORT_SYMBOL_GPL(of_get_regulator_init_data);
194
195struct devm_of_regulator_matches {
196	struct of_regulator_match *matches;
197	unsigned int num_matches;
198};
199
200static 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 */
227int 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				return -EINVAL;
278			}
279			match->of_node = of_node_get(child);
280			count++;
281			break;
282		}
283	}
284
285	return count;
286}
287EXPORT_SYMBOL_GPL(of_regulator_match);
288
289struct regulator_init_data *regulator_of_get_init_data(struct device *dev,
290					    const struct regulator_desc *desc,
291					    struct regulator_config *config,
292					    struct device_node **node)
293{
294	struct device_node *search, *child;
295	struct regulator_init_data *init_data = NULL;
296	const char *name;
297
298	if (!dev->of_node || !desc->of_match)
299		return NULL;
300
301	if (desc->regulators_node)
302		search = of_get_child_by_name(dev->of_node,
303					      desc->regulators_node);
304	else
305		search = dev->of_node;
306
307	if (!search) {
308		dev_dbg(dev, "Failed to find regulator container node '%s'\n",
309			desc->regulators_node);
310		return NULL;
311	}
312
313	for_each_available_child_of_node(search, child) {
314		name = of_get_property(child, "regulator-compatible", NULL);
315		if (!name)
316			name = child->name;
317
318		if (strcmp(desc->of_match, name))
319			continue;
320
321		init_data = of_get_regulator_init_data(dev, child, desc);
322		if (!init_data) {
323			dev_err(dev,
324				"failed to parse DT for regulator %s\n",
325				child->name);
326			break;
327		}
328
329		if (desc->of_parse_cb) {
330			if (desc->of_parse_cb(child, desc, config)) {
331				dev_err(dev,
332					"driver callback failed to parse DT for regulator %s\n",
333					child->name);
334				init_data = NULL;
335				break;
336			}
337		}
338
339		of_node_get(child);
340		*node = child;
341		break;
342	}
343
344	of_node_put(search);
345
346	return init_data;
347}
348