[mirror_edk2.git] / EmbeddedPkg / Library / FdtLib / fdt_overlay.c

/*\r
 * libfdt - Flat Device Tree manipulation\r
 * Copyright (C) 2016 Free Electrons\r
 * Copyright (C) 2016 NextThing Co.\r
 *\r
 * libfdt is dual licensed: you can use it either under the terms of\r
 * the GPL, or the BSD license, at your option.\r
 *\r
 *  a) This library is free software; you can redistribute it and/or\r
 *     modify it under the terms of the GNU General Public License as\r
 *     published by the Free Software Foundation; either version 2 of the\r
 *     License, or (at your option) any later version.\r
 *\r
 *     This library is distributed in the hope that it will be useful,\r
 *     but WITHOUT ANY WARRANTY; without even the implied warranty of\r
 *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
 *     GNU General Public License for more details.\r
 *\r
 *     You should have received a copy of the GNU General Public\r
 *     License along with this library; if not, write to the Free\r
 *     Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,\r
 *     MA 02110-1301 USA\r
 *\r
 * Alternatively,\r
 *\r
 *  b) Redistribution and use in source and binary forms, with or\r
 *     without modification, are permitted provided that the following\r
 *     conditions are met:\r
 *\r
 *     1. Redistributions of source code must retain the above\r
 *        copyright notice, this list of conditions and the following\r
 *        disclaimer.\r
 *     2. Redistributions in binary form must reproduce the above\r
 *        copyright notice, this list of conditions and the following\r
 *        disclaimer in the documentation and/or other materials\r
 *        provided with the distribution.\r
 *\r
 *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND\r
 *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,\r
 *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF\r
 *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\r
 *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR\r
 *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\r
 *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\r
 *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r
 *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\r
 *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
 *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR\r
 *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,\r
 *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
 */\r
#include "libfdt_env.h"\r
\r
#include <fdt.h>\r
#include <libfdt.h>\r
\r
#include "libfdt_internal.h"\r
\r
/**\r
 * overlay_get_target_phandle - retrieves the target phandle of a fragment\r
 * @fdto: pointer to the device tree overlay blob\r
 * @fragment: node offset of the fragment in the overlay\r
 *\r
 * overlay_get_target_phandle() retrieves the target phandle of an\r
 * overlay fragment when that fragment uses a phandle (target\r
 * property) instead of a path (target-path property).\r
 *\r
 * returns:\r
 *      the phandle pointed by the target property\r
 *      0, if the phandle was not found\r
 *      -1, if the phandle was malformed\r
 */\r
static uint32_t\r
overlay_get_target_phandle (\r
  const void  *fdto,\r
  int         fragment\r
  )\r
{\r
  const fdt32_t  *val;\r
  int            len;\r
\r
  val = fdt_getprop (fdto, fragment, "target", &len);\r
  if (!val) {\r
    return 0;\r
  }\r
\r
  if ((len != sizeof (*val)) || (fdt32_to_cpu (*val) == (uint32_t)-1)) {\r
    return (uint32_t)-1;\r
  }\r
\r
  return fdt32_to_cpu (*val);\r
}\r
\r
/**\r
 * overlay_get_target - retrieves the offset of a fragment's target\r
 * @fdt: Base device tree blob\r
 * @fdto: Device tree overlay blob\r
 * @fragment: node offset of the fragment in the overlay\r
 * @pathp: pointer which receives the path of the target (or NULL)\r
 *\r
 * overlay_get_target() retrieves the target offset in the base\r
 * device tree of a fragment, no matter how the actual targetting is\r
 * done (through a phandle or a path)\r
 *\r
 * returns:\r
 *      the targetted node offset in the base device tree\r
 *      Negative error code on error\r
 */\r
