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