1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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
29
30
31
32
33struct pinctrl_dt_map {
34 struct list_head node;
35 struct pinctrl_dev *pctldev;
36 struct pinctrl_map *map;
37 unsigned num_maps;
38};
39
40static 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 if (ops->dt_free_map)
46 ops->dt_free_map(pctldev, map, num_maps);
47 } else {
48
49 kfree(map);
50 }
51}
52
53void pinctrl_dt_free_maps(struct pinctrl *p)
54{
55 struct pinctrl_dt_map *dt_map, *n1;
56
57 list_for_each_entry_safe(dt_map, n1, &p->dt_maps, node) {
58 pinctrl_unregister_map(dt_map->map);
59 list_del(&dt_map->node);
60 dt_free_map(dt_map->pctldev, dt_map->map,
61 dt_map->num_maps);
62 kfree(dt_map);
63 }
64
65 of_node_put(p->dev->of_node);
66}
67
68static int dt_remember_or_free_map(struct pinctrl *p, const char *statename,
69 struct pinctrl_dev *pctldev,
70 struct pinctrl_map *map, unsigned num_maps)
71{
72 int i;
73 struct pinctrl_dt_map *dt_map;
74
75
76 for (i = 0; i < num_maps; i++) {
77 map[i].dev_name = dev_name(p->dev);
78 map[i].name = statename;
79 if (pctldev)
80 map[i].ctrl_dev_name = dev_name(pctldev->dev);
81 }
82
83
84 dt_map = kzalloc(sizeof(*dt_map), GFP_KERNEL);
85 if (!dt_map) {
86 dev_err(p->dev, "failed to alloc struct pinctrl_dt_map\n");
87 dt_free_map(pctldev, map, num_maps);
88 return -ENOMEM;
89 }
90
91 dt_map->pctldev = pctldev;
92 dt_map->map = map;
93 dt_map->num_maps = num_maps;
94 list_add_tail(&dt_map->node, &p->dt_maps);
95
96 return pinctrl_register_map(map, num_maps, false);
97}
98
99struct pinctrl_dev *of_pinctrl_get(struct device_node *np)
100{
101 return get_pinctrl_dev_from_of_node(np);
102}
103
104static int dt_to_map_one_config(struct pinctrl *p,
105 struct pinctrl_dev *pctldev,
106 const char *statename,
107 struct device_node *np_config)
108{
109 struct device_node *np_pctldev;
110 const struct pinctrl_ops *ops;
111 int ret;
112 struct pinctrl_map *map;
113 unsigned num_maps;
114
115
116 np_pctldev = of_node_get(np_config);
117 for (;;) {
118 np_pctldev = of_get_next_parent(np_pctldev);
119 if (!np_pctldev || of_node_is_root(np_pctldev)) {
120 dev_info(p->dev, "could not find pctldev for node %s, deferring probe\n",
121 np_config->full_name);
122 of_node_put(np_pctldev);
123
124 return -EPROBE_DEFER;
125 }
126 if (!pctldev)
127 pctldev = get_pinctrl_dev_from_of_node(np_pctldev);
128 if (pctldev)
129 break;
130
131 if (np_pctldev == p->dev->of_node) {
132 of_node_put(np_pctldev);
133 return -ENODEV;
134 }
135 }
136 of_node_put(np_pctldev);
137
138
139
140
141
142 ops = pctldev->desc->pctlops;
143 if (!ops->dt_node_to_map) {
144 dev_err(p->dev, "pctldev %s doesn't support DT\n",
145 dev_name(pctldev->dev));
146 return -ENODEV;
147 }
148 ret = ops->dt_node_to_map(pctldev, np_config, &map, &num_maps);
149 if (ret < 0)
150 return ret;
151
152
153 return dt_remember_or_free_map(p, statename, pctldev, map, num_maps);
154}
155
156static int dt_remember_dummy_state(struct pinctrl *p, const char *statename)
157{
158 struct pinctrl_map *map;
159
160 map = kzalloc(sizeof(*map), GFP_KERNEL);
161 if (!map) {
162 dev_err(p->dev, "failed to alloc struct pinctrl_map\n");
163 return -ENOMEM;
164 }
165
166
167 map->type = PIN_MAP_TYPE_DUMMY_STATE;
168
169 return dt_remember_or_free_map(p, statename, NULL, map, 1);
170}
171
172bool pinctrl_dt_has_hogs(struct pinctrl_dev *pctldev)
173{
174 struct device_node *np;
175 struct property *prop;
176 int size;
177
178 np = pctldev->dev->of_node;
179 if (!np)
180 return false;
181
182 prop = of_find_property(np, "pinctrl-0", &size);
183
184 return prop ? true : false;
185}
186
187int pinctrl_dt_to_map(struct pinctrl *p, struct pinctrl_dev *pctldev)
188{
189 struct device_node *np = p->dev->of_node;
190 int state, ret;
191 char *propname;
192 struct property *prop;
193 const char *statename;
194 const __be32 *list;
195 int size, config;
196 phandle phandle;
197 struct device_node *np_config;
198
199
200 if (!np) {
201 if (of_have_populated_dt())
202 dev_dbg(p->dev,
203 "no of_node; not parsing pinctrl DT\n");
204 return 0;
205 }
206
207
208 of_node_get(np);
209
210
211 for (state = 0; ; state++) {
212
213 propname = kasprintf(GFP_KERNEL, "pinctrl-%d", state);
214 prop = of_find_property(np, propname, &size);
215 kfree(propname);
216 if (!prop) {
217 if (state == 0) {
218 of_node_put(np);
219 return -ENODEV;
220 }
221 break;
222 }
223 list = prop->value;
224 size /= sizeof(*list);
225
226
227 ret = of_property_read_string_index(np, "pinctrl-names",
228 state, &statename);
229
230
231
232
233
234 if (ret < 0) {
235
236 statename = prop->name + 8;
237 }
238
239
240 for (config = 0; config < size; config++) {
241 phandle = be32_to_cpup(list++);
242
243
244 np_config = of_find_node_by_phandle(phandle);
245 if (!np_config) {
246 dev_err(p->dev,
247 "prop %s index %i invalid phandle\n",
248 prop->name, config);
249 ret = -EINVAL;
250 goto err;
251 }
252
253
254 ret = dt_to_map_one_config(p, pctldev, statename,
255 np_config);
256 of_node_put(np_config);
257 if (ret < 0)
258 goto err;
259 }
260
261
262 if (!size) {
263 ret = dt_remember_dummy_state(p, statename);
264 if (ret < 0)
265 goto err;
266 }
267 }
268
269 return 0;
270
271err:
272 pinctrl_dt_free_maps(p);
273 return ret;
274}
275
276
277
278
279
280static int pinctrl_find_cells_size(const struct device_node *np)
281{
282 const char *cells_name = "#pinctrl-cells";
283 int cells_size, error;
284
285 error = of_property_read_u32(np->parent, cells_name, &cells_size);
286 if (error) {
287 error = of_property_read_u32(np->parent->parent,
288 cells_name, &cells_size);
289 if (error)
290 return -ENOENT;
291 }
292
293 return cells_size;
294}
295
296
297
298
299
300
301
302
303
304
305
306static int pinctrl_get_list_and_count(const struct device_node *np,
307 const char *list_name,
308 const __be32 **list,
309 int *cells_size,
310 int *nr_elements)
311{
312 int size;
313
314 *cells_size = 0;
315 *nr_elements = 0;
316
317 *list = of_get_property(np, list_name, &size);
318 if (!*list)
319 return -ENOENT;
320
321 *cells_size = pinctrl_find_cells_size(np);
322 if (*cells_size < 0)
323 return -ENOENT;
324
325
326 *nr_elements = (size / sizeof(**list)) / (*cells_size + 1);
327
328 return 0;
329}
330
331
332
333
334
335
336
337
338
339
340int pinctrl_count_index_with_args(const struct device_node *np,
341 const char *list_name)
342{
343 const __be32 *list;
344 int size, nr_cells, error;
345
346 error = pinctrl_get_list_and_count(np, list_name, &list,
347 &nr_cells, &size);
348 if (error)
349 return error;
350
351 return size;
352}
353EXPORT_SYMBOL_GPL(pinctrl_count_index_with_args);
354
355
356
357
358
359
360
361
362
363
364
365
366static int pinctrl_copy_args(const struct device_node *np,
367 const __be32 *list,
368 int index, int nr_cells, int nr_elem,
369 struct of_phandle_args *out_args)
370{
371 int i;
372
373 memset(out_args, 0, sizeof(*out_args));
374 out_args->np = (struct device_node *)np;
375 out_args->args_count = nr_cells + 1;
376
377 if (index >= nr_elem)
378 return -EINVAL;
379
380 list += index * (nr_cells + 1);
381
382 for (i = 0; i < nr_cells + 1; i++)
383 out_args->args[i] = be32_to_cpup(list++);
384
385 return 0;
386}
387
388
389
390
391
392
393
394
395
396
397
398
399int pinctrl_parse_index_with_args(const struct device_node *np,
400 const char *list_name, int index,
401 struct of_phandle_args *out_args)
402{
403 const __be32 *list;
404 int nr_elem, nr_cells, error;
405
406 error = pinctrl_get_list_and_count(np, list_name, &list,
407 &nr_cells, &nr_elem);
408 if (error || !nr_cells)
409 return error;
410
411 error = pinctrl_copy_args(np, list, index, nr_cells, nr_elem,
412 out_args);
413 if (error)
414 return error;
415
416 return 0;
417}
418EXPORT_SYMBOL_GPL(pinctrl_parse_index_with_args);
419