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