xref: /openbmc/linux/drivers/pinctrl/devicetree.c (revision 82003e04)
1 /*
2  * Device tree integration for the pin control subsystem
3  *
4  * Copyright (C) 2012 NVIDIA CORPORATION. All rights reserved.
5  *
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms and conditions of the GNU General Public License,
8  * version 2, as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope it will be useful, but WITHOUT
11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
13  * more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
17  */
18 
19 #include <linux/device.h>
20 #include <linux/of.h>
21 #include <linux/pinctrl/pinctrl.h>
22 #include <linux/slab.h>
23 
24 #include "core.h"
25 #include "devicetree.h"
26 
27 /**
28  * struct pinctrl_dt_map - mapping table chunk parsed from device tree
29  * @node: list node for struct pinctrl's @dt_maps field
30  * @pctldev: the pin controller that allocated this struct, and will free it
31  * @maps: the mapping table entries
32  */
33 struct pinctrl_dt_map {
34 	struct list_head node;
35 	struct pinctrl_dev *pctldev;
36 	struct pinctrl_map *map;
37 	unsigned num_maps;
38 };
39 
40 static void dt_free_map(struct pinctrl_dev *pctldev,
41 		     struct pinctrl_map *map, unsigned num_maps)
42 {
43 	if (pctldev) {
44 		const struct pinctrl_ops *ops = pctldev->desc->pctlops;
45 		ops->dt_free_map(pctldev, map, num_maps);
46 	} else {
47 		/* There is no pctldev for PIN_MAP_TYPE_DUMMY_STATE */
48 		kfree(map);
49 	}
50 }
51 
52 void pinctrl_dt_free_maps(struct pinctrl *p)
53 {
54 	struct pinctrl_dt_map *dt_map, *n1;
55 
56 	list_for_each_entry_safe(dt_map, n1, &p->dt_maps, node) {
57 		pinctrl_unregister_map(dt_map->map);
58 		list_del(&dt_map->node);
59 		dt_free_map(dt_map->pctldev, dt_map->map,
60 			    dt_map->num_maps);
61 		kfree(dt_map);
62 	}
63 
64 	of_node_put(p->dev->of_node);
65 }
66 
67 static int dt_remember_or_free_map(struct pinctrl *p, const char *statename,
68 				   struct pinctrl_dev *pctldev,
69 				   struct pinctrl_map *map, unsigned num_maps)
70 {
71 	int i;
72 	struct pinctrl_dt_map *dt_map;
73 
74 	/* Initialize common mapping table entry fields */
75 	for (i = 0; i < num_maps; i++) {
76 		map[i].dev_name = dev_name(p->dev);
77 		map[i].name = statename;
78 		if (pctldev)
79 			map[i].ctrl_dev_name = dev_name(pctldev->dev);
80 	}
81 
82 	/* Remember the converted mapping table entries */
83 	dt_map = kzalloc(sizeof(*dt_map), GFP_KERNEL);
84 	if (!dt_map) {
85 		dev_err(p->dev, "failed to alloc struct pinctrl_dt_map\n");
86 		dt_free_map(pctldev, map, num_maps);
87 		return -ENOMEM;
88 	}
89 
90 	dt_map->pctldev = pctldev;
91 	dt_map->map = map;
92 	dt_map->num_maps = num_maps;
93 	list_add_tail(&dt_map->node, &p->dt_maps);
94 
95 	return pinctrl_register_map(map, num_maps, false);
96 }
97 
98 struct pinctrl_dev *of_pinctrl_get(struct device_node *np)
99 {
100 	return get_pinctrl_dev_from_of_node(np);
101 }
102 
103 static int dt_to_map_one_config(struct pinctrl *p, const char *statename,
104 				struct device_node *np_config)
105 {
106 	struct device_node *np_pctldev;
107 	struct pinctrl_dev *pctldev;
108 	const struct pinctrl_ops *ops;
109 	int ret;
110 	struct pinctrl_map *map;
111 	unsigned num_maps;
112 
113 	/* Find the pin controller containing np_config */
114 	np_pctldev = of_node_get(np_config);
115 	for (;;) {
116 		np_pctldev = of_get_next_parent(np_pctldev);
117 		if (!np_pctldev || of_node_is_root(np_pctldev)) {
118 			dev_info(p->dev, "could not find pctldev for node %s, deferring probe\n",
119 				np_config->full_name);
120 			of_node_put(np_pctldev);
121 			/* OK let's just assume this will appear later then */
122 			return -EPROBE_DEFER;
123 		}
124 		pctldev = get_pinctrl_dev_from_of_node(np_pctldev);
125 		if (pctldev)
126 			break;
127 		/* Do not defer probing of hogs (circular loop) */
128 		if (np_pctldev == p->dev->of_node) {
129 			of_node_put(np_pctldev);
130 			return -ENODEV;
131 		}
132 	}
133 	of_node_put(np_pctldev);
134 
135 	/*
136 	 * Call pinctrl driver to parse device tree node, and
137 	 * generate mapping table entries
138 	 */
139 	ops = pctldev->desc->pctlops;
140 	if (!ops->dt_node_to_map) {
141 		dev_err(p->dev, "pctldev %s doesn't support DT\n",
142 			dev_name(pctldev->dev));
143 		return -ENODEV;
144 	}
145 	ret = ops->dt_node_to_map(pctldev, np_config, &map, &num_maps);
146 	if (ret < 0)
147 		return ret;
148 
149 	/* Stash the mapping table chunk away for later use */
150 	return dt_remember_or_free_map(p, statename, pctldev, map, num_maps);
151 }
152 
153 static int dt_remember_dummy_state(struct pinctrl *p, const char *statename)
154 {
155 	struct pinctrl_map *map;
156 
157 	map = kzalloc(sizeof(*map), GFP_KERNEL);
158 	if (!map) {
159 		dev_err(p->dev, "failed to alloc struct pinctrl_map\n");
160 		return -ENOMEM;
161 	}
162 
163 	/* There is no pctldev for PIN_MAP_TYPE_DUMMY_STATE */
164 	map->type = PIN_MAP_TYPE_DUMMY_STATE;
165 
166 	return dt_remember_or_free_map(p, statename, NULL, map, 1);
167 }
168 
169 int pinctrl_dt_to_map(struct pinctrl *p)
170 {
171 	struct device_node *np = p->dev->of_node;
172 	int state, ret;
173 	char *propname;
174 	struct property *prop;
175 	const char *statename;
176 	const __be32 *list;
177 	int size, config;
178 	phandle phandle;
179 	struct device_node *np_config;
180 
181 	/* CONFIG_OF enabled, p->dev not instantiated from DT */
182 	if (!np) {
183 		if (of_have_populated_dt())
184 			dev_dbg(p->dev,
185 				"no of_node; not parsing pinctrl DT\n");
186 		return 0;
187 	}
188 
189 	/* We may store pointers to property names within the node */
190 	of_node_get(np);
191 
192 	/* For each defined state ID */
193 	for (state = 0; ; state++) {
194 		/* Retrieve the pinctrl-* property */
195 		propname = kasprintf(GFP_KERNEL, "pinctrl-%d", state);
196 		prop = of_find_property(np, propname, &size);
197 		kfree(propname);
198 		if (!prop) {
199 			if (state == 0) {
200 				of_node_put(np);
201 				return -ENODEV;
202 			}
203 			break;
204 		}
205 		list = prop->value;
206 		size /= sizeof(*list);
207 
208 		/* Determine whether pinctrl-names property names the state */
209 		ret = of_property_read_string_index(np, "pinctrl-names",
210 						    state, &statename);
211 		/*
212 		 * If not, statename is just the integer state ID. But rather
213 		 * than dynamically allocate it and have to free it later,
214 		 * just point part way into the property name for the string.
215 		 */
216 		if (ret < 0) {
217 			/* strlen("pinctrl-") == 8 */
218 			statename = prop->name + 8;
219 		}
220 
221 		/* For every referenced pin configuration node in it */
222 		for (config = 0; config < size; config++) {
223 			phandle = be32_to_cpup(list++);
224 
225 			/* Look up the pin configuration node */
226 			np_config = of_find_node_by_phandle(phandle);
227 			if (!np_config) {
228 				dev_err(p->dev,
229 					"prop %s index %i invalid phandle\n",
230 					prop->name, config);
231 				ret = -EINVAL;
232 				goto err;
233 			}
234 
235 			/* Parse the node */
236 			ret = dt_to_map_one_config(p, statename, np_config);
237 			of_node_put(np_config);
238 			if (ret < 0)
239 				goto err;
240 		}
241 
242 		/* No entries in DT? Generate a dummy state table entry */
243 		if (!size) {
244 			ret = dt_remember_dummy_state(p, statename);
245 			if (ret < 0)
246 				goto err;
247 		}
248 	}
249 
250 	return 0;
251 
252 err:
253 	pinctrl_dt_free_maps(p);
254 	return ret;
255 }
256