Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * Functions for dealing with DT resolution
4 : : *
5 : : * Copyright (C) 2012 Pantelis Antoniou <panto@antoniou-consulting.com>
6 : : * Copyright (C) 2012 Texas Instruments Inc.
7 : : */
8 : :
9 : : #define pr_fmt(fmt) "OF: resolver: " fmt
10 : :
11 : : #include <linux/kernel.h>
12 : : #include <linux/module.h>
13 : : #include <linux/of.h>
14 : : #include <linux/of_device.h>
15 : : #include <linux/string.h>
16 : : #include <linux/ctype.h>
17 : : #include <linux/errno.h>
18 : : #include <linux/slab.h>
19 : :
20 : : #include "of_private.h"
21 : :
22 : 0 : static phandle live_tree_max_phandle(void)
23 : : {
24 : : struct device_node *node;
25 : : phandle phandle;
26 : : unsigned long flags;
27 : :
28 : 0 : raw_spin_lock_irqsave(&devtree_lock, flags);
29 : : phandle = 0;
30 [ # # ]: 0 : for_each_of_allnodes(node) {
31 [ # # # # ]: 0 : if (node->phandle != OF_PHANDLE_ILLEGAL &&
32 : : node->phandle > phandle)
33 : : phandle = node->phandle;
34 : : }
35 : 0 : raw_spin_unlock_irqrestore(&devtree_lock, flags);
36 : :
37 : 0 : return phandle;
38 : : }
39 : :
40 : 0 : static void adjust_overlay_phandles(struct device_node *overlay,
41 : : int phandle_delta)
42 : : {
43 : : struct device_node *child;
44 : : struct property *prop;
45 : : phandle phandle;
46 : :
47 : : /* adjust node's phandle in node */
48 [ # # ]: 0 : if (overlay->phandle != 0 && overlay->phandle != OF_PHANDLE_ILLEGAL)
49 : 0 : overlay->phandle += phandle_delta;
50 : :
51 : : /* copy adjusted phandle into *phandle properties */
52 [ # # ]: 0 : for_each_property_of_node(overlay, prop) {
53 : :
54 [ # # # # ]: 0 : if (of_prop_cmp(prop->name, "phandle") &&
55 : 0 : of_prop_cmp(prop->name, "linux,phandle"))
56 : 0 : continue;
57 : :
58 [ # # ]: 0 : if (prop->length < 4)
59 : 0 : continue;
60 : :
61 : 0 : phandle = be32_to_cpup(prop->value);
62 [ # # ]: 0 : if (phandle == OF_PHANDLE_ILLEGAL)
63 : 0 : continue;
64 : :
65 : 0 : *(__be32 *)prop->value = cpu_to_be32(overlay->phandle);
66 : : }
67 : :
68 [ # # ]: 0 : for_each_child_of_node(overlay, child)
69 : 0 : adjust_overlay_phandles(child, phandle_delta);
70 : 0 : }
71 : :
72 : 0 : static int update_usages_of_a_phandle_reference(struct device_node *overlay,
73 : : struct property *prop_fixup, phandle phandle)
74 : : {
75 : : struct device_node *refnode;
76 : : struct property *prop;
77 : : char *value, *cur, *end, *node_path, *prop_name, *s;
78 : : int offset, len;
79 : : int err = 0;
80 : :
81 : 0 : value = kmemdup(prop_fixup->value, prop_fixup->length, GFP_KERNEL);
82 [ # # ]: 0 : if (!value)
83 : : return -ENOMEM;
84 : :
85 : : /* prop_fixup contains a list of tuples of path:property_name:offset */
86 : 0 : end = value + prop_fixup->length;
87 [ # # ]: 0 : for (cur = value; cur < end; cur += len + 1) {
88 : 0 : len = strlen(cur);
89 : :
90 : : node_path = cur;
91 : 0 : s = strchr(cur, ':');
92 [ # # ]: 0 : if (!s) {
93 : : err = -EINVAL;
94 : : goto err_fail;
95 : : }
96 : 0 : *s++ = '\0';
97 : :
98 : : prop_name = s;
99 : 0 : s = strchr(s, ':');
100 [ # # ]: 0 : if (!s) {
101 : : err = -EINVAL;
102 : : goto err_fail;
103 : : }
104 : 0 : *s++ = '\0';
105 : :
106 : 0 : err = kstrtoint(s, 10, &offset);
107 [ # # ]: 0 : if (err)
108 : : goto err_fail;
109 : :
110 : 0 : refnode = __of_find_node_by_full_path(of_node_get(overlay), node_path);
111 [ # # ]: 0 : if (!refnode)
112 : 0 : continue;
113 : :
114 [ # # ]: 0 : for_each_property_of_node(refnode, prop) {
115 [ # # ]: 0 : if (!of_prop_cmp(prop->name, prop_name))
116 : : break;
117 : : }
118 : 0 : of_node_put(refnode);
119 : :
120 [ # # ]: 0 : if (!prop) {
121 : : err = -ENOENT;
122 : : goto err_fail;
123 : : }
124 : :
125 [ # # # # ]: 0 : if (offset < 0 || offset + sizeof(__be32) > prop->length) {
126 : : err = -EINVAL;
127 : : goto err_fail;
128 : : }
129 : :
130 : 0 : *(__be32 *)(prop->value + offset) = cpu_to_be32(phandle);
131 : : }
132 : :
133 : : err_fail:
134 : 0 : kfree(value);
135 : 0 : return err;
136 : : }
137 : :
138 : : /* compare nodes taking into account that 'name' strips out the @ part */
139 : 0 : static int node_name_cmp(const struct device_node *dn1,
140 : : const struct device_node *dn2)
141 : : {
142 : 0 : const char *n1 = kbasename(dn1->full_name);
143 : 0 : const char *n2 = kbasename(dn2->full_name);
144 : :
145 : 0 : return of_node_cmp(n1, n2);
146 : : }
147 : :
148 : : /*
149 : : * Adjust the local phandle references by the given phandle delta.
150 : : *
151 : : * Subtree @local_fixups, which is overlay node __local_fixups__,
152 : : * mirrors the fragment node structure at the root of the overlay.
153 : : *
154 : : * For each property in the fragments that contains a phandle reference,
155 : : * @local_fixups has a property of the same name that contains a list
156 : : * of offsets of the phandle reference(s) within the respective property
157 : : * value(s). The values at these offsets will be fixed up.
158 : : */
159 : 0 : static int adjust_local_phandle_references(struct device_node *local_fixups,
160 : : struct device_node *overlay, int phandle_delta)
161 : : {
162 : : struct device_node *child, *overlay_child;
163 : : struct property *prop_fix, *prop;
164 : : int err, i, count;
165 : : unsigned int off;
166 : :
167 [ # # ]: 0 : if (!local_fixups)
168 : : return 0;
169 : :
170 [ # # ]: 0 : for_each_property_of_node(local_fixups, prop_fix) {
171 : :
172 : : /* skip properties added automatically */
173 [ # # # # ]: 0 : if (!of_prop_cmp(prop_fix->name, "name") ||
174 [ # # ]: 0 : !of_prop_cmp(prop_fix->name, "phandle") ||
175 : 0 : !of_prop_cmp(prop_fix->name, "linux,phandle"))
176 : 0 : continue;
177 : :
178 [ # # # # ]: 0 : if ((prop_fix->length % 4) != 0 || prop_fix->length == 0)
179 : : return -EINVAL;
180 : 0 : count = prop_fix->length / sizeof(__be32);
181 : :
182 [ # # ]: 0 : for_each_property_of_node(overlay, prop) {
183 [ # # ]: 0 : if (!of_prop_cmp(prop->name, prop_fix->name))
184 : : break;
185 : : }
186 : :
187 [ # # ]: 0 : if (!prop)
188 : : return -EINVAL;
189 : :
190 [ # # ]: 0 : for (i = 0; i < count; i++) {
191 : 0 : off = be32_to_cpu(((__be32 *)prop_fix->value)[i]);
192 [ # # ]: 0 : if ((off + 4) > prop->length)
193 : : return -EINVAL;
194 : :
195 : 0 : be32_add_cpu(prop->value + off, phandle_delta);
196 : : }
197 : : }
198 : :
199 : : /*
200 : : * These nested loops recurse down two subtrees in parallel, where the
201 : : * node names in the two subtrees match.
202 : : *
203 : : * The roots of the subtrees are the overlay's __local_fixups__ node
204 : : * and the overlay's root node.
205 : : */
206 [ # # ]: 0 : for_each_child_of_node(local_fixups, child) {
207 : :
208 [ # # ]: 0 : for_each_child_of_node(overlay, overlay_child)
209 [ # # ]: 0 : if (!node_name_cmp(child, overlay_child)) {
210 : 0 : of_node_put(overlay_child);
211 : 0 : break;
212 : : }
213 : :
214 [ # # ]: 0 : if (!overlay_child) {
215 : 0 : of_node_put(child);
216 : 0 : return -EINVAL;
217 : : }
218 : :
219 : 0 : err = adjust_local_phandle_references(child, overlay_child,
220 : : phandle_delta);
221 [ # # ]: 0 : if (err) {
222 : 0 : of_node_put(child);
223 : 0 : return err;
224 : : }
225 : : }
226 : :
227 : : return 0;
228 : : }
229 : :
230 : : /**
231 : : * of_resolve_phandles - Relocate and resolve overlay against live tree
232 : : *
233 : : * @overlay: Pointer to devicetree overlay to relocate and resolve
234 : : *
235 : : * Modify (relocate) values of local phandles in @overlay to a range that
236 : : * does not conflict with the live expanded devicetree. Update references
237 : : * to the local phandles in @overlay. Update (resolve) phandle references
238 : : * in @overlay that refer to the live expanded devicetree.
239 : : *
240 : : * Phandle values in the live tree are in the range of
241 : : * 1 .. live_tree_max_phandle(). The range of phandle values in the overlay
242 : : * also begin with at 1. Adjust the phandle values in the overlay to begin
243 : : * at live_tree_max_phandle() + 1. Update references to the phandles to
244 : : * the adjusted phandle values.
245 : : *
246 : : * The name of each property in the "__fixups__" node in the overlay matches
247 : : * the name of a symbol (a label) in the live tree. The values of each
248 : : * property in the "__fixups__" node is a list of the property values in the
249 : : * overlay that need to be updated to contain the phandle reference
250 : : * corresponding to that symbol in the live tree. Update the references in
251 : : * the overlay with the phandle values in the live tree.
252 : : *
253 : : * @overlay must be detached.
254 : : *
255 : : * Resolving and applying @overlay to the live expanded devicetree must be
256 : : * protected by a mechanism to ensure that multiple overlays are processed
257 : : * in a single threaded manner so that multiple overlays will not relocate
258 : : * phandles to overlapping ranges. The mechanism to enforce this is not
259 : : * yet implemented.
260 : : *
261 : : * Return: %0 on success or a negative error value on error.
262 : : */
263 : 0 : int of_resolve_phandles(struct device_node *overlay)
264 : : {
265 : : struct device_node *child, *local_fixups, *refnode;
266 : : struct device_node *tree_symbols, *overlay_fixups;
267 : : struct property *prop;
268 : : const char *refpath;
269 : : phandle phandle, phandle_delta;
270 : : int err;
271 : :
272 : : tree_symbols = NULL;
273 : :
274 [ # # ]: 0 : if (!overlay) {
275 : 0 : pr_err("null overlay\n");
276 : : err = -EINVAL;
277 : 0 : goto out;
278 : : }
279 : :
280 [ # # ]: 0 : if (!of_node_check_flag(overlay, OF_DETACHED)) {
281 : 0 : pr_err("overlay not detached\n");
282 : : err = -EINVAL;
283 : 0 : goto out;
284 : : }
285 : :
286 : 0 : phandle_delta = live_tree_max_phandle() + 1;
287 : 0 : adjust_overlay_phandles(overlay, phandle_delta);
288 : :
289 [ # # ]: 0 : for_each_child_of_node(overlay, local_fixups)
290 [ # # ]: 0 : if (of_node_name_eq(local_fixups, "__local_fixups__"))
291 : : break;
292 : :
293 : 0 : err = adjust_local_phandle_references(local_fixups, overlay, phandle_delta);
294 [ # # ]: 0 : if (err)
295 : : goto out;
296 : :
297 : : overlay_fixups = NULL;
298 : :
299 [ # # ]: 0 : for_each_child_of_node(overlay, child) {
300 [ # # ]: 0 : if (of_node_name_eq(child, "__fixups__"))
301 : : overlay_fixups = child;
302 : : }
303 : :
304 [ # # ]: 0 : if (!overlay_fixups) {
305 : : err = 0;
306 : : goto out;
307 : : }
308 : :
309 : : tree_symbols = of_find_node_by_path("/__symbols__");
310 [ # # ]: 0 : if (!tree_symbols) {
311 : 0 : pr_err("no symbols in root of device tree.\n");
312 : : err = -EINVAL;
313 : 0 : goto out;
314 : : }
315 : :
316 [ # # ]: 0 : for_each_property_of_node(overlay_fixups, prop) {
317 : :
318 : : /* skip properties added automatically */
319 [ # # ]: 0 : if (!of_prop_cmp(prop->name, "name"))
320 : 0 : continue;
321 : :
322 : 0 : err = of_property_read_string(tree_symbols,
323 : : prop->name, &refpath);
324 [ # # ]: 0 : if (err)
325 : : goto out;
326 : :
327 : 0 : refnode = of_find_node_by_path(refpath);
328 [ # # ]: 0 : if (!refnode) {
329 : : err = -ENOENT;
330 : : goto out;
331 : : }
332 : :
333 : 0 : phandle = refnode->phandle;
334 : 0 : of_node_put(refnode);
335 : :
336 : 0 : err = update_usages_of_a_phandle_reference(overlay, prop, phandle);
337 [ # # ]: 0 : if (err)
338 : : break;
339 : : }
340 : :
341 : : out:
342 [ # # ]: 0 : if (err)
343 : 0 : pr_err("overlay phandle fixup failed: %d\n", err);
344 : 0 : of_node_put(tree_symbols);
345 : :
346 : 0 : return err;
347 : : }
348 : : EXPORT_SYMBOL_GPL(of_resolve_phandles);
|
