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/of_regulator.h>
 18
 19static void of_get_regulation_constraints(struct device_node *np,
 20					struct regulator_init_data **init_data)
 21{
 22	const __be32 *min_uV, *max_uV, *uV_offset;
 23	const __be32 *min_uA, *max_uA, *ramp_delay;
 24	struct property *prop;
 25	struct regulation_constraints *constraints = &(*init_data)->constraints;
 26	int ret;
 27	u32 pval;
 28
 29	constraints->name = of_get_property(np, "regulator-name", NULL);
 30
 31	min_uV = of_get_property(np, "regulator-min-microvolt", NULL);
 32	if (min_uV)
 33		constraints->min_uV = be32_to_cpu(*min_uV);
 34	max_uV = of_get_property(np, "regulator-max-microvolt", NULL);
 35	if (max_uV)
 36		constraints->max_uV = be32_to_cpu(*max_uV);
 37
 38	/* Voltage change possible? */
 39	if (constraints->min_uV != constraints->max_uV)
 40		constraints->valid_ops_mask |= REGULATOR_CHANGE_VOLTAGE;
 41	/* Only one voltage?  Then make sure it's set. */
 42	if (min_uV && max_uV && constraints->min_uV == constraints->max_uV)
 43		constraints->apply_uV = true;
 44
 45	uV_offset = of_get_property(np, "regulator-microvolt-offset", NULL);
 46	if (uV_offset)
 47		constraints->uV_offset = be32_to_cpu(*uV_offset);
 48	min_uA = of_get_property(np, "regulator-min-microamp", NULL);
 49	if (min_uA)
 50		constraints->min_uA = be32_to_cpu(*min_uA);
 51	max_uA = of_get_property(np, "regulator-max-microamp", NULL);
 52	if (max_uA)
 53		constraints->max_uA = be32_to_cpu(*max_uA);
 54
 55	/* Current change possible? */
 56	if (constraints->min_uA != constraints->max_uA)
 57		constraints->valid_ops_mask |= REGULATOR_CHANGE_CURRENT;
 58
 59	if (of_find_property(np, "regulator-boot-on", NULL))
 60		constraints->boot_on = true;
 61
 62	if (of_find_property(np, "regulator-always-on", NULL))
 63		constraints->always_on = true;
 64	else /* status change should be possible if not always on. */
 65		constraints->valid_ops_mask |= REGULATOR_CHANGE_STATUS;
 66
 67	if (of_property_read_bool(np, "regulator-allow-bypass"))
 68		constraints->valid_ops_mask |= REGULATOR_CHANGE_BYPASS;
 69
 70	prop = of_find_property(np, "regulator-ramp-delay", NULL);
 71	if (prop && prop->value) {
 72		ramp_delay = prop->value;
 73		if (*ramp_delay)
 74			constraints->ramp_delay = be32_to_cpu(*ramp_delay);
 75		else
 76			constraints->ramp_disable = true;
 77	}
 78
 79	ret = of_property_read_u32(np, "regulator-enable-ramp-delay", &pval);
 80	if (!ret)
 81		constraints->enable_time = pval;
 82}
 83
 84/**
 85 * of_get_regulator_init_data - extract regulator_init_data structure info
 86 * @dev: device requesting for regulator_init_data
 87 *
 88 * Populates regulator_init_data structure by extracting data from device
 89 * tree node, returns a pointer to the populated struture or NULL if memory
 90 * alloc fails.
 91 */
 92struct regulator_init_data *of_get_regulator_init_data(struct device *dev,
 93						struct device_node *node)
 94{
 95	struct regulator_init_data *init_data;
 96
 97	if (!node)
 98		return NULL;
 99
100	init_data = devm_kzalloc(dev, sizeof(*init_data), GFP_KERNEL);
101	if (!init_data)
102		return NULL; /* Out of memory? */
103
104	of_get_regulation_constraints(node, &init_data);
105	return init_data;
106}
107EXPORT_SYMBOL_GPL(of_get_regulator_init_data);
108
109/**
110 * of_regulator_match - extract multiple regulator init data from device tree.
111 * @dev: device requesting the data
112 * @node: parent device node of the regulators
113 * @matches: match table for the regulators
114 * @num_matches: number of entries in match table
115 *
116 * This function uses a match table specified by the regulator driver to
117 * parse regulator init data from the device tree. @node is expected to
118 * contain a set of child nodes, each providing the init data for one
119 * regulator. The data parsed from a child node will be matched to a regulator
120 * based on either the deprecated property regulator-compatible if present,
121 * or otherwise the child node's name. Note that the match table is modified
122 * in place.
123 *
124 * Returns the number of matches found or a negative error code on failure.
125 */
126int of_regulator_match(struct device *dev, struct device_node *node,
127		       struct of_regulator_match *matches,
128		       unsigned int num_matches)
129{
130	unsigned int count = 0;
131	unsigned int i;
132	const char *name;
133	struct device_node *child;
134
135	if (!dev || !node)
136		return -EINVAL;
137
138	for (i = 0; i < num_matches; i++) {
139		struct of_regulator_match *match = &matches[i];
140		match->init_data = NULL;
141		match->of_node = NULL;
142	}
143
144	for_each_child_of_node(node, child) {
145		name = of_get_property(child,
146					"regulator-compatible", NULL);
147		if (!name)
148			name = child->name;
149		for (i = 0; i < num_matches; i++) {
150			struct of_regulator_match *match = &matches[i];
151			if (match->of_node)
152				continue;
153
154			if (strcmp(match->name, name))
155				continue;
156
157			match->init_data =
158				of_get_regulator_init_data(dev, child);
159			if (!match->init_data) {
160				dev_err(dev,
161					"failed to parse DT for regulator %s\n",
162					child->name);
163				return -EINVAL;
164			}
165			match->of_node = child;
166			count++;
167			break;
168		}
169	}
170
171	return count;
172}
173EXPORT_SYMBOL_GPL(of_regulator_match);