]>
Commit | Line | Data |
---|---|---|
57291ce2 SW |
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 | 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, true); | |
96 | } | |
97 | ||
98 | static struct pinctrl_dev *find_pinctrl_by_of_node(struct device_node *np) | |
99 | { | |
100 | struct pinctrl_dev *pctldev; | |
101 | ||
102 | list_for_each_entry(pctldev, &pinctrldev_list, node) | |
103 | if (pctldev->dev->of_node == np) | |
104 | return pctldev; | |
105 | ||
106 | return NULL; | |
107 | } | |
108 | ||
1e63d7b9 | 109 | struct pinctrl_dev *of_pinctrl_get(struct device_node *np) |
f23f1516 SH |
110 | { |
111 | struct pinctrl_dev *pctldev; | |
112 | ||
113 | pctldev = find_pinctrl_by_of_node(np); | |
114 | if (!pctldev) | |
115 | return NULL; | |
116 | ||
f23f1516 SH |
117 | return pctldev; |
118 | } | |
119 | ||
57291ce2 SW |
120 | static int dt_to_map_one_config(struct pinctrl *p, const char *statename, |
121 | struct device_node *np_config) | |
122 | { | |
123 | struct device_node *np_pctldev; | |
124 | struct pinctrl_dev *pctldev; | |
125 | struct pinctrl_ops *ops; | |
126 | int ret; | |
127 | struct pinctrl_map *map; | |
128 | unsigned num_maps; | |
129 | ||
130 | /* Find the pin controller containing np_config */ | |
131 | np_pctldev = of_node_get(np_config); | |
132 | for (;;) { | |
133 | np_pctldev = of_get_next_parent(np_pctldev); | |
134 | if (!np_pctldev || of_node_is_root(np_pctldev)) { | |
c05127c4 | 135 | dev_info(p->dev, "could not find pctldev for node %s, deferring probe\n", |
57291ce2 SW |
136 | np_config->full_name); |
137 | of_node_put(np_pctldev); | |
c05127c4 LW |
138 | /* OK let's just assume this will appear later then */ |
139 | return -EPROBE_DEFER; | |
57291ce2 SW |
140 | } |
141 | pctldev = find_pinctrl_by_of_node(np_pctldev); | |
142 | if (pctldev) | |
143 | break; | |
b2083062 LW |
144 | /* Do not defer probing of hogs (circular loop) */ |
145 | if (np_pctldev == p->dev->of_node) { | |
146 | of_node_put(np_pctldev); | |
147 | return -ENODEV; | |
148 | } | |
57291ce2 SW |
149 | } |
150 | of_node_put(np_pctldev); | |
151 | ||
152 | /* | |
153 | * Call pinctrl driver to parse device tree node, and | |
154 | * generate mapping table entries | |
155 | */ | |
156 | ops = pctldev->desc->pctlops; | |
157 | if (!ops->dt_node_to_map) { | |
158 | dev_err(p->dev, "pctldev %s doesn't support DT\n", | |
159 | dev_name(pctldev->dev)); | |
160 | return -ENODEV; | |
161 | } | |
162 | ret = ops->dt_node_to_map(pctldev, np_config, &map, &num_maps); | |
163 | if (ret < 0) | |
164 | return ret; | |
165 | ||
166 | /* Stash the mapping table chunk away for later use */ | |
167 | return dt_remember_or_free_map(p, statename, pctldev, map, num_maps); | |
168 | } | |
169 | ||
170 | static int dt_remember_dummy_state(struct pinctrl *p, const char *statename) | |
171 | { | |
172 | struct pinctrl_map *map; | |
173 | ||
174 | map = kzalloc(sizeof(*map), GFP_KERNEL); | |
175 | if (!map) { | |
176 | dev_err(p->dev, "failed to alloc struct pinctrl_map\n"); | |
177 | return -ENOMEM; | |
178 | } | |
179 | ||
180 | /* There is no pctldev for PIN_MAP_TYPE_DUMMY_STATE */ | |
181 | map->type = PIN_MAP_TYPE_DUMMY_STATE; | |
182 | ||
183 | return dt_remember_or_free_map(p, statename, NULL, map, 1); | |
184 | } | |
185 | ||
186 | int pinctrl_dt_to_map(struct pinctrl *p) | |
187 | { | |
188 | struct device_node *np = p->dev->of_node; | |
189 | int state, ret; | |
190 | char *propname; | |
191 | struct property *prop; | |
192 | const char *statename; | |
193 | const __be32 *list; | |
194 | int size, config; | |
195 | phandle phandle; | |
196 | struct device_node *np_config; | |
197 | ||
198 | /* CONFIG_OF enabled, p->dev not instantiated from DT */ | |
199 | if (!np) { | |
200 | dev_dbg(p->dev, "no of_node; not parsing pinctrl DT\n"); | |
201 | return 0; | |
202 | } | |
203 | ||
204 | /* We may store pointers to property names within the node */ | |
205 | of_node_get(np); | |
206 | ||
207 | /* For each defined state ID */ | |
208 | for (state = 0; ; state++) { | |
209 | /* Retrieve the pinctrl-* property */ | |
210 | propname = kasprintf(GFP_KERNEL, "pinctrl-%d", state); | |
211 | prop = of_find_property(np, propname, &size); | |
212 | kfree(propname); | |
213 | if (!prop) | |
214 | break; | |
215 | list = prop->value; | |
216 | size /= sizeof(*list); | |
217 | ||
218 | /* Determine whether pinctrl-names property names the state */ | |
219 | ret = of_property_read_string_index(np, "pinctrl-names", | |
220 | state, &statename); | |
221 | /* | |
222 | * If not, statename is just the integer state ID. But rather | |
223 | * than dynamically allocate it and have to free it later, | |
224 | * just point part way into the property name for the string. | |
225 | */ | |
226 | if (ret < 0) { | |
227 | /* strlen("pinctrl-") == 8 */ | |
228 | statename = prop->name + 8; | |
229 | } | |
230 | ||
231 | /* For every referenced pin configuration node in it */ | |
232 | for (config = 0; config < size; config++) { | |
233 | phandle = be32_to_cpup(list++); | |
234 | ||
235 | /* Look up the pin configuration node */ | |
236 | np_config = of_find_node_by_phandle(phandle); | |
237 | if (!np_config) { | |
238 | dev_err(p->dev, | |
239 | "prop %s index %i invalid phandle\n", | |
240 | prop->name, config); | |
241 | ret = -EINVAL; | |
242 | goto err; | |
243 | } | |
244 | ||
245 | /* Parse the node */ | |
246 | ret = dt_to_map_one_config(p, statename, np_config); | |
247 | of_node_put(np_config); | |
248 | if (ret < 0) | |
249 | goto err; | |
250 | } | |
251 | ||
252 | /* No entries in DT? Generate a dummy state table entry */ | |
253 | if (!size) { | |
254 | ret = dt_remember_dummy_state(p, statename); | |
255 | if (ret < 0) | |
256 | goto err; | |
257 | } | |
258 | } | |
259 | ||
260 | return 0; | |
261 | ||
262 | err: | |
263 | pinctrl_dt_free_maps(p); | |
264 | return ret; | |
265 | } |