static int\r
overlay_get_target (\r
  const void  *fdt,\r
  const void  *fdto,\r
  int         fragment,\r
  char const  **pathp\r
  )\r
{\r
  uint32_t    phandle;\r
  const char  *path = NULL;\r
  int         path_len = 0, ret;\r
\r
  /* Try first to do a phandle based lookup */\r
  phandle = overlay_get_target_phandle (fdto, fragment);\r
  if (phandle == (uint32_t)-1) {\r
    return -FDT_ERR_BADPHANDLE;\r
  }\r
\r
  /* no phandle, try path */\r
  if (!phandle) {\r
    /* And then a path based lookup */\r
    path = fdt_getprop (fdto, fragment, "target-path", &path_len);\r
    if (path) {\r
      ret = fdt_path_offset (fdt, path);\r
    } else {\r
      ret = path_len;\r
    }\r
  } else {\r
    ret = fdt_node_offset_by_phandle (fdt, phandle);\r
  }\r
\r
  /*\r
  * If we haven't found either a target or a\r
  * target-path property in a node that contains a\r
  * __overlay__ subnode (we wouldn't be called\r
  * otherwise), consider it a improperly written\r
  * overlay\r
  */\r
  if ((ret < 0) && (path_len == -FDT_ERR_NOTFOUND)) {\r
    ret = -FDT_ERR_BADOVERLAY;\r
  }\r
\r
  /* return on error */\r
  if (ret < 0) {\r
    return ret;\r
  }\r
\r
  /* return pointer to path (if available) */\r
  if (pathp) {\r
    *pathp = path ? path : NULL;\r
  }\r
\r
  return ret;\r
}\r
\r
/**\r
 * overlay_phandle_add_offset - Increases a phandle by an offset\r
 * @fdt: Base device tree blob\r
 * @node: Device tree overlay blob\r
 * @name: Name of the property to modify (phandle or linux,phandle)\r
 * @delta: offset to apply\r
 *\r
 * overlay_phandle_add_offset() increments a node phandle by a given\r
 * offset.\r
 *\r
 * returns:\r
 *      0 on success.\r
 *      Negative error code on error\r
 */\r
static int\r
overlay_phandle_add_offset (\r
  void        *fdt,\r
  int         node,\r
  const char  *name,\r
  uint32_t    delta\r
  )\r
{\r
  const fdt32_t  *val;\r
  uint32_t       adj_val;\r
  int            len;\r
\r
  val = fdt_getprop (fdt, node, name, &len);\r
  if (!val) {\r
    return len;\r
  }\r
\r
  if (len != sizeof (*val)) {\r
    return -FDT_ERR_BADPHANDLE;\r
  }\r
\r
  adj_val = fdt32_to_cpu (*val);\r
  if ((adj_val + delta) < adj_val) {\r
    return -FDT_ERR_NOPHANDLES;\r
  }\r
\r
  adj_val += delta;\r
  if (adj_val == (uint32_t)-1) {\r
    return -FDT_ERR_NOPHANDLES;\r
  }\r
\r
  return fdt_setprop_inplace_u32 (fdt, node, name, adj_val);\r
}\r
\r
/**\r
 * overlay_adjust_node_phandles - Offsets the phandles of a node\r
 * @fdto: Device tree overlay blob\r
 * @node: Offset of the node we want to adjust\r
 * @delta: Offset to shift the phandles of\r
 *\r
 * overlay_adjust_node_phandles() adds a constant to all the phandles\r
 * of a given node. This is mainly use as part of the overlay\r
 * application process, when we want to update all the overlay\r
 * phandles to not conflict with the overlays of the base device tree.\r
 *\r
 * returns:\r
 *      0 on success\r
 *      Negative error code on failure\r
 */\r
static int\r
overlay_adjust_node_phandles (\r
  void      *fdto,\r
  int       node,\r
  uint32_t  delta\r
  )\r
{\r
  int  child;\r
  int  ret;\r
\r
  ret = overlay_phandle_add_offset (fdto, node, "phandle", delta);\r
  if (ret && (ret != -FDT_ERR_NOTFOUND)) {\r
    return ret;\r
  }\r
\r
  ret = overlay_phandle_add_offset (fdto, node, "linux,phandle", delta);\r
  if (ret && (ret != -FDT_ERR_NOTFOUND)) {\r
    return ret;\r
  }\r
\r
  fdt_for_each_subnode (child, fdto, node) {\r
    ret = overlay_adjust_node_phandles (fdto, child, delta);\r
    if (ret) {\r
      return ret;\r
    }\r
  }\r
\r
  return 0;\r
}\r
\r
/**\r
 * overlay_adjust_local_phandles - Adjust the phandles of a whole overlay\r
 * @fdto: Device tree overlay blob\r
 * @delta: Offset to shift the phandles of\r
 *\r
 * overlay_adjust_local_phandles() adds a constant to all the\r
 * phandles of an overlay. This is mainly use as part of the overlay\r
 * application process, when we want to update all the overlay\r
 * phandles to not conflict with the overlays of the base device tree.\r
 *\r
 * returns:\r
 *      0 on success\r
 *      Negative error code on failure\r
 */\r
static int\r
overlay_adjust_local_phandles (\r
  void      *fdto,\r
  uint32_t  delta\r
  )\r
{\r
  /*\r
   * Start adjusting the phandles from the overlay root\r
   */\r
  return overlay_adjust_node_phandles (fdto, 0, delta);\r
}\r
\r
/**\r
 * overlay_update_local_node_references - Adjust the overlay references\r
 * @fdto: Device tree overlay blob\r
 * @tree_node: Node offset of the node to operate on\r
 * @fixup_node: Node offset of the matching local fixups node\r
 * @delta: Offset to shift the phandles of\r
 *\r
 * overlay_update_local_nodes_references() update the phandles\r
 * pointing to a node within the device tree overlay by adding a\r
 * constant delta.\r
 *\r
 * This is mainly used as part of a device tree application process,\r
 * where you want the device tree overlays phandles to not conflict\r
 * with the ones from the base device tree before merging them.\r
 *\r
 * returns:\r
 *      0 on success\r
 *      Negative error code on failure\r
 */\r
static int\r
overlay_update_local_node_references (\r
  void      *fdto,\r
  int       tree_node,\r
  int       fixup_node,\r
  uint32_t  delta\r
  )\r
{\r
  int  fixup_prop;\r
  int  fixup_child;\r
  int  ret;\r
\r
  fdt_for_each_property_offset (fixup_prop, fdto, fixup_node) {\r
    const fdt32_t  *fixup_val;\r
    const char     *tree_val;\r
    const char     *name;\r
    int            fixup_len;\r
    int            tree_len;\r
    int            i;\r
\r
    fixup_val = fdt_getprop_by_offset (\r
                  fdto,\r
                  fixup_prop,\r
                  &name,\r
                  &fixup_len\r
                  );\r
    if (!fixup_val) {\r
      return fixup_len;\r
    }\r
\r
    if (fixup_len % sizeof (uint32_t)) {\r
      return -FDT_ERR_BADOVERLAY;\r
    }\r
\r
    tree_val = fdt_getprop (fdto, tree_node, name, &tree_len);\r
    if (!tree_val) {\r
      if (tree_len == -FDT_ERR_NOTFOUND) {\r
        return -FDT_ERR_BADOVERLAY;\r
      }\r
\r
      return tree_len;\r
    }\r
\r
    for (i = 0; i < (fixup_len / sizeof (uint32_t)); i++) {\r
      fdt32_t   adj_val;\r
      uint32_t  poffset;\r
\r
      poffset = fdt32_to_cpu (fixup_val[i]);\r
\r
      /*\r
       * phandles to fixup can be unaligned.\r
       *\r
       * Use a memcpy for the architectures that do\r
       * not support unaligned accesses.\r
       */\r
      memcpy (&adj_val, tree_val + poffset, sizeof (adj_val));\r
\r
      adj_val = cpu_to_fdt32 (fdt32_to_cpu (adj_val) + delta);\r
\r
      ret = fdt_setprop_inplace_namelen_partial (\r
              fdto,\r
              tree_node,\r
              name,\r
              strlen (name),\r
              poffset,\r
              &adj_val,\r
              sizeof (adj_val)\r
              );\r
      if (ret == -FDT_ERR_NOSPACE) {\r
        return -FDT_ERR_BADOVERLAY;\r
      }\r
\r
      if (ret) {\r
        return ret;\r
      }\r
    }\r
  }\r
\r
  fdt_for_each_subnode (fixup_child, fdto, fixup_node) {\r
    const char  *fixup_child_name = fdt_get_name (\r
                                      fdto,\r
                                      fixup_child,\r
                                      NULL\r
                                      );\r
    int  tree_child;\r
\r
    tree_child = fdt_subnode_offset (\r
                   fdto,\r
                   tree_node,\r
                   fixup_child_name\r
                   );\r
    if (tree_child == -FDT_ERR_NOTFOUND) {\r
      return -FDT_ERR_BADOVERLAY;\r
    }\r
\r
    if (tree_child < 0) {\r
      return tree_child;\r
    }\r
\r
    ret = overlay_update_local_node_references (\r
            fdto,\r
            tree_child,\r
            fixup_child,\r
            delta\r
            );\r
    if (ret) {\r
      return ret;\r
    }\r
  }\r
\r
  return 0;\r
}\r
\r
/**\r
 * overlay_update_local_references - Adjust the overlay references\r
 * @fdto: Device tree overlay blob\r
 * @delta: Offset to shift the phandles of\r
 *\r
 * overlay_update_local_references() update all the phandles pointing\r
 * to a node within the device tree overlay by adding a constant\r
 * delta to not conflict with the base overlay.\r
 *\r
 * This is mainly used as part of a device tree application process,\r
 * where you want the device tree overlays phandles to not conflict\r
 * with the ones from the base device tree before merging them.\r
 *\r
 * returns:\r
 *      0 on success\r
 *      Negative error code on failure\r
 */\r
static int\r
overlay_update_local_references (\r
  void      *fdto,\r
  uint32_t  delta\r
  )\r
{\r
  int  fixups;\r
\r
  fixups = fdt_path_offset (fdto, "/__local_fixups__");\r
  if (fixups < 0) {\r
    /* There's no local phandles to adjust, bail out */\r
    if (fixups == -FDT_ERR_NOTFOUND) {\r
      return 0;\r
    }\r
\r
    return fixups;\r
  }\r
\r
  /*\r
   * Update our local references from the root of the tree\r
   */\r
  return overlay_update_local_node_references (\r
           fdto,\r
           0,\r
           fixups,\r
           delta\r
           );\r
}\r
\r
/**\r
 * overlay_fixup_one_phandle - Set an overlay phandle to the base one\r
 * @fdt: Base Device Tree blob\r
 * @fdto: Device tree overlay blob\r
 * @symbols_off: Node offset of the symbols node in the base device tree\r
 * @path: Path to a node holding a phandle in the overlay\r
 * @path_len: number of path characters to consider\r
 * @name: Name of the property holding the phandle reference in the overlay\r
 * @name_len: number of name characters to consider\r
 * @poffset: Offset within the overlay property where the phandle is stored\r
 * @label: Label of the node referenced by the phandle\r
 *\r
 * overlay_fixup_one_phandle() resolves an overlay phandle pointing to\r
 * a node in the base device tree.\r
 *\r
 * This is part of the device tree overlay application process, when\r
 * you want all the phandles in the overlay to point to the actual\r
 * base dt nodes.\r
 *\r
 * returns:\r
 *      0 on success\r
 *      Negative error code on failure\r
 */\r
static int\r
overlay_fixup_one_phandle (\r
  void        *fdt,\r
  void        *fdto,\r
  int         symbols_off,\r
  const char  *path,\r
  uint32_t    path_len,\r
  const char  *name,\r
  uint32_t    name_len,\r
  int         poffset,\r
  const char  *label\r
  )\r
{\r
  const char  *symbol_path;\r
  uint32_t    phandle;\r
  fdt32_t     phandle_prop;\r
  int         symbol_off, fixup_off;\r
  int         prop_len;\r
\r
  if (symbols_off < 0) {\r
    return symbols_off;\r
  }\r
\r
  symbol_path = fdt_getprop (\r
                  fdt,\r
                  symbols_off,\r
                  label,\r
                  &prop_len\r
                  );\r
  if (!symbol_path) {\r
    return prop_len;\r
  }\r
\r
  symbol_off = fdt_path_offset (fdt, symbol_path);\r
  if (symbol_off < 0) {\r
    return symbol_off;\r
  }\r
\r
  phandle = fdt_get_phandle (fdt, symbol_off);\r
  if (!phandle) {\r
    return -FDT_ERR_NOTFOUND;\r
  }\r
\r
  fixup_off = fdt_path_offset_namelen (fdto, path, path_len);\r
  if (fixup_off == -FDT_ERR_NOTFOUND) {\r
    return -FDT_ERR_BADOVERLAY;\r
  }\r
\r
  if (fixup_off < 0) {\r
    return fixup_off;\r
  }\r
\r
  phandle_prop = cpu_to_fdt32 (phandle);\r
  return fdt_setprop_inplace_namelen_partial (\r
           fdto,\r
           fixup_off,\r
           name,\r
           name_len,\r
           poffset,\r
           &phandle_prop,\r
           sizeof (phandle_prop)\r
           );\r
}\r
\r
unsigned long\r
strtoul (\r
  const char  *nptr,\r
  char        **endptr,\r
  int         base\r
  );\r
\r
/**\r
 * overlay_fixup_phandle - Set an overlay phandle to the base one\r
 * @fdt: Base Device Tree blob\r
 * @fdto: Device tree overlay blob\r
 * @symbols_off: Node offset of the symbols node in the base device tree\r
 * @property: Property offset in the overlay holding the list of fixups\r
 *\r
 * overlay_fixup_phandle() resolves all the overlay phandles pointed\r
 * to in a __fixups__ property, and updates them to match the phandles\r
 * in use in the base device tree.\r
 *\r
 * This is part of the device tree overlay application process, when\r
 * you want all the phandles in the overlay to point to the actual\r
 * base dt nodes.\r
 *\r
 * returns:\r
 *      0 on success\r
 *      Negative error code on failure\r
 */\r
static int\r
overlay_fixup_phandle (\r
  void  *fdt,\r
  void  *fdto,\r
  int   symbols_off,\r
  int   property\r
  )\r
{\r
  const char  *value;\r
  const char  *label;\r
  int         len;\r
\r
  value = fdt_getprop_by_offset (\r
            fdto,\r
            property,\r
            &label,\r
            &len\r
            );\r
  if (!value) {\r
    if (len == -FDT_ERR_NOTFOUND) {\r
      return -FDT_ERR_INTERNAL;\r
    }\r
\r
    return len;\r
  }\r
\r
  do {\r
    const char  *path, *name, *fixup_end;\r
    const char  *fixup_str = value;\r
    uint32_t    path_len, name_len;\r
    uint32_t    fixup_len;\r
    char        *sep, *endptr;\r
    int         poffset, ret;\r
\r
    fixup_end = memchr (value, '\0', len);\r
    if (!fixup_end) {\r
      return -FDT_ERR_BADOVERLAY;\r
    }\r
\r
    fixup_len = fixup_end - fixup_str;\r
\r
    len   -= fixup_len + 1;\r
    value += fixup_len + 1;\r
\r
    path = fixup_str;\r
    sep  = memchr (fixup_str, ':', fixup_len);\r
    if (!sep || (*sep != ':')) {\r
      return -FDT_ERR_BADOVERLAY;\r
    }\r
\r
    path_len = sep - path;\r
    if (path_len == (fixup_len - 1)) {\r
      return -FDT_ERR_BADOVERLAY;\r
    }\r
\r
    fixup_len -= path_len + 1;\r
    name       = sep + 1;\r
    sep        = memchr (name, ':', fixup_len);\r
    if (!sep || (*sep != ':')) {\r
      return -FDT_ERR_BADOVERLAY;\r
    }\r
\r
    name_len = sep - name;\r
    if (!name_len) {\r
      return -FDT_ERR_BADOVERLAY;\r
    }\r
\r
    poffset = strtoul (sep + 1, &endptr, 10);\r
    if ((*endptr != '\0') || (endptr <= (sep + 1))) {\r
      return -FDT_ERR_BADOVERLAY;\r
    }\r
\r
    ret = overlay_fixup_one_phandle (\r
            fdt,\r
            fdto,\r
            symbols_off,\r
            path,\r
            path_len,\r
            name,\r
            name_len,\r
            poffset,\r
            label\r
            );\r
    if (ret) {\r
      return ret;\r
    }\r
  } while (len > 0);\r
\r
  return 0;\r
}\r
\r
/**\r
 * overlay_fixup_phandles - Resolve the overlay phandles to the base\r
 *                          device tree\r
 * @fdt: Base Device Tree blob\r
 * @fdto: Device tree overlay blob\r
 *\r
 * overlay_fixup_phandles() resolves all the overlay phandles pointing\r
 * to nodes in the base device tree.\r
 *\r
 * This is one of the steps of the device tree overlay application\r
 * process, when you want all the phandles in the overlay to point to\r
 * the actual base dt nodes.\r
 *\r
 * returns:\r
 *      0 on success\r
 *      Negative error code on failure\r
 */\r
static int\r
overlay_fixup_phandles (\r
  void  *fdt,\r
  void  *fdto\r
  )\r
{\r
  int  fixups_off, symbols_off;\r
  int  property;\r
\r
  /* We can have overlays without any fixups */\r
  fixups_off = fdt_path_offset (fdto, "/__fixups__");\r
  if (fixups_off == -FDT_ERR_NOTFOUND) {\r
    return 0;             /* nothing to do */\r
  }\r
\r
  if (fixups_off < 0) {\r
    return fixups_off;\r
  }\r
\r
  /* And base DTs without symbols */\r
  symbols_off = fdt_path_offset (fdt, "/__symbols__");\r
  if (((symbols_off < 0) && (symbols_off != -FDT_ERR_NOTFOUND))) {\r
    return symbols_off;\r
  }\r
\r
  fdt_for_each_property_offset (property, fdto, fixups_off) {\r
    int  ret;\r
\r
    ret = overlay_fixup_phandle (fdt, fdto, symbols_off, property);\r
    if (ret) {\r
      return ret;\r
    }\r
  }\r
\r
  return 0;\r
}\r
\r
/**\r
 * overlay_apply_node - Merges a node into the base device tree\r
 * @fdt: Base Device Tree blob\r
 * @target: Node offset in the base device tree to apply the fragment to\r
 * @fdto: Device tree overlay blob\r
 * @node: Node offset in the overlay holding the changes to merge\r
 *\r
 * overlay_apply_node() merges a node into a target base device tree\r
 * node pointed.\r
 *\r
 * This is part of the final step in the device tree overlay\r
 * application process, when all the phandles have been adjusted and\r
 * resolved and you just have to merge overlay into the base device\r
 * tree.\r
 *\r
 * returns:\r
 *      0 on success\r
 *      Negative error code on failure\r
 */\r
static int\r
overlay_apply_node (\r
  void  *fdt,\r
  int   target,\r
  void  *fdto,\r
  int   node\r
  )\r
{\r
  int  property;\r
  int  subnode;\r
\r
  fdt_for_each_property_offset (property, fdto, node) {\r
    const char  *name;\r
    const void  *prop;\r
    int         prop_len;\r
    int         ret;\r
\r
    prop = fdt_getprop_by_offset (\r
             fdto,\r
             property,\r
             &name,\r
             &prop_len\r
             );\r
    if (prop_len == -FDT_ERR_NOTFOUND) {\r
      return -FDT_ERR_INTERNAL;\r
    }\r
\r
    if (prop_len < 0) {\r
      return prop_len;\r
    }\r
\r
    ret = fdt_setprop (fdt, target, name, prop, prop_len);\r
    if (ret) {\r
      return ret;\r
    }\r
  }\r
\r
  fdt_for_each_subnode (subnode, fdto, node) {\r
    const char  *name = fdt_get_name (fdto, subnode, NULL);\r
    int         nnode;\r
    int         ret;\r
\r
    nnode = fdt_add_subnode (fdt, target, name);\r
    if (nnode == -FDT_ERR_EXISTS) {\r
      nnode = fdt_subnode_offset (fdt, target, name);\r
      if (nnode == -FDT_ERR_NOTFOUND) {\r
        return -FDT_ERR_INTERNAL;\r
      }\r
    }\r
\r
    if (nnode < 0) {\r
      return nnode;\r
    }\r
\r
    ret = overlay_apply_node (fdt, nnode, fdto, subnode);\r
    if (ret) {\r
      return ret;\r
    }\r
  }\r
\r
  return 0;\r
}\r
\r
/**\r
 * overlay_merge - Merge an overlay into its base device tree\r
 * @fdt: Base Device Tree blob\r
 * @fdto: Device tree overlay blob\r
 *\r
 * overlay_merge() merges an overlay into its base device tree.\r
 *\r
 * This is the next to last step in the device tree overlay application\r
 * process, when all the phandles have been adjusted and resolved and\r
 * you just have to merge overlay into the base device tree.\r
 *\r
 * returns:\r
 *      0 on success\r
 *      Negative error code on failure\r
 */\r
static int\r
overlay_merge (\r
  void  *fdt,\r
  void  *fdto\r
  )\r
{\r
  int  fragment;\r
\r
  fdt_for_each_subnode (fragment, fdto, 0) {\r
    int  overlay;\r
    int  target;\r
    int  ret;\r
\r
    /*\r
     * Each fragments will have an __overlay__ node. If\r
     * they don't, it's not supposed to be merged\r
     */\r
    overlay = fdt_subnode_offset (fdto, fragment, "__overlay__");\r
    if (overlay == -FDT_ERR_NOTFOUND) {\r
      continue;\r
    }\r
\r
    if (overlay < 0) {\r
      return overlay;\r
    }\r
\r
    target = overlay_get_target (fdt, fdto, fragment, NULL);\r
    if (target < 0) {\r
      return target;\r
    }\r
\r
    ret = overlay_apply_node (fdt, target, fdto, overlay);\r
    if (ret) {\r
      return ret;\r
    }\r
  }\r
\r
  return 0;\r
}\r
\r
static int\r
get_path_len (\r
  const void  *fdt,\r
  int         nodeoffset\r
  )\r
{\r
  int         len = 0, namelen;\r
  const char  *name;\r
\r
  FDT_CHECK_HEADER (fdt);\r
\r
  for ( ; ;) {\r
    name = fdt_get_name (fdt, nodeoffset, &namelen);\r
    if (!name) {\r
      return namelen;\r
    }\r
\r
    /* root? we're done */\r
    if (namelen == 0) {\r
      break;\r
    }\r
\r
    nodeoffset = fdt_parent_offset (fdt, nodeoffset);\r
    if (nodeoffset < 0) {\r
      return nodeoffset;\r
    }\r
\r
    len += namelen + 1;\r
  }\r
\r
  /* in case of root pretend it's "/" */\r
  if (len == 0) {\r
    len++;\r
  }\r
\r
  return len;\r
}\r
\r
/**\r
 * overlay_symbol_update - Update the symbols of base tree after a merge\r
 * @fdt: Base Device Tree blob\r
 * @fdto: Device tree overlay blob\r
 *\r
 * overlay_symbol_update() updates the symbols of the base tree with the\r
 * symbols of the applied overlay\r
 *\r
 * This is the last step in the device tree overlay application\r
 * process, allowing the reference of overlay symbols by subsequent\r
 * overlay operations.\r
 *\r
 * returns:\r
 *      0 on success\r
 *      Negative error code on failure\r
 */\r
static int\r
overlay_symbol_update (\r
  void  *fdt,\r
  void  *fdto\r
  )\r
{\r
  int         root_sym, ov_sym, prop, path_len, fragment, target;\r
  int         len, frag_name_len, ret, rel_path_len;\r
  const char  *s, *e;\r
  const char  *path;\r
  const char  *name;\r
  const char  *frag_name;\r
  const char  *rel_path;\r
  const char  *target_path;\r
  char        *buf;\r
  void        *p;\r
\r
  ov_sym = fdt_subnode_offset (fdto, 0, "__symbols__");\r
\r
  /* if no overlay symbols exist no problem */\r
  if (ov_sym < 0) {\r
    return 0;\r
  }\r
\r
  root_sym = fdt_subnode_offset (fdt, 0, "__symbols__");\r
\r
  /* it no root symbols exist we should create them */\r
  if (root_sym == -FDT_ERR_NOTFOUND) {\r
    root_sym = fdt_add_subnode (fdt, 0, "__symbols__");\r
  }\r
\r
  /* any error is fatal now */\r
  if (root_sym < 0) {\r
    return root_sym;\r
  }\r
\r
  /* iterate over each overlay symbol */\r
  fdt_for_each_property_offset (prop, fdto, ov_sym) {\r
    path = fdt_getprop_by_offset (fdto, prop, &name, &path_len);\r
    if (!path) {\r
      return path_len;\r
    }\r
\r
    /* verify it's a string property (terminated by a single \0) */\r
    if ((path_len < 1) || (memchr (path, '\0', path_len) != &path[path_len - 1])) {\r
      return -FDT_ERR_BADVALUE;\r
    }\r
\r
    /* keep end marker to avoid strlen() */\r
    e = path + path_len;\r
\r
    /* format: /<fragment-name>/__overlay__/<relative-subnode-path> */\r
\r
    if (*path != '/') {\r
      return -FDT_ERR_BADVALUE;\r
    }\r
\r
    /* get fragment name first */\r
    s = strchr (path + 1, '/');\r
    if (!s) {\r
      return -FDT_ERR_BADOVERLAY;\r
    }\r
\r
    frag_name     = path + 1;\r
    frag_name_len = s - path - 1;\r
\r
    /* verify format; safe since "s" lies in \0 terminated prop */\r
    len = sizeof ("/__overlay__/") - 1;\r
    if (((e - s) < len) || memcmp (s, "/__overlay__/", len)) {\r
      return -FDT_ERR_BADOVERLAY;\r
    }\r
\r
    rel_path     = s + len;\r
    rel_path_len = e - rel_path;\r
\r
    /* find the fragment index in which the symbol lies */\r
    ret = fdt_subnode_offset_namelen (\r
            fdto,\r
            0,\r
            frag_name,\r
            frag_name_len\r
            );\r
    /* not found? */\r
    if (ret < 0) {\r
      return -FDT_ERR_BADOVERLAY;\r
    }\r
\r
    fragment = ret;\r
\r
    /* an __overlay__ subnode must exist */\r
    ret = fdt_subnode_offset (fdto, fragment, "__overlay__");\r
    if (ret < 0) {\r
      return -FDT_ERR_BADOVERLAY;\r
    }\r
\r
    /* get the target of the fragment */\r
    ret = overlay_get_target (fdt, fdto, fragment, &target_path);\r
    if (ret < 0) {\r
      return ret;\r
    }\r
\r
    target = ret;\r
\r
    /* if we have a target path use */\r
    if (!target_path) {\r
      ret = get_path_len (fdt, target);\r
      if (ret < 0) {\r
        return ret;\r
      }\r
\r
      len = ret;\r
    } else {\r
      len = strlen (target_path);\r
    }\r
\r
    ret = fdt_setprop_placeholder (\r
            fdt,\r
            root_sym,\r
            name,\r
            len + (len > 1) + rel_path_len + 1,\r
            &p\r
            );\r
    if (ret < 0) {\r
      return ret;\r
    }\r
\r
    if (!target_path) {\r
      /* again in case setprop_placeholder changed it */\r
      ret = overlay_get_target (fdt, fdto, fragment, &target_path);\r
      if (ret < 0) {\r
        return ret;\r
      }\r
\r
      target = ret;\r
    }\r
\r
    buf = p;\r
    if (len > 1) {\r
      /* target is not root */\r
      if (!target_path) {\r
        ret = fdt_get_path (fdt, target, buf, len + 1);\r
        if (ret < 0) {\r
          return ret;\r
        }\r
      } else {\r
        memcpy (buf, target_path, len + 1);\r
      }\r
    } else {\r
      len--;\r
    }\r
\r
    buf[len] = '/';\r
    memcpy (buf + len + 1, rel_path, rel_path_len);\r
    buf[len + 1 + rel_path_len] = '\0';\r
  }\r
\r
  return 0;\r
}\r
\r
int\r
fdt_overlay_apply (\r
  void  *fdt,\r
  void  *fdto\r
  )\r
{\r
  uint32_t  delta = fdt_get_max_phandle (fdt);\r
  int       ret;\r
\r
  FDT_CHECK_HEADER (fdt);\r
  FDT_CHECK_HEADER (fdto);\r
\r
  ret = overlay_adjust_local_phandles (fdto, delta);\r
  if (ret) {\r
    goto err;\r
  }\r
\r
  ret = overlay_update_local_references (fdto, delta);\r
  if (ret) {\r
    goto err;\r
  }\r
\r
  ret = overlay_fixup_phandles (fdt, fdto);\r
  if (ret) {\r
    goto err;\r
  }\r
\r
  ret = overlay_merge (fdt, fdto);\r
  if (ret) {\r
    goto err;\r
  }\r
\r
  ret = overlay_symbol_update (fdt, fdto);\r
  if (ret) {\r
    goto err;\r
  }\r
\r
  /*\r
   * The overlay has been damaged, erase its magic.\r
   */\r
  fdt_set_magic (fdto, ~0);\r
\r
  return 0;\r
\r
err:\r
\r
  /*\r
   * The overlay might have been damaged, erase its magic.\r
   */\r
  fdt_set_magic (fdto, ~0);\r
\r
  /*\r
   * The base device tree might have been damaged, erase its\r
   * magic.\r
   */\r
  fdt_set_magic (fdt, ~0);\r
\r
  return ret;\r
}\r