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