Commit | Line | Data |
---|---|---|
7941b27b PA |
1 | /* |
2 | * Functions for dealing with DT resolution | |
3 | * | |
4 | * Copyright (C) 2012 Pantelis Antoniou <panto@antoniou-consulting.com> | |
5 | * Copyright (C) 2012 Texas Instruments Inc. | |
6 | * | |
7 | * This program is free software; you can redistribute it and/or | |
8 | * modify it under the terms of the GNU General Public License | |
9 | * version 2 as published by the Free Software Foundation. | |
10 | */ | |
11 | ||
12 | #include <linux/kernel.h> | |
13 | #include <linux/module.h> | |
14 | #include <linux/of.h> | |
15 | #include <linux/of_device.h> | |
16 | #include <linux/string.h> | |
17 | #include <linux/ctype.h> | |
18 | #include <linux/errno.h> | |
19 | #include <linux/string.h> | |
20 | #include <linux/slab.h> | |
21 | ||
22 | /* illegal phandle value (set when unresolved) */ | |
23 | #define OF_PHANDLE_ILLEGAL 0xdeadbeef | |
24 | ||
25 | /** | |
26 | * Find a node with the give full name by recursively following any of | |
27 | * the child node links. | |
28 | */ | |
29 | static struct device_node *__of_find_node_by_full_name(struct device_node *node, | |
30 | const char *full_name) | |
31 | { | |
32 | struct device_node *child, *found; | |
33 | ||
34 | if (node == NULL) | |
35 | return NULL; | |
36 | ||
37 | /* check */ | |
38 | if (of_node_cmp(node->full_name, full_name) == 0) | |
82f68756 | 39 | return of_node_get(node); |
7941b27b PA |
40 | |
41 | for_each_child_of_node(node, child) { | |
42 | found = __of_find_node_by_full_name(child, full_name); | |
82f68756 AKC |
43 | if (found != NULL) { |
44 | of_node_put(child); | |
7941b27b | 45 | return found; |
82f68756 | 46 | } |
7941b27b PA |
47 | } |
48 | ||
49 | return NULL; | |
50 | } | |
51 | ||
52 | /* | |
53 | * Find live tree's maximum phandle value. | |
54 | */ | |
55 | static phandle of_get_tree_max_phandle(void) | |
56 | { | |
57 | struct device_node *node; | |
58 | phandle phandle; | |
59 | unsigned long flags; | |
60 | ||
61 | /* now search recursively */ | |
62 | raw_spin_lock_irqsave(&devtree_lock, flags); | |
63 | phandle = 0; | |
64 | for_each_of_allnodes(node) { | |
65 | if (node->phandle != OF_PHANDLE_ILLEGAL && | |
66 | node->phandle > phandle) | |
67 | phandle = node->phandle; | |
68 | } | |
69 | raw_spin_unlock_irqrestore(&devtree_lock, flags); | |
70 | ||
71 | return phandle; | |
72 | } | |
73 | ||
74 | /* | |
75 | * Adjust a subtree's phandle values by a given delta. | |
76 | * Makes sure not to just adjust the device node's phandle value, | |
77 | * but modify the phandle properties values as well. | |
78 | */ | |
79 | static void __of_adjust_tree_phandles(struct device_node *node, | |
80 | int phandle_delta) | |
81 | { | |
82 | struct device_node *child; | |
83 | struct property *prop; | |
84 | phandle phandle; | |
85 | ||
86 | /* first adjust the node's phandle direct value */ | |
87 | if (node->phandle != 0 && node->phandle != OF_PHANDLE_ILLEGAL) | |
88 | node->phandle += phandle_delta; | |
89 | ||
90 | /* now adjust phandle & linux,phandle values */ | |
91 | for_each_property_of_node(node, prop) { | |
92 | ||
93 | /* only look for these two */ | |
94 | if (of_prop_cmp(prop->name, "phandle") != 0 && | |
95 | of_prop_cmp(prop->name, "linux,phandle") != 0) | |
96 | continue; | |
97 | ||
98 | /* must be big enough */ | |
99 | if (prop->length < 4) | |
100 | continue; | |
101 | ||
102 | /* read phandle value */ | |
103 | phandle = be32_to_cpup(prop->value); | |
104 | if (phandle == OF_PHANDLE_ILLEGAL) /* unresolved */ | |
105 | continue; | |
106 | ||
107 | /* adjust */ | |
108 | *(uint32_t *)prop->value = cpu_to_be32(node->phandle); | |
109 | } | |
110 | ||
111 | /* now do the children recursively */ | |
112 | for_each_child_of_node(node, child) | |
113 | __of_adjust_tree_phandles(child, phandle_delta); | |
114 | } | |
115 | ||
da56d04c PA |
116 | static int __of_adjust_phandle_ref(struct device_node *node, |
117 | struct property *rprop, int value) | |
7941b27b PA |
118 | { |
119 | phandle phandle; | |
120 | struct device_node *refnode; | |
121 | struct property *sprop; | |
122 | char *propval, *propcur, *propend, *nodestr, *propstr, *s; | |
123 | int offset, propcurlen; | |
124 | int err = 0; | |
125 | ||
126 | /* make a copy */ | |
127 | propval = kmalloc(rprop->length, GFP_KERNEL); | |
128 | if (!propval) { | |
129 | pr_err("%s: Could not copy value of '%s'\n", | |
130 | __func__, rprop->name); | |
131 | return -ENOMEM; | |
132 | } | |
133 | memcpy(propval, rprop->value, rprop->length); | |
134 | ||
135 | propend = propval + rprop->length; | |
136 | for (propcur = propval; propcur < propend; propcur += propcurlen + 1) { | |
137 | propcurlen = strlen(propcur); | |
138 | ||
139 | nodestr = propcur; | |
140 | s = strchr(propcur, ':'); | |
141 | if (!s) { | |
142 | pr_err("%s: Illegal symbol entry '%s' (1)\n", | |
143 | __func__, propcur); | |
144 | err = -EINVAL; | |
145 | goto err_fail; | |
146 | } | |
147 | *s++ = '\0'; | |
148 | ||
149 | propstr = s; | |
150 | s = strchr(s, ':'); | |
151 | if (!s) { | |
152 | pr_err("%s: Illegal symbol entry '%s' (2)\n", | |
153 | __func__, (char *)rprop->value); | |
154 | err = -EINVAL; | |
155 | goto err_fail; | |
156 | } | |
157 | ||
158 | *s++ = '\0'; | |
159 | err = kstrtoint(s, 10, &offset); | |
160 | if (err != 0) { | |
161 | pr_err("%s: Could get offset '%s'\n", | |
162 | __func__, (char *)rprop->value); | |
163 | goto err_fail; | |
164 | } | |
165 | ||
166 | /* look into the resolve node for the full path */ | |
167 | refnode = __of_find_node_by_full_name(node, nodestr); | |
168 | if (!refnode) { | |
169 | pr_warn("%s: Could not find refnode '%s'\n", | |
170 | __func__, (char *)rprop->value); | |
171 | continue; | |
172 | } | |
173 | ||
174 | /* now find the property */ | |
175 | for_each_property_of_node(refnode, sprop) { | |
176 | if (of_prop_cmp(sprop->name, propstr) == 0) | |
177 | break; | |
178 | } | |
82f68756 | 179 | of_node_put(refnode); |
7941b27b PA |
180 | |
181 | if (!sprop) { | |
182 | pr_err("%s: Could not find property '%s'\n", | |
183 | __func__, (char *)rprop->value); | |
184 | err = -ENOENT; | |
185 | goto err_fail; | |
186 | } | |
187 | ||
da56d04c | 188 | phandle = value; |
7941b27b PA |
189 | *(__be32 *)(sprop->value + offset) = cpu_to_be32(phandle); |
190 | } | |
191 | ||
192 | err_fail: | |
193 | kfree(propval); | |
194 | return err; | |
195 | } | |
196 | ||
da56d04c PA |
197 | /* compare nodes taking into account that 'name' strips out the @ part */ |
198 | static int __of_node_name_cmp(const struct device_node *dn1, | |
199 | const struct device_node *dn2) | |
200 | { | |
201 | const char *n1 = strrchr(dn1->full_name, '/') ? : "/"; | |
202 | const char *n2 = strrchr(dn2->full_name, '/') ? : "/"; | |
203 | ||
204 | return of_node_cmp(n1, n2); | |
205 | } | |
206 | ||
7941b27b PA |
207 | /* |
208 | * Adjust the local phandle references by the given phandle delta. | |
da56d04c PA |
209 | * Assumes the existances of a __local_fixups__ node at the root. |
210 | * Assumes that __of_verify_tree_phandle_references has been called. | |
211 | * Does not take any devtree locks so make sure you call this on a tree | |
212 | * which is at the detached state. | |
7941b27b PA |
213 | */ |
214 | static int __of_adjust_tree_phandle_references(struct device_node *node, | |
da56d04c | 215 | struct device_node *target, int phandle_delta) |
7941b27b | 216 | { |
da56d04c PA |
217 | struct device_node *child, *childtarget; |
218 | struct property *rprop, *sprop; | |
219 | int err, i, count; | |
220 | unsigned int off; | |
221 | phandle phandle; | |
7941b27b | 222 | |
da56d04c | 223 | if (node == NULL) |
7941b27b PA |
224 | return 0; |
225 | ||
da56d04c PA |
226 | for_each_property_of_node(node, rprop) { |
227 | ||
7941b27b | 228 | /* skip properties added automatically */ |
da56d04c PA |
229 | if (of_prop_cmp(rprop->name, "name") == 0 || |
230 | of_prop_cmp(rprop->name, "phandle") == 0 || | |
231 | of_prop_cmp(rprop->name, "linux,phandle") == 0) | |
7941b27b PA |
232 | continue; |
233 | ||
da56d04c PA |
234 | if ((rprop->length % 4) != 0 || rprop->length == 0) { |
235 | pr_err("%s: Illegal property (size) '%s' @%s\n", | |
236 | __func__, rprop->name, node->full_name); | |
237 | return -EINVAL; | |
238 | } | |
239 | count = rprop->length / sizeof(__be32); | |
240 | ||
241 | /* now find the target property */ | |
242 | for_each_property_of_node(target, sprop) { | |
243 | if (of_prop_cmp(sprop->name, rprop->name) == 0) | |
244 | break; | |
245 | } | |
246 | ||
247 | if (sprop == NULL) { | |
248 | pr_err("%s: Could not find target property '%s' @%s\n", | |
249 | __func__, rprop->name, node->full_name); | |
250 | return -EINVAL; | |
251 | } | |
252 | ||
253 | for (i = 0; i < count; i++) { | |
254 | off = be32_to_cpu(((__be32 *)rprop->value)[i]); | |
255 | /* make sure the offset doesn't overstep (even wrap) */ | |
256 | if (off >= sprop->length || | |
257 | (off + 4) > sprop->length) { | |
258 | pr_err("%s: Illegal property '%s' @%s\n", | |
259 | __func__, rprop->name, | |
260 | node->full_name); | |
261 | return -EINVAL; | |
262 | } | |
263 | ||
264 | if (phandle_delta) { | |
265 | /* adjust */ | |
266 | phandle = be32_to_cpu(*(__be32 *)(sprop->value + off)); | |
267 | phandle += phandle_delta; | |
268 | *(__be32 *)(sprop->value + off) = cpu_to_be32(phandle); | |
269 | } | |
270 | } | |
271 | } | |
272 | ||
273 | for_each_child_of_node(node, child) { | |
274 | ||
275 | for_each_child_of_node(target, childtarget) | |
276 | if (__of_node_name_cmp(child, childtarget) == 0) | |
277 | break; | |
278 | ||
279 | if (!childtarget) { | |
280 | pr_err("%s: Could not find target child '%s' @%s\n", | |
281 | __func__, child->name, node->full_name); | |
282 | return -EINVAL; | |
283 | } | |
284 | ||
285 | err = __of_adjust_tree_phandle_references(child, childtarget, | |
286 | phandle_delta); | |
287 | if (err != 0) | |
7941b27b PA |
288 | return err; |
289 | } | |
290 | ||
291 | return 0; | |
292 | } | |
293 | ||
294 | /** | |
295 | * of_resolve - Resolve the given node against the live tree. | |
296 | * | |
297 | * @resolve: Node to resolve | |
298 | * | |
299 | * Perform dynamic Device Tree resolution against the live tree | |
300 | * to the given node to resolve. This depends on the live tree | |
301 | * having a __symbols__ node, and the resolve node the __fixups__ & | |
302 | * __local_fixups__ nodes (if needed). | |
303 | * The result of the operation is a resolve node that it's contents | |
304 | * are fit to be inserted or operate upon the live tree. | |
305 | * Returns 0 on success or a negative error value on error. | |
306 | */ | |
307 | int of_resolve_phandles(struct device_node *resolve) | |
308 | { | |
da56d04c | 309 | struct device_node *child, *childroot, *refnode; |
7941b27b PA |
310 | struct device_node *root_sym, *resolve_sym, *resolve_fix; |
311 | struct property *rprop; | |
312 | const char *refpath; | |
313 | phandle phandle, phandle_delta; | |
314 | int err; | |
315 | ||
316 | /* the resolve node must exist, and be detached */ | |
317 | if (!resolve || !of_node_check_flag(resolve, OF_DETACHED)) | |
318 | return -EINVAL; | |
319 | ||
320 | /* first we need to adjust the phandles */ | |
321 | phandle_delta = of_get_tree_max_phandle() + 1; | |
322 | __of_adjust_tree_phandles(resolve, phandle_delta); | |
da56d04c PA |
323 | |
324 | /* locate the local fixups */ | |
325 | childroot = NULL; | |
326 | for_each_child_of_node(resolve, childroot) | |
327 | if (of_node_cmp(childroot->name, "__local_fixups__") == 0) | |
328 | break; | |
329 | ||
330 | if (childroot != NULL) { | |
331 | /* resolve root is guaranteed to be the '/' */ | |
332 | err = __of_adjust_tree_phandle_references(childroot, | |
333 | resolve, 0); | |
334 | if (err != 0) | |
335 | return err; | |
336 | ||
337 | BUG_ON(__of_adjust_tree_phandle_references(childroot, | |
338 | resolve, phandle_delta)); | |
339 | } | |
7941b27b PA |
340 | |
341 | root_sym = NULL; | |
342 | resolve_sym = NULL; | |
343 | resolve_fix = NULL; | |
344 | ||
345 | /* this may fail (if no fixups are required) */ | |
346 | root_sym = of_find_node_by_path("/__symbols__"); | |
347 | ||
348 | /* locate the symbols & fixups nodes on resolve */ | |
349 | for_each_child_of_node(resolve, child) { | |
350 | ||
351 | if (!resolve_sym && | |
352 | of_node_cmp(child->name, "__symbols__") == 0) | |
353 | resolve_sym = child; | |
354 | ||
355 | if (!resolve_fix && | |
356 | of_node_cmp(child->name, "__fixups__") == 0) | |
357 | resolve_fix = child; | |
358 | ||
359 | /* both found, don't bother anymore */ | |
360 | if (resolve_sym && resolve_fix) | |
361 | break; | |
362 | } | |
363 | ||
364 | /* we do allow for the case where no fixups are needed */ | |
365 | if (!resolve_fix) { | |
366 | err = 0; /* no error */ | |
367 | goto out; | |
368 | } | |
369 | ||
370 | /* we need to fixup, but no root symbols... */ | |
371 | if (!root_sym) { | |
372 | err = -EINVAL; | |
373 | goto out; | |
374 | } | |
375 | ||
376 | for_each_property_of_node(resolve_fix, rprop) { | |
377 | ||
378 | /* skip properties added automatically */ | |
379 | if (of_prop_cmp(rprop->name, "name") == 0) | |
380 | continue; | |
381 | ||
382 | err = of_property_read_string(root_sym, | |
383 | rprop->name, &refpath); | |
384 | if (err != 0) { | |
385 | pr_err("%s: Could not find symbol '%s'\n", | |
386 | __func__, rprop->name); | |
387 | goto out; | |
388 | } | |
389 | ||
390 | refnode = of_find_node_by_path(refpath); | |
391 | if (!refnode) { | |
392 | pr_err("%s: Could not find node by path '%s'\n", | |
393 | __func__, refpath); | |
394 | err = -ENOENT; | |
395 | goto out; | |
396 | } | |
397 | ||
398 | phandle = refnode->phandle; | |
399 | of_node_put(refnode); | |
400 | ||
401 | pr_debug("%s: %s phandle is 0x%08x\n", | |
402 | __func__, rprop->name, phandle); | |
403 | ||
da56d04c | 404 | err = __of_adjust_phandle_ref(resolve, rprop, phandle); |
7941b27b PA |
405 | if (err) |
406 | break; | |
407 | } | |
408 | ||
409 | out: | |
410 | /* NULL is handled by of_node_put as NOP */ | |
411 | of_node_put(root_sym); | |
412 | ||
413 | return err; | |
414 | } | |
415 | EXPORT_SYMBOL_GPL(of_resolve_phandles); |