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