drivers/of/resolver.c

   1 /*
   2  * Functions for dealing with DT resolution
   3  *
   4  * Copyright (C) 2012 Pantelis Antoniou <[email protected]>
   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, struct property *rprop, int value, bool is_delta)
 115 {
 116         phandle phandle;
 117         struct device_node *refnode;
 118         struct property *sprop;
 119         char *propval, *propcur, *propend, *nodestr, *propstr, *s;
 120         int offset, propcurlen;
 121         int err = 0;
 122
 123         /* make a copy */
 124         propval = kmalloc(rprop->length, GFP_KERNEL);
 125         if (!propval) {
 126                 pr_err("%s: Could not copy value of '%s'\n",
 127                                 __func__, rprop->name);
 128                 return -ENOMEM;
 129         }
 130         memcpy(propval, rprop->value, rprop->length);
 131
 132         propend = propval + rprop->length;
 133         for (propcur = propval; propcur < propend; propcur += propcurlen + 1) {
 134                 propcurlen = strlen(propcur);
 135
 136                 nodestr = propcur;
 137                 s = strchr(propcur, ':');
 138                 if (!s) {
 139                         pr_err("%s: Illegal symbol entry '%s' (1)\n",
 140                                 __func__, propcur);
 141                         err = -EINVAL;
 142                         goto err_fail;
 143                 }
 144                 *s++ = '\0';
 145
 146                 propstr = s;
 147                 s = strchr(s, ':');
 148                 if (!s) {
 149                         pr_err("%s: Illegal symbol entry '%s' (2)\n",
 150                                 __func__, (char *)rprop->value);
 151                         err = -EINVAL;
 152                         goto err_fail;
 153                 }
 154
 155                 *s++ = '\0';
 156                 err = kstrtoint(s, 10, &offset);
 157                 if (err != 0) {
 158                         pr_err("%s: Could get offset '%s'\n",
 159                                 __func__, (char *)rprop->value);
 160                         goto err_fail;
 161                 }
 162
 163                 /* look into the resolve node for the full path */
 164                 refnode = __of_find_node_by_full_name(node, nodestr);
 165                 if (!refnode) {
 166                         pr_warn("%s: Could not find refnode '%s'\n",
 167                                 __func__, (char *)rprop->value);
 168                         continue;
 169                 }
 170
 171                 /* now find the property */
 172                 for_each_property_of_node(refnode, sprop) {
 173                         if (of_prop_cmp(sprop->name, propstr) == 0)
 174                                 break;
 175                 }
 176
 177                 if (!sprop) {
 178                         pr_err("%s: Could not find property '%s'\n",
 179                                 __func__, (char *)rprop->value);
 180                         err = -ENOENT;
 181                         goto err_fail;
 182                 }
 183
 184                 phandle = is_delta ? be32_to_cpup(sprop->value + offset) + value : value;
 185                 *(__be32 *)(sprop->value + offset) = cpu_to_be32(phandle);
 186         }
 187
 188 err_fail:
 189         kfree(propval);
 190         return err;
 191 }
 192
 193 /*
 194  * Adjust the local phandle references by the given phandle delta.
 195  * Assumes the existances of a __local_fixups__ node at the root
 196  * of the tree. Does not take any devtree locks so make sure you
 197  * call this on a tree which is at the detached state.
 198  */
 199 static int __of_adjust_tree_phandle_references(struct device_node *node,
 200                 int phandle_delta)
 201 {
 202         struct device_node *child;
 203         struct property *rprop;
 204         int err;
 205
 206         /* locate the symbols & fixups nodes on resolve */
 207         for_each_child_of_node(node, child)
 208                 if (of_node_cmp(child->name, "__local_fixups__") == 0)
 209                         break;
 210
 211         /* no local fixups */
 212         if (!child)
 213                 return 0;
 214
 215         /* find the local fixups property */
 216         for_each_property_of_node(child, rprop) {
 217                 /* skip properties added automatically */
 218                 if (of_prop_cmp(rprop->name, "name") == 0)
 219                         continue;
 220
 221                 err = __of_adjust_phandle_ref(node, rprop, phandle_delta, true);
 222                 if (err)
 223                         return err;
 224         }
 225
 226         return 0;
 227 }
 228
 229 /**
 230  * of_resolve   - Resolve the given node against the live tree.
 231  *
 232  * @resolve:    Node to resolve
 233  *
 234  * Perform dynamic Device Tree resolution against the live tree
 235  * to the given node to resolve. This depends on the live tree
 236  * having a __symbols__ node, and the resolve node the __fixups__ &
 237  * __local_fixups__ nodes (if needed).
 238  * The result of the operation is a resolve node that it's contents
 239  * are fit to be inserted or operate upon the live tree.
 240  * Returns 0 on success or a negative error value on error.
 241  */
 242 int of_resolve_phandles(struct device_node *resolve)
 243 {
 244         struct device_node *child, *refnode;
 245         struct device_node *root_sym, *resolve_sym, *resolve_fix;
 246         struct property *rprop;
 247         const char *refpath;
 248         phandle phandle, phandle_delta;
 249         int err;
 250
 251         /* the resolve node must exist, and be detached */
 252         if (!resolve || !of_node_check_flag(resolve, OF_DETACHED))
 253                 return -EINVAL;
 254
 255         /* first we need to adjust the phandles */
 256         phandle_delta = of_get_tree_max_phandle() + 1;
 257         __of_adjust_tree_phandles(resolve, phandle_delta);
 258         err = __of_adjust_tree_phandle_references(resolve, phandle_delta);
 259         if (err != 0)
 260                 return err;
 261
 262         root_sym = NULL;
 263         resolve_sym = NULL;
 264         resolve_fix = NULL;
 265
 266         /* this may fail (if no fixups are required) */
 267         root_sym = of_find_node_by_path("/__symbols__");
 268
 269         /* locate the symbols & fixups nodes on resolve */
 270         for_each_child_of_node(resolve, child) {
 271
 272                 if (!resolve_sym &&
 273                                 of_node_cmp(child->name, "__symbols__") == 0)
 274                         resolve_sym = child;
 275
 276                 if (!resolve_fix &&
 277                                 of_node_cmp(child->name, "__fixups__") == 0)
 278                         resolve_fix = child;
 279
 280                 /* both found, don't bother anymore */
 281                 if (resolve_sym && resolve_fix)
 282                         break;
 283         }
 284
 285         /* we do allow for the case where no fixups are needed */
 286         if (!resolve_fix) {
 287                 err = 0;        /* no error */
 288                 goto out;
 289         }
 290
 291         /* we need to fixup, but no root symbols... */
 292         if (!root_sym) {
 293                 err = -EINVAL;
 294                 goto out;
 295         }
 296
 297         for_each_property_of_node(resolve_fix, rprop) {
 298
 299                 /* skip properties added automatically */
 300                 if (of_prop_cmp(rprop->name, "name") == 0)
 301                         continue;
 302
 303                 err = of_property_read_string(root_sym,
 304                                 rprop->name, &refpath);
 305                 if (err != 0) {
 306                         pr_err("%s: Could not find symbol '%s'\n",
 307                                         __func__, rprop->name);
 308                         goto out;
 309                 }
 310
 311                 refnode = of_find_node_by_path(refpath);
 312                 if (!refnode) {
 313                         pr_err("%s: Could not find node by path '%s'\n",
 314                                         __func__, refpath);
 315                         err = -ENOENT;
 316                         goto out;
 317                 }
 318
 319                 phandle = refnode->phandle;
 320                 of_node_put(refnode);
 321
 322                 pr_debug("%s: %s phandle is 0x%08x\n",
 323                                 __func__, rprop->name, phandle);
 324
 325                 err = __of_adjust_phandle_ref(resolve, rprop, phandle, false);
 326                 if (err)
 327                         break;
 328         }
 329
 330 out:
 331         /* NULL is handled by of_node_put as NOP */
 332         of_node_put(root_sym);
 333
 334         return err;
 335 }
 336 EXPORT_SYMBOL_GPL(of_resolve_phandles);