ArmPkg: only attempt buildin MmCommunicationDxe for AArch64
[mirror_edk2.git] / EmbeddedPkg / Include / libfdt.h
index 85fe324..141ecb5 100644 (file)
@@ -61,7 +61,7 @@
 #define FDT_ERR_NOTFOUND       1\r
        /* FDT_ERR_NOTFOUND: The requested node or property does not exist */\r
 #define FDT_ERR_EXISTS         2\r
 #define FDT_ERR_NOTFOUND       1\r
        /* FDT_ERR_NOTFOUND: The requested node or property does not exist */\r
 #define FDT_ERR_EXISTS         2\r
-       /* FDT_ERR_EXISTS: Attemped to create a node or property which\r
+       /* FDT_ERR_EXISTS: Attempted to create a node or property which\r
         * already exists */\r
 #define FDT_ERR_NOSPACE                3\r
        /* FDT_ERR_NOSPACE: Operation needed to expand the device\r
         * already exists */\r
 #define FDT_ERR_NOSPACE                3\r
        /* FDT_ERR_NOSPACE: Operation needed to expand the device\r
         * (e.g. missing a leading / for a function which requires an\r
         * absolute path) */\r
 #define FDT_ERR_BADPHANDLE     6\r
         * (e.g. missing a leading / for a function which requires an\r
         * absolute path) */\r
 #define FDT_ERR_BADPHANDLE     6\r
-       /* FDT_ERR_BADPHANDLE: Function was passed an invalid phandle\r
-        * value.  phandle values of 0 and -1 are not permitted. */\r
+       /* FDT_ERR_BADPHANDLE: Function was passed an invalid phandle.\r
+        * This can be caused either by an invalid phandle property\r
+        * length, or the phandle value was either 0 or -1, which are\r
+        * not permitted. */\r
 #define FDT_ERR_BADSTATE       7\r
        /* FDT_ERR_BADSTATE: Function was passed an incomplete device\r
         * tree created by the sequential-write functions, which is\r
 #define FDT_ERR_BADSTATE       7\r
        /* FDT_ERR_BADSTATE: Function was passed an incomplete device\r
         * tree created by the sequential-write functions, which is\r
         * Should never be returned, if it is, it indicates a bug in\r
         * libfdt itself. */\r
 \r
         * Should never be returned, if it is, it indicates a bug in\r
         * libfdt itself. */\r
 \r
-#define FDT_ERR_MAX            13\r
+/* Errors in device tree content */\r
+#define FDT_ERR_BADNCELLS      14\r
+       /* FDT_ERR_BADNCELLS: Device tree has a #address-cells, #size-cells\r
+        * or similar property with a bad format or value */\r
+\r
+#define FDT_ERR_BADVALUE       15\r
+       /* FDT_ERR_BADVALUE: Device tree has a property with an unexpected\r
+        * value. For example: a property expected to contain a string list\r
+        * is not NUL-terminated within the length of its value. */\r
+\r
+#define FDT_ERR_BADOVERLAY     16\r
+       /* FDT_ERR_BADOVERLAY: The device tree overlay, while\r
+        * correctly structured, cannot be applied due to some\r
+        * unexpected or missing value, property or node. */\r
+\r
+#define FDT_ERR_NOPHANDLES     17\r
+       /* FDT_ERR_NOPHANDLES: The device tree doesn't have any\r
+        * phandle available anymore without causing an overflow */\r
+\r
+#define FDT_ERR_MAX            17\r
 \r
 /**********************************************************************/\r
 /* Low-level functions (you probably don't need these)                */\r
 /**********************************************************************/\r
 \r
 \r
 /**********************************************************************/\r
 /* Low-level functions (you probably don't need these)                */\r
 /**********************************************************************/\r
 \r
+#ifndef SWIG /* This function is not useful in Python */\r
 const void *fdt_offset_ptr(const void *fdt, int offset, unsigned int checklen);\r
 const void *fdt_offset_ptr(const void *fdt, int offset, unsigned int checklen);\r
+#endif\r
 static inline void *fdt_offset_ptr_w(void *fdt, int offset, int checklen)\r
 {\r
        return (void *)(uintptr_t)fdt_offset_ptr(fdt, offset, checklen);\r
 static inline void *fdt_offset_ptr_w(void *fdt, int offset, int checklen)\r
 {\r
        return (void *)(uintptr_t)fdt_offset_ptr(fdt, offset, checklen);\r
@@ -136,27 +159,76 @@ uint32_t fdt_next_tag(const void *fdt, int offset, int *nextoffset);
 \r
 int fdt_next_node(const void *fdt, int offset, int *depth);\r
 \r
 \r
 int fdt_next_node(const void *fdt, int offset, int *depth);\r
 \r
+/**\r
+ * fdt_first_subnode() - get offset of first direct subnode\r
+ *\r
+ * @fdt:       FDT blob\r
+ * @offset:    Offset of node to check\r
+ * @return offset of first subnode, or -FDT_ERR_NOTFOUND if there is none\r
+ */\r
+int fdt_first_subnode(const void *fdt, int offset);\r
+\r
+/**\r
+ * fdt_next_subnode() - get offset of next direct subnode\r
+ *\r
+ * After first calling fdt_first_subnode(), call this function repeatedly to\r
+ * get direct subnodes of a parent node.\r
+ *\r
+ * @fdt:       FDT blob\r
+ * @offset:    Offset of previous subnode\r
+ * @return offset of next subnode, or -FDT_ERR_NOTFOUND if there are no more\r
+ * subnodes\r
+ */\r
+int fdt_next_subnode(const void *fdt, int offset);\r
+\r
+/**\r
+ * fdt_for_each_subnode - iterate over all subnodes of a parent\r
+ *\r
+ * @node:      child node (int, lvalue)\r
+ * @fdt:       FDT blob (const void *)\r
+ * @parent:    parent node (int)\r
+ *\r
+ * This is actually a wrapper around a for loop and would be used like so:\r
+ *\r
+ *     fdt_for_each_subnode(node, fdt, parent) {\r
+ *             Use node\r
+ *             ...\r
+ *     }\r
+ *\r
+ *     if ((node < 0) && (node != -FDT_ERR_NOT_FOUND)) {\r
+ *             Error handling\r
+ *     }\r
+ *\r
+ * Note that this is implemented as a macro and @node is used as\r
+ * iterator in the loop. The parent variable be constant or even a\r
+ * literal.\r
+ *\r
+ */\r
+#define fdt_for_each_subnode(node, fdt, parent)                \\r
+       for (node = fdt_first_subnode(fdt, parent);     \\r
+            node >= 0;                                 \\r
+            node = fdt_next_subnode(fdt, node))\r
+\r
 /**********************************************************************/\r
 /* General functions                                                  */\r
 /**********************************************************************/\r
 /**********************************************************************/\r
 /* General functions                                                  */\r
 /**********************************************************************/\r
-\r
 #define fdt_get_header(fdt, field) \\r
        (fdt32_to_cpu(((const struct fdt_header *)(fdt))->field))\r
 #define fdt_get_header(fdt, field) \\r
        (fdt32_to_cpu(((const struct fdt_header *)(fdt))->field))\r
-#define fdt_magic(fdt)                         (fdt_get_header(fdt, magic))\r
+#define fdt_magic(fdt)                 (fdt_get_header(fdt, magic))\r
 #define fdt_totalsize(fdt)             (fdt_get_header(fdt, totalsize))\r
 #define fdt_off_dt_struct(fdt)         (fdt_get_header(fdt, off_dt_struct))\r
 #define fdt_off_dt_strings(fdt)                (fdt_get_header(fdt, off_dt_strings))\r
 #define fdt_off_mem_rsvmap(fdt)                (fdt_get_header(fdt, off_mem_rsvmap))\r
 #define fdt_version(fdt)               (fdt_get_header(fdt, version))\r
 #define fdt_totalsize(fdt)             (fdt_get_header(fdt, totalsize))\r
 #define fdt_off_dt_struct(fdt)         (fdt_get_header(fdt, off_dt_struct))\r
 #define fdt_off_dt_strings(fdt)                (fdt_get_header(fdt, off_dt_strings))\r
 #define fdt_off_mem_rsvmap(fdt)                (fdt_get_header(fdt, off_mem_rsvmap))\r
 #define fdt_version(fdt)               (fdt_get_header(fdt, version))\r
-#define fdt_last_comp_version(fdt)     (fdt_get_header(fdt, last_comp_version))\r
-#define fdt_boot_cpuid_phys(fdt)       (fdt_get_header(fdt, boot_cpuid_phys))\r
-#define fdt_size_dt_strings(fdt)       (fdt_get_header(fdt, size_dt_strings))\r
+#define fdt_last_comp_version(fdt)     (fdt_get_header(fdt, last_comp_version))\r
+#define fdt_boot_cpuid_phys(fdt)       (fdt_get_header(fdt, boot_cpuid_phys))\r
+#define fdt_size_dt_strings(fdt)       (fdt_get_header(fdt, size_dt_strings))\r
 #define fdt_size_dt_struct(fdt)                (fdt_get_header(fdt, size_dt_struct))\r
 \r
 #define __fdt_set_hdr(name) \\r
        static inline void fdt_set_##name(void *fdt, uint32_t val) \\r
        { \\r
 #define fdt_size_dt_struct(fdt)                (fdt_get_header(fdt, size_dt_struct))\r
 \r
 #define __fdt_set_hdr(name) \\r
        static inline void fdt_set_##name(void *fdt, uint32_t val) \\r
        { \\r
-               struct fdt_header *fdth = (struct fdt_header*)fdt; \\r
+               struct fdt_header *fdth = (struct fdt_header *)fdt; \\r
                fdth->name = cpu_to_fdt32(val); \\r
        }\r
 __fdt_set_hdr(magic);\r
                fdth->name = cpu_to_fdt32(val); \\r
        }\r
 __fdt_set_hdr(magic);\r
@@ -226,6 +298,21 @@ int fdt_move(const void *fdt, void *buf, int bufsize);
  */\r
 const char *fdt_string(const void *fdt, int stroffset);\r
 \r
  */\r
 const char *fdt_string(const void *fdt, int stroffset);\r
 \r
+/**\r
+ * fdt_get_max_phandle - retrieves the highest phandle in a tree\r
+ * @fdt: pointer to the device tree blob\r
+ *\r
+ * fdt_get_max_phandle retrieves the highest phandle in the given\r
+ * device tree. This will ignore badly formatted phandles, or phandles\r
+ * with a value of 0 or -1.\r
+ *\r
+ * returns:\r
+ *      the highest phandle on success\r
+ *      0, if no phandle was found in the device tree\r
+ *      -1, if an error occurred\r
+ */\r
+uint32_t fdt_get_max_phandle(const void *fdt);\r
+\r
 /**\r
  * fdt_num_mem_rsv - retrieve the number of memory reserve map entries\r
  * @fdt: pointer to the device tree blob\r
 /**\r
  * fdt_num_mem_rsv - retrieve the number of memory reserve map entries\r
  * @fdt: pointer to the device tree blob\r
@@ -268,8 +355,10 @@ int fdt_get_mem_rsv(const void *fdt, int n, uint64_t *address, uint64_t *size);
  * useful for finding subnodes based on a portion of a larger string,\r
  * such as a full path.\r
  */\r
  * useful for finding subnodes based on a portion of a larger string,\r
  * such as a full path.\r
  */\r
+#ifndef SWIG /* Not available in Python */\r
 int fdt_subnode_offset_namelen(const void *fdt, int parentoffset,\r
                               const char *name, int namelen);\r
 int fdt_subnode_offset_namelen(const void *fdt, int parentoffset,\r
                               const char *name, int namelen);\r
+#endif\r
 /**\r
  * fdt_subnode_offset - find a subnode of a given node\r
  * @fdt: pointer to the device tree blob\r
 /**\r
  * fdt_subnode_offset - find a subnode of a given node\r
  * @fdt: pointer to the device tree blob\r
@@ -286,8 +375,9 @@ int fdt_subnode_offset_namelen(const void *fdt, int parentoffset,
  * returns:\r
  *     structure block offset of the requested subnode (>=0), on success\r
  *     -FDT_ERR_NOTFOUND, if the requested subnode does not exist\r
  * returns:\r
  *     structure block offset of the requested subnode (>=0), on success\r
  *     -FDT_ERR_NOTFOUND, if the requested subnode does not exist\r
- *     -FDT_ERR_BADOFFSET, if parentoffset did not point to an FDT_BEGIN_NODE tag\r
- *      -FDT_ERR_BADMAGIC,\r
+ *     -FDT_ERR_BADOFFSET, if parentoffset did not point to an FDT_BEGIN_NODE\r
+ *             tag\r
+ *     -FDT_ERR_BADMAGIC,\r
  *     -FDT_ERR_BADVERSION,\r
  *     -FDT_ERR_BADSTATE,\r
  *     -FDT_ERR_BADSTRUCTURE,\r
  *     -FDT_ERR_BADVERSION,\r
  *     -FDT_ERR_BADSTATE,\r
  *     -FDT_ERR_BADSTRUCTURE,\r
@@ -295,6 +385,19 @@ int fdt_subnode_offset_namelen(const void *fdt, int parentoffset,
  */\r
 int fdt_subnode_offset(const void *fdt, int parentoffset, const char *name);\r
 \r
  */\r
 int fdt_subnode_offset(const void *fdt, int parentoffset, const char *name);\r
 \r
+/**\r
+ * fdt_path_offset_namelen - find a tree node by its full path\r
+ * @fdt: pointer to the device tree blob\r
+ * @path: full path of the node to locate\r
+ * @namelen: number of characters of path to consider\r
+ *\r
+ * Identical to fdt_path_offset(), but only consider the first namelen\r
+ * characters of path as the path name.\r
+ */\r
+#ifndef SWIG /* Not available in Python */\r
+int fdt_path_offset_namelen(const void *fdt, const char *path, int namelen);\r
+#endif\r
+\r
 /**\r
  * fdt_path_offset - find a tree node by its full path\r
  * @fdt: pointer to the device tree blob\r
 /**\r
  * fdt_path_offset - find a tree node by its full path\r
  * @fdt: pointer to the device tree blob\r
@@ -308,7 +411,8 @@ int fdt_subnode_offset(const void *fdt, int parentoffset, const char *name);
  * address).\r
  *\r
  * returns:\r
  * address).\r
  *\r
  * returns:\r
- *     structure block offset of the node with the requested path (>=0), on success\r
+ *     structure block offset of the node with the requested path (>=0), on\r
+ *             success\r
  *     -FDT_ERR_BADPATH, given path does not begin with '/' or is invalid\r
  *     -FDT_ERR_NOTFOUND, if the requested node does not exist\r
  *      -FDT_ERR_BADMAGIC,\r
  *     -FDT_ERR_BADPATH, given path does not begin with '/' or is invalid\r
  *     -FDT_ERR_NOTFOUND, if the requested node does not exist\r
  *      -FDT_ERR_BADMAGIC,\r
@@ -332,10 +436,12 @@ int fdt_path_offset(const void *fdt, const char *path);
  *\r
  * returns:\r
  *     pointer to the node's name, on success\r
  *\r
  * returns:\r
  *     pointer to the node's name, on success\r
- *             If lenp is non-NULL, *lenp contains the length of that name (>=0)\r
+ *             If lenp is non-NULL, *lenp contains the length of that name\r
+ *                     (>=0)\r
  *     NULL, on error\r
  *             if lenp is non-NULL *lenp contains an error code (<0):\r
  *     NULL, on error\r
  *             if lenp is non-NULL *lenp contains an error code (<0):\r
- *             -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag\r
+ *             -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE\r
+ *                     tag\r
  *             -FDT_ERR_BADMAGIC,\r
  *             -FDT_ERR_BADVERSION,\r
  *             -FDT_ERR_BADSTATE, standard meanings\r
  *             -FDT_ERR_BADMAGIC,\r
  *             -FDT_ERR_BADVERSION,\r
  *             -FDT_ERR_BADSTATE, standard meanings\r
@@ -383,6 +489,33 @@ int fdt_first_property_offset(const void *fdt, int nodeoffset);
  */\r
 int fdt_next_property_offset(const void *fdt, int offset);\r
 \r
  */\r
 int fdt_next_property_offset(const void *fdt, int offset);\r
 \r
+/**\r
+ * fdt_for_each_property_offset - iterate over all properties of a node\r
+ *\r
+ * @property_offset:   property offset (int, lvalue)\r
+ * @fdt:               FDT blob (const void *)\r
+ * @node:              node offset (int)\r
+ *\r
+ * This is actually a wrapper around a for loop and would be used like so:\r
+ *\r
+ *     fdt_for_each_property_offset(property, fdt, node) {\r
+ *             Use property\r
+ *             ...\r
+ *     }\r
+ *\r
+ *     if ((property < 0) && (property != -FDT_ERR_NOT_FOUND)) {\r
+ *             Error handling\r
+ *     }\r
+ *\r
+ * Note that this is implemented as a macro and property is used as\r
+ * iterator in the loop. The node variable can be constant or even a\r
+ * literal.\r
+ */\r
+#define fdt_for_each_property_offset(property, fdt, node)      \\r
+       for (property = fdt_first_property_offset(fdt, node);   \\r
+            property >= 0;                                     \\r
+            property = fdt_next_property_offset(fdt, property))\r
+\r
 /**\r
  * fdt_get_property_by_offset - retrieve the property at a given offset\r
  * @fdt: pointer to the device tree blob\r
 /**\r
  * fdt_get_property_by_offset - retrieve the property at a given offset\r
  * @fdt: pointer to the device tree blob\r
@@ -419,13 +552,15 @@ const struct fdt_property *fdt_get_property_by_offset(const void *fdt,
  * @namelen: number of characters of name to consider\r
  * @lenp: pointer to an integer variable (will be overwritten) or NULL\r
  *\r
  * @namelen: number of characters of name to consider\r
  * @lenp: pointer to an integer variable (will be overwritten) or NULL\r
  *\r
- * Identical to fdt_get_property_namelen(), but only examine the first\r
- * namelen characters of name for matching the property name.\r
+ * Identical to fdt_get_property(), but only examine the first namelen\r
+ * characters of name for matching the property name.\r
  */\r
  */\r
+#ifndef SWIG /* Not available in Python */\r
 const struct fdt_property *fdt_get_property_namelen(const void *fdt,\r
                                                    int nodeoffset,\r
                                                    const char *name,\r
                                                    int namelen, int *lenp);\r
 const struct fdt_property *fdt_get_property_namelen(const void *fdt,\r
                                                    int nodeoffset,\r
                                                    const char *name,\r
                                                    int namelen, int *lenp);\r
+#endif\r
 \r
 /**\r
  * fdt_get_property - find a given property in a given node\r
 \r
 /**\r
  * fdt_get_property - find a given property in a given node\r
@@ -447,7 +582,8 @@ const struct fdt_property *fdt_get_property_namelen(const void *fdt,
  *     NULL, on error\r
  *             if lenp is non-NULL, *lenp contains an error code (<0):\r
  *             -FDT_ERR_NOTFOUND, node does not have named property\r
  *     NULL, on error\r
  *             if lenp is non-NULL, *lenp contains an error code (<0):\r
  *             -FDT_ERR_NOTFOUND, node does not have named property\r
- *             -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag\r
+ *             -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE\r
+ *                     tag\r
  *             -FDT_ERR_BADMAGIC,\r
  *             -FDT_ERR_BADVERSION,\r
  *             -FDT_ERR_BADSTATE,\r
  *             -FDT_ERR_BADMAGIC,\r
  *             -FDT_ERR_BADVERSION,\r
  *             -FDT_ERR_BADSTATE,\r
@@ -495,8 +631,10 @@ static inline struct fdt_property *fdt_get_property_w(void *fdt, int nodeoffset,
  *             -FDT_ERR_BADSTRUCTURE,\r
  *             -FDT_ERR_TRUNCATED, standard meanings\r
  */\r
  *             -FDT_ERR_BADSTRUCTURE,\r
  *             -FDT_ERR_TRUNCATED, standard meanings\r
  */\r
+#ifndef SWIG /* This function is not useful in Python */\r
 const void *fdt_getprop_by_offset(const void *fdt, int offset,\r
                                  const char **namep, int *lenp);\r
 const void *fdt_getprop_by_offset(const void *fdt, int offset,\r
                                  const char **namep, int *lenp);\r
+#endif\r
 \r
 /**\r
  * fdt_getprop_namelen - get property value based on substring\r
 \r
 /**\r
  * fdt_getprop_namelen - get property value based on substring\r
@@ -509,8 +647,17 @@ const void *fdt_getprop_by_offset(const void *fdt, int offset,
  * Identical to fdt_getprop(), but only examine the first namelen\r
  * characters of name for matching the property name.\r
  */\r
  * Identical to fdt_getprop(), but only examine the first namelen\r
  * characters of name for matching the property name.\r
  */\r
+#ifndef SWIG /* Not available in Python */\r
 const void *fdt_getprop_namelen(const void *fdt, int nodeoffset,\r
                                const char *name, int namelen, int *lenp);\r
 const void *fdt_getprop_namelen(const void *fdt, int nodeoffset,\r
                                const char *name, int namelen, int *lenp);\r
+static inline void *fdt_getprop_namelen_w(void *fdt, int nodeoffset,\r
+                                         const char *name, int namelen,\r
+                                         int *lenp)\r
+{\r
+       return (void *)(uintptr_t)fdt_getprop_namelen(fdt, nodeoffset, name,\r
+                                                     namelen, lenp);\r
+}\r
+#endif\r
 \r
 /**\r
  * fdt_getprop - retrieve the value of a given property\r
 \r
 /**\r
  * fdt_getprop - retrieve the value of a given property\r
@@ -532,7 +679,8 @@ const void *fdt_getprop_namelen(const void *fdt, int nodeoffset,
  *     NULL, on error\r
  *             if lenp is non-NULL, *lenp contains an error code (<0):\r
  *             -FDT_ERR_NOTFOUND, node does not have named property\r
  *     NULL, on error\r
  *             if lenp is non-NULL, *lenp contains an error code (<0):\r
  *             -FDT_ERR_NOTFOUND, node does not have named property\r
- *             -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag\r
+ *             -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE\r
+ *                     tag\r
  *             -FDT_ERR_BADMAGIC,\r
  *             -FDT_ERR_BADVERSION,\r
  *             -FDT_ERR_BADSTATE,\r
  *             -FDT_ERR_BADMAGIC,\r
  *             -FDT_ERR_BADVERSION,\r
  *             -FDT_ERR_BADSTATE,\r
@@ -570,11 +718,13 @@ uint32_t fdt_get_phandle(const void *fdt, int nodeoffset);
  * Identical to fdt_get_alias(), but only examine the first namelen\r
  * characters of name for matching the alias name.\r
  */\r
  * Identical to fdt_get_alias(), but only examine the first namelen\r
  * characters of name for matching the alias name.\r
  */\r
+#ifndef SWIG /* Not available in Python */\r
 const char *fdt_get_alias_namelen(const void *fdt,\r
                                  const char *name, int namelen);\r
 const char *fdt_get_alias_namelen(const void *fdt,\r
                                  const char *name, int namelen);\r
+#endif\r
 \r
 /**\r
 \r
 /**\r
- * fdt_get_alias - retreive the path referenced by a given alias\r
+ * fdt_get_alias - retrieve the path referenced by a given alias\r
  * @fdt: pointer to the device tree blob\r
  * @name: name of the alias th look up\r
  *\r
  * @fdt: pointer to the device tree blob\r
  * @name: name of the alias th look up\r
  *\r
@@ -582,7 +732,7 @@ const char *fdt_get_alias_namelen(const void *fdt,
  * value of the property named 'name' in the node /aliases.\r
  *\r
  * returns:\r
  * value of the property named 'name' in the node /aliases.\r
  *\r
  * returns:\r
- *     a pointer to the expansion of the alias named 'name', of it exists\r
+ *     a pointer to the expansion of the alias named 'name', if it exists\r
  *     NULL, if the given alias or the /aliases node does not exist\r
  */\r
 const char *fdt_get_alias(const void *fdt, const char *name);\r
  *     NULL, if the given alias or the /aliases node does not exist\r
  */\r
 const char *fdt_get_alias(const void *fdt, const char *name);\r
@@ -604,7 +754,7 @@ const char *fdt_get_alias(const void *fdt, const char *name);
  *     0, on success\r
  *             buf contains the absolute path of the node at\r
  *             nodeoffset, as a NUL-terminated string.\r
  *     0, on success\r
  *             buf contains the absolute path of the node at\r
  *             nodeoffset, as a NUL-terminated string.\r
- *     -FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag\r
+ *     -FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag\r
  *     -FDT_ERR_NOSPACE, the path of the given node is longer than (bufsize-1)\r
  *             characters and will not fit in the given buffer.\r
  *     -FDT_ERR_BADMAGIC,\r
  *     -FDT_ERR_NOSPACE, the path of the given node is longer than (bufsize-1)\r
  *             characters and will not fit in the given buffer.\r
  *     -FDT_ERR_BADMAGIC,\r
@@ -634,11 +784,11 @@ int fdt_get_path(const void *fdt, int nodeoffset, char *buf, int buflen);
  * structure from the start to nodeoffset.\r
  *\r
  * returns:\r
  * structure from the start to nodeoffset.\r
  *\r
  * returns:\r
-\r
  *     structure block offset of the node at node offset's ancestor\r
  *             of depth supernodedepth (>=0), on success\r
  *     structure block offset of the node at node offset's ancestor\r
  *             of depth supernodedepth (>=0), on success\r
- *     -FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag\r
-*      -FDT_ERR_NOTFOUND, supernodedepth was greater than the depth of nodeoffset\r
+ *     -FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag\r
+ *     -FDT_ERR_NOTFOUND, supernodedepth was greater than the depth of\r
+ *             nodeoffset\r
  *     -FDT_ERR_BADMAGIC,\r
  *     -FDT_ERR_BADVERSION,\r
  *     -FDT_ERR_BADSTATE,\r
  *     -FDT_ERR_BADMAGIC,\r
  *     -FDT_ERR_BADVERSION,\r
  *     -FDT_ERR_BADSTATE,\r
@@ -660,7 +810,7 @@ int fdt_supernode_atdepth_offset(const void *fdt, int nodeoffset,
  *\r
  * returns:\r
  *     depth of the node at nodeoffset (>=0), on success\r
  *\r
  * returns:\r
  *     depth of the node at nodeoffset (>=0), on success\r
- *     -FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag\r
+ *     -FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag\r
  *     -FDT_ERR_BADMAGIC,\r
  *     -FDT_ERR_BADVERSION,\r
  *     -FDT_ERR_BADSTATE,\r
  *     -FDT_ERR_BADMAGIC,\r
  *     -FDT_ERR_BADVERSION,\r
  *     -FDT_ERR_BADSTATE,\r
@@ -683,7 +833,7 @@ int fdt_node_depth(const void *fdt, int nodeoffset);
  * returns:\r
  *     structure block offset of the parent of the node at nodeoffset\r
  *             (>=0), on success\r
  * returns:\r
  *     structure block offset of the parent of the node at nodeoffset\r
  *             (>=0), on success\r
- *     -FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag\r
+ *     -FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag\r
  *     -FDT_ERR_BADMAGIC,\r
  *     -FDT_ERR_BADVERSION,\r
  *     -FDT_ERR_BADSTATE,\r
  *     -FDT_ERR_BADMAGIC,\r
  *     -FDT_ERR_BADVERSION,\r
  *     -FDT_ERR_BADSTATE,\r
@@ -723,7 +873,7 @@ int fdt_parent_offset(const void *fdt, int nodeoffset);
  *              on success\r
  *     -FDT_ERR_NOTFOUND, no node matching the criterion exists in the\r
  *             tree after startoffset\r
  *              on success\r
  *     -FDT_ERR_NOTFOUND, no node matching the criterion exists in the\r
  *             tree after startoffset\r
- *     -FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag\r
+ *     -FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag\r
  *     -FDT_ERR_BADMAGIC,\r
  *     -FDT_ERR_BADVERSION,\r
  *     -FDT_ERR_BADSTATE,\r
  *     -FDT_ERR_BADMAGIC,\r
  *     -FDT_ERR_BADVERSION,\r
  *     -FDT_ERR_BADSTATE,\r
@@ -770,7 +920,7 @@ int fdt_node_offset_by_phandle(const void *fdt, uint32_t phandle);
  *     1, if the node has a 'compatible' property, but it does not list\r
  *             the given string\r
  *     -FDT_ERR_NOTFOUND, if the given node has no 'compatible' property\r
  *     1, if the node has a 'compatible' property, but it does not list\r
  *             the given string\r
  *     -FDT_ERR_NOTFOUND, if the given node has no 'compatible' property\r
- *     -FDT_ERR_BADOFFSET, if nodeoffset does not refer to a BEGIN_NODE tag\r
+ *     -FDT_ERR_BADOFFSET, if nodeoffset does not refer to a BEGIN_NODE tag\r
  *     -FDT_ERR_BADMAGIC,\r
  *     -FDT_ERR_BADVERSION,\r
  *     -FDT_ERR_BADSTATE,\r
  *     -FDT_ERR_BADMAGIC,\r
  *     -FDT_ERR_BADVERSION,\r
  *     -FDT_ERR_BADSTATE,\r
@@ -807,7 +957,7 @@ int fdt_node_check_compatible(const void *fdt, int nodeoffset,
  *              on success\r
  *     -FDT_ERR_NOTFOUND, no node matching the criterion exists in the\r
  *             tree after startoffset\r
  *              on success\r
  *     -FDT_ERR_NOTFOUND, no node matching the criterion exists in the\r
  *             tree after startoffset\r
- *     -FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag\r
+ *     -FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag\r
  *     -FDT_ERR_BADMAGIC,\r
  *     -FDT_ERR_BADVERSION,\r
  *     -FDT_ERR_BADSTATE,\r
  *     -FDT_ERR_BADMAGIC,\r
  *     -FDT_ERR_BADVERSION,\r
  *     -FDT_ERR_BADSTATE,\r
@@ -816,10 +966,166 @@ int fdt_node_check_compatible(const void *fdt, int nodeoffset,
 int fdt_node_offset_by_compatible(const void *fdt, int startoffset,\r
                                  const char *compatible);\r
 \r
 int fdt_node_offset_by_compatible(const void *fdt, int startoffset,\r
                                  const char *compatible);\r
 \r
+/**\r
+ * fdt_stringlist_contains - check a string list property for a string\r
+ * @strlist: Property containing a list of strings to check\r
+ * @listlen: Length of property\r
+ * @str: String to search for\r
+ *\r
+ * This is a utility function provided for convenience. The list contains\r
+ * one or more strings, each terminated by \0, as is found in a device tree\r
+ * "compatible" property.\r
+ *\r
+ * @return: 1 if the string is found in the list, 0 not found, or invalid list\r
+ */\r
+int fdt_stringlist_contains(const char *strlist, int listlen, const char *str);\r
+\r
+/**\r
+ * fdt_stringlist_count - count the number of strings in a string list\r
+ * @fdt: pointer to the device tree blob\r
+ * @nodeoffset: offset of a tree node\r
+ * @property: name of the property containing the string list\r
+ * @return:\r
+ *   the number of strings in the given property\r
+ *   -FDT_ERR_BADVALUE if the property value is not NUL-terminated\r
+ *   -FDT_ERR_NOTFOUND if the property does not exist\r
+ */\r
+int fdt_stringlist_count(const void *fdt, int nodeoffset, const char *property);\r
+\r
+/**\r
+ * fdt_stringlist_search - find a string in a string list and return its index\r
+ * @fdt: pointer to the device tree blob\r
+ * @nodeoffset: offset of a tree node\r
+ * @property: name of the property containing the string list\r
+ * @string: string to look up in the string list\r
+ *\r
+ * Note that it is possible for this function to succeed on property values\r
+ * that are not NUL-terminated. That's because the function will stop after\r
+ * finding the first occurrence of @string. This can for example happen with\r
+ * small-valued cell properties, such as #address-cells, when searching for\r
+ * the empty string.\r
+ *\r
+ * @return:\r
+ *   the index of the string in the list of strings\r
+ *   -FDT_ERR_BADVALUE if the property value is not NUL-terminated\r
+ *   -FDT_ERR_NOTFOUND if the property does not exist or does not contain\r
+ *                     the given string\r
+ */\r
+int fdt_stringlist_search(const void *fdt, int nodeoffset, const char *property,\r
+                         const char *string);\r
+\r
+/**\r
+ * fdt_stringlist_get() - obtain the string at a given index in a string list\r
+ * @fdt: pointer to the device tree blob\r
+ * @nodeoffset: offset of a tree node\r
+ * @property: name of the property containing the string list\r
+ * @index: index of the string to return\r
+ * @lenp: return location for the string length or an error code on failure\r
+ *\r
+ * Note that this will successfully extract strings from properties with\r
+ * non-NUL-terminated values. For example on small-valued cell properties\r
+ * this function will return the empty string.\r
+ *\r
+ * If non-NULL, the length of the string (on success) or a negative error-code\r
+ * (on failure) will be stored in the integer pointer to by lenp.\r
+ *\r
+ * @return:\r
+ *   A pointer to the string at the given index in the string list or NULL on\r
+ *   failure. On success the length of the string will be stored in the memory\r
+ *   location pointed to by the lenp parameter, if non-NULL. On failure one of\r
+ *   the following negative error codes will be returned in the lenp parameter\r
+ *   (if non-NULL):\r
+ *     -FDT_ERR_BADVALUE if the property value is not NUL-terminated\r
+ *     -FDT_ERR_NOTFOUND if the property does not exist\r
+ */\r
+const char *fdt_stringlist_get(const void *fdt, int nodeoffset,\r
+                              const char *property, int index,\r
+                              int *lenp);\r
+\r
+/**********************************************************************/\r
+/* Read-only functions (addressing related)                           */\r
+/**********************************************************************/\r
+\r
+/**\r
+ * FDT_MAX_NCELLS - maximum value for #address-cells and #size-cells\r
+ *\r
+ * This is the maximum value for #address-cells, #size-cells and\r
+ * similar properties that will be processed by libfdt.  IEE1275\r
+ * requires that OF implementations handle values up to 4.\r
+ * Implementations may support larger values, but in practice higher\r
+ * values aren't used.\r
+ */\r
+#define FDT_MAX_NCELLS         4\r
+\r
+/**\r
+ * fdt_address_cells - retrieve address size for a bus represented in the tree\r
+ * @fdt: pointer to the device tree blob\r
+ * @nodeoffset: offset of the node to find the address size for\r
+ *\r
+ * When the node has a valid #address-cells property, returns its value.\r
+ *\r
+ * returns:\r
+ *     0 <= n < FDT_MAX_NCELLS, on success\r
+ *      2, if the node has no #address-cells property\r
+ *      -FDT_ERR_BADNCELLS, if the node has a badly formatted or invalid\r
+ *             #address-cells property\r
+ *     -FDT_ERR_BADMAGIC,\r
+ *     -FDT_ERR_BADVERSION,\r
+ *     -FDT_ERR_BADSTATE,\r
+ *     -FDT_ERR_BADSTRUCTURE,\r
+ *     -FDT_ERR_TRUNCATED, standard meanings\r
+ */\r
+int fdt_address_cells(const void *fdt, int nodeoffset);\r
+\r
+/**\r
+ * fdt_size_cells - retrieve address range size for a bus represented in the\r
+ *                  tree\r
+ * @fdt: pointer to the device tree blob\r
+ * @nodeoffset: offset of the node to find the address range size for\r
+ *\r
+ * When the node has a valid #size-cells property, returns its value.\r
+ *\r
+ * returns:\r
+ *     0 <= n < FDT_MAX_NCELLS, on success\r
+ *      2, if the node has no #address-cells property\r
+ *      -FDT_ERR_BADNCELLS, if the node has a badly formatted or invalid\r
+ *             #size-cells property\r
+ *     -FDT_ERR_BADMAGIC,\r
+ *     -FDT_ERR_BADVERSION,\r
+ *     -FDT_ERR_BADSTATE,\r
+ *     -FDT_ERR_BADSTRUCTURE,\r
+ *     -FDT_ERR_TRUNCATED, standard meanings\r
+ */\r
+int fdt_size_cells(const void *fdt, int nodeoffset);\r
+\r
+\r
 /**********************************************************************/\r
 /* Write-in-place functions                                           */\r
 /**********************************************************************/\r
 \r
 /**********************************************************************/\r
 /* Write-in-place functions                                           */\r
 /**********************************************************************/\r
 \r
+/**\r
+ * fdt_setprop_inplace_namelen_partial - change a property's value,\r
+ *                                       but not its size\r
+ * @fdt: pointer to the device tree blob\r
+ * @nodeoffset: offset of the node whose property to change\r
+ * @name: name of the property to change\r
+ * @namelen: number of characters of name to consider\r
+ * @idx: index of the property to change in the array\r
+ * @val: pointer to data to replace the property value with\r
+ * @len: length of the property value\r
+ *\r
+ * Identical to fdt_setprop_inplace(), but modifies the given property\r
+ * starting from the given index, and using only the first characters\r
+ * of the name. It is useful when you want to manipulate only one value of\r
+ * an array and you have a string that doesn't end with \0.\r
+ */\r
+#ifndef SWIG /* Not available in Python */\r
+int fdt_setprop_inplace_namelen_partial(void *fdt, int nodeoffset,\r
+                                       const char *name, int namelen,\r
+                                       uint32_t idx, const void *val,\r
+                                       int len);\r
+#endif\r
+\r
 /**\r
  * fdt_setprop_inplace - change a property's value, but not its size\r
  * @fdt: pointer to the device tree blob\r
 /**\r
  * fdt_setprop_inplace - change a property's value, but not its size\r
  * @fdt: pointer to the device tree blob\r
@@ -848,8 +1154,10 @@ int fdt_node_offset_by_compatible(const void *fdt, int startoffset,
  *     -FDT_ERR_BADSTRUCTURE,\r
  *     -FDT_ERR_TRUNCATED, standard meanings\r
  */\r
  *     -FDT_ERR_BADSTRUCTURE,\r
  *     -FDT_ERR_TRUNCATED, standard meanings\r
  */\r
+#ifndef SWIG /* Not available in Python */\r
 int fdt_setprop_inplace(void *fdt, int nodeoffset, const char *name,\r
                        const void *val, int len);\r
 int fdt_setprop_inplace(void *fdt, int nodeoffset, const char *name,\r
                        const void *val, int len);\r
+#endif\r
 \r
 /**\r
  * fdt_setprop_inplace_u32 - change the value of a 32-bit integer property\r
 \r
 /**\r
  * fdt_setprop_inplace_u32 - change the value of a 32-bit integer property\r
@@ -882,8 +1190,8 @@ int fdt_setprop_inplace(void *fdt, int nodeoffset, const char *name,
 static inline int fdt_setprop_inplace_u32(void *fdt, int nodeoffset,\r
                                          const char *name, uint32_t val)\r
 {\r
 static inline int fdt_setprop_inplace_u32(void *fdt, int nodeoffset,\r
                                          const char *name, uint32_t val)\r
 {\r
-       val = cpu_to_fdt32(val);\r
-       return fdt_setprop_inplace(fdt, nodeoffset, name, &val, sizeof(val));\r
+       fdt32_t tmp = cpu_to_fdt32(val);\r
+       return fdt_setprop_inplace(fdt, nodeoffset, name, &tmp, sizeof(tmp));\r
 }\r
 \r
 /**\r
 }\r
 \r
 /**\r
@@ -917,8 +1225,8 @@ static inline int fdt_setprop_inplace_u32(void *fdt, int nodeoffset,
 static inline int fdt_setprop_inplace_u64(void *fdt, int nodeoffset,\r
                                          const char *name, uint64_t val)\r
 {\r
 static inline int fdt_setprop_inplace_u64(void *fdt, int nodeoffset,\r
                                          const char *name, uint64_t val)\r
 {\r
-       val = cpu_to_fdt64(val);\r
-       return fdt_setprop_inplace(fdt, nodeoffset, name, &val, sizeof(val));\r
+       fdt64_t tmp = cpu_to_fdt64(val);\r
+       return fdt_setprop_inplace(fdt, nodeoffset, name, &tmp, sizeof(tmp));\r
 }\r
 \r
 /**\r
 }\r
 \r
 /**\r
@@ -987,24 +1295,41 @@ int fdt_nop_node(void *fdt, int nodeoffset);
 /**********************************************************************/\r
 \r
 int fdt_create(void *buf, int bufsize);\r
 /**********************************************************************/\r
 \r
 int fdt_create(void *buf, int bufsize);\r
+int fdt_resize(void *fdt, void *buf, int bufsize);\r
 int fdt_add_reservemap_entry(void *fdt, uint64_t addr, uint64_t size);\r
 int fdt_finish_reservemap(void *fdt);\r
 int fdt_begin_node(void *fdt, const char *name);\r
 int fdt_property(void *fdt, const char *name, const void *val, int len);\r
 static inline int fdt_property_u32(void *fdt, const char *name, uint32_t val)\r
 {\r
 int fdt_add_reservemap_entry(void *fdt, uint64_t addr, uint64_t size);\r
 int fdt_finish_reservemap(void *fdt);\r
 int fdt_begin_node(void *fdt, const char *name);\r
 int fdt_property(void *fdt, const char *name, const void *val, int len);\r
 static inline int fdt_property_u32(void *fdt, const char *name, uint32_t val)\r
 {\r
-       val = cpu_to_fdt32(val);\r
-       return fdt_property(fdt, name, &val, sizeof(val));\r
+       fdt32_t tmp = cpu_to_fdt32(val);\r
+       return fdt_property(fdt, name, &tmp, sizeof(tmp));\r
 }\r
 static inline int fdt_property_u64(void *fdt, const char *name, uint64_t val)\r
 {\r
 }\r
 static inline int fdt_property_u64(void *fdt, const char *name, uint64_t val)\r
 {\r
-       val = cpu_to_fdt64(val);\r
-       return fdt_property(fdt, name, &val, sizeof(val));\r
+       fdt64_t tmp = cpu_to_fdt64(val);\r
+       return fdt_property(fdt, name, &tmp, sizeof(tmp));\r
 }\r
 static inline int fdt_property_cell(void *fdt, const char *name, uint32_t val)\r
 {\r
        return fdt_property_u32(fdt, name, val);\r
 }\r
 }\r
 static inline int fdt_property_cell(void *fdt, const char *name, uint32_t val)\r
 {\r
        return fdt_property_u32(fdt, name, val);\r
 }\r
+\r
+/**\r
+ * fdt_property_placeholder - add a new property and return a ptr to its value\r
+ *\r
+ * @fdt: pointer to the device tree blob\r
+ * @name: name of property to add\r
+ * @len: length of property value in bytes\r
+ * @valp: returns a pointer to where where the value should be placed\r
+ *\r
+ * returns:\r
+ *     0, on success\r
+ *     -FDT_ERR_BADMAGIC,\r
+ *     -FDT_ERR_NOSPACE, standard meanings\r
+ */\r
+int fdt_property_placeholder(void *fdt, const char *name, int len, void **valp);\r
+\r
 #define fdt_property_string(fdt, name, str) \\r
        fdt_property(fdt, name, str, strlen(str)+1)\r
 int fdt_end_node(void *fdt);\r
 #define fdt_property_string(fdt, name, str) \\r
        fdt_property(fdt, name, str, strlen(str)+1)\r
 int fdt_end_node(void *fdt);\r
@@ -1123,6 +1448,37 @@ int fdt_set_name(void *fdt, int nodeoffset, const char *name);
 int fdt_setprop(void *fdt, int nodeoffset, const char *name,\r
                const void *val, int len);\r
 \r
 int fdt_setprop(void *fdt, int nodeoffset, const char *name,\r
                const void *val, int len);\r
 \r
+/**\r
+ * fdt_setprop _placeholder - allocate space for a property\r
+ * @fdt: pointer to the device tree blob\r
+ * @nodeoffset: offset of the node whose property to change\r
+ * @name: name of the property to change\r
+ * @len: length of the property value\r
+ * @prop_data: return pointer to property data\r
+ *\r
+ * fdt_setprop_placeholer() allocates the named property in the given node.\r
+ * If the property exists it is resized. In either case a pointer to the\r
+ * property data is returned.\r
+ *\r
+ * This function may insert or delete data from the blob, and will\r
+ * therefore change the offsets of some existing nodes.\r
+ *\r
+ * returns:\r
+ *     0, on success\r
+ *     -FDT_ERR_NOSPACE, there is insufficient free space in the blob to\r
+ *             contain the new property value\r
+ *     -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag\r
+ *     -FDT_ERR_BADLAYOUT,\r
+ *     -FDT_ERR_BADMAGIC,\r
+ *     -FDT_ERR_BADVERSION,\r
+ *     -FDT_ERR_BADSTATE,\r
+ *     -FDT_ERR_BADSTRUCTURE,\r
+ *     -FDT_ERR_BADLAYOUT,\r
+ *     -FDT_ERR_TRUNCATED, standard meanings\r
+ */\r
+int fdt_setprop_placeholder(void *fdt, int nodeoffset, const char *name,\r
+                           int len, void **prop_data);\r
+\r
 /**\r
  * fdt_setprop_u32 - set a property to a 32-bit integer\r
  * @fdt: pointer to the device tree blob\r
 /**\r
  * fdt_setprop_u32 - set a property to a 32-bit integer\r
  * @fdt: pointer to the device tree blob\r
@@ -1154,8 +1510,8 @@ int fdt_setprop(void *fdt, int nodeoffset, const char *name,
 static inline int fdt_setprop_u32(void *fdt, int nodeoffset, const char *name,\r
                                  uint32_t val)\r
 {\r
 static inline int fdt_setprop_u32(void *fdt, int nodeoffset, const char *name,\r
                                  uint32_t val)\r
 {\r
-       val = cpu_to_fdt32(val);\r
-       return fdt_setprop(fdt, nodeoffset, name, &val, sizeof(val));\r
+       fdt32_t tmp = cpu_to_fdt32(val);\r
+       return fdt_setprop(fdt, nodeoffset, name, &tmp, sizeof(tmp));\r
 }\r
 \r
 /**\r
 }\r
 \r
 /**\r
@@ -1189,8 +1545,8 @@ static inline int fdt_setprop_u32(void *fdt, int nodeoffset, const char *name,
 static inline int fdt_setprop_u64(void *fdt, int nodeoffset, const char *name,\r
                                  uint64_t val)\r
 {\r
 static inline int fdt_setprop_u64(void *fdt, int nodeoffset, const char *name,\r
                                  uint64_t val)\r
 {\r
-       val = cpu_to_fdt64(val);\r
-       return fdt_setprop(fdt, nodeoffset, name, &val, sizeof(val));\r
+       fdt64_t tmp = cpu_to_fdt64(val);\r
+       return fdt_setprop(fdt, nodeoffset, name, &tmp, sizeof(tmp));\r
 }\r
 \r
 /**\r
 }\r
 \r
 /**\r
@@ -1235,6 +1591,36 @@ static inline int fdt_setprop_cell(void *fdt, int nodeoffset, const char *name,
 #define fdt_setprop_string(fdt, nodeoffset, name, str) \\r
        fdt_setprop((fdt), (nodeoffset), (name), (str), strlen(str)+1)\r
 \r
 #define fdt_setprop_string(fdt, nodeoffset, name, str) \\r
        fdt_setprop((fdt), (nodeoffset), (name), (str), strlen(str)+1)\r
 \r
+\r
+/**\r
+ * fdt_setprop_empty - set a property to an empty value\r
+ * @fdt: pointer to the device tree blob\r
+ * @nodeoffset: offset of the node whose property to change\r
+ * @name: name of the property to change\r
+ *\r
+ * fdt_setprop_empty() sets the value of the named property in the\r
+ * given node to an empty (zero length) value, or creates a new empty\r
+ * property if it does not already exist.\r
+ *\r
+ * This function may insert or delete data from the blob, and will\r
+ * therefore change the offsets of some existing nodes.\r
+ *\r
+ * returns:\r
+ *     0, on success\r
+ *     -FDT_ERR_NOSPACE, there is insufficient free space in the blob to\r
+ *             contain the new property value\r
+ *     -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag\r
+ *     -FDT_ERR_BADLAYOUT,\r
+ *     -FDT_ERR_BADMAGIC,\r
+ *     -FDT_ERR_BADVERSION,\r
+ *     -FDT_ERR_BADSTATE,\r
+ *     -FDT_ERR_BADSTRUCTURE,\r
+ *     -FDT_ERR_BADLAYOUT,\r
+ *     -FDT_ERR_TRUNCATED, standard meanings\r
+ */\r
+#define fdt_setprop_empty(fdt, nodeoffset, name) \\r
+       fdt_setprop((fdt), (nodeoffset), (name), NULL, 0)\r
+\r
 /**\r
  * fdt_appendprop - append to or create a property\r
  * @fdt: pointer to the device tree blob\r
 /**\r
  * fdt_appendprop - append to or create a property\r
  * @fdt: pointer to the device tree blob\r
@@ -1296,8 +1682,8 @@ int fdt_appendprop(void *fdt, int nodeoffset, const char *name,
 static inline int fdt_appendprop_u32(void *fdt, int nodeoffset,\r
                                     const char *name, uint32_t val)\r
 {\r
 static inline int fdt_appendprop_u32(void *fdt, int nodeoffset,\r
                                     const char *name, uint32_t val)\r
 {\r
-       val = cpu_to_fdt32(val);\r
-       return fdt_appendprop(fdt, nodeoffset, name, &val, sizeof(val));\r
+       fdt32_t tmp = cpu_to_fdt32(val);\r
+       return fdt_appendprop(fdt, nodeoffset, name, &tmp, sizeof(tmp));\r
 }\r
 \r
 /**\r
 }\r
 \r
 /**\r
@@ -1331,8 +1717,8 @@ static inline int fdt_appendprop_u32(void *fdt, int nodeoffset,
 static inline int fdt_appendprop_u64(void *fdt, int nodeoffset,\r
                                     const char *name, uint64_t val)\r
 {\r
 static inline int fdt_appendprop_u64(void *fdt, int nodeoffset,\r
                                     const char *name, uint64_t val)\r
 {\r
-       val = cpu_to_fdt64(val);\r
-       return fdt_appendprop(fdt, nodeoffset, name, &val, sizeof(val));\r
+       fdt64_t tmp = cpu_to_fdt64(val);\r
+       return fdt_appendprop(fdt, nodeoffset, name, &tmp, sizeof(tmp));\r
 }\r
 \r
 /**\r
 }\r
 \r
 /**\r
@@ -1412,8 +1798,10 @@ int fdt_delprop(void *fdt, int nodeoffset, const char *name);
  * creating subnodes based on a portion of a larger string, such as a\r
  * full path.\r
  */\r
  * creating subnodes based on a portion of a larger string, such as a\r
  * full path.\r
  */\r
+#ifndef SWIG /* Not available in Python */\r
 int fdt_add_subnode_namelen(void *fdt, int parentoffset,\r
                            const char *name, int namelen);\r
 int fdt_add_subnode_namelen(void *fdt, int parentoffset,\r
                            const char *name, int namelen);\r
+#endif\r
 \r
 /**\r
  * fdt_add_subnode - creates a new node\r
 \r
 /**\r
  * fdt_add_subnode - creates a new node\r
@@ -1429,9 +1817,11 @@ int fdt_add_subnode_namelen(void *fdt, int parentoffset,
  * change the offsets of some existing nodes.\r
 \r
  * returns:\r
  * change the offsets of some existing nodes.\r
 \r
  * returns:\r
- *     structure block offset of the created nodeequested subnode (>=0), on success\r
+ *     structure block offset of the created nodeequested subnode (>=0), on\r
+ *             success\r
  *     -FDT_ERR_NOTFOUND, if the requested subnode does not exist\r
  *     -FDT_ERR_NOTFOUND, if the requested subnode does not exist\r
- *     -FDT_ERR_BADOFFSET, if parentoffset did not point to an FDT_BEGIN_NODE tag\r
+ *     -FDT_ERR_BADOFFSET, if parentoffset did not point to an FDT_BEGIN_NODE\r
+ *             tag\r
  *     -FDT_ERR_EXISTS, if the node at parentoffset already has a subnode of\r
  *             the given name\r
  *     -FDT_ERR_NOSPACE, if there is insufficient free space in the\r
  *     -FDT_ERR_EXISTS, if the node at parentoffset already has a subnode of\r
  *             the given name\r
  *     -FDT_ERR_NOSPACE, if there is insufficient free space in the\r
@@ -1469,6 +1859,37 @@ int fdt_add_subnode(void *fdt, int parentoffset, const char *name);
  */\r
 int fdt_del_node(void *fdt, int nodeoffset);\r
 \r
  */\r
 int fdt_del_node(void *fdt, int nodeoffset);\r
 \r
+/**\r
+ * fdt_overlay_apply - Applies a DT overlay on a base DT\r
+ * @fdt: pointer to the base device tree blob\r
+ * @fdto: pointer to the device tree overlay blob\r
+ *\r
+ * fdt_overlay_apply() will apply the given device tree overlay on the\r
+ * given base device tree.\r
+ *\r
+ * Expect the base device tree to be modified, even if the function\r
+ * returns an error.\r
+ *\r
+ * returns:\r
+ *     0, on success\r
+ *     -FDT_ERR_NOSPACE, there's not enough space in the base device tree\r
+ *     -FDT_ERR_NOTFOUND, the overlay points to some inexistant nodes or\r
+ *             properties in the base DT\r
+ *     -FDT_ERR_BADPHANDLE,\r
+ *     -FDT_ERR_BADOVERLAY,\r
+ *     -FDT_ERR_NOPHANDLES,\r
+ *     -FDT_ERR_INTERNAL,\r
+ *     -FDT_ERR_BADLAYOUT,\r
+ *     -FDT_ERR_BADMAGIC,\r
+ *     -FDT_ERR_BADOFFSET,\r
+ *     -FDT_ERR_BADPATH,\r
+ *     -FDT_ERR_BADVERSION,\r
+ *     -FDT_ERR_BADSTRUCTURE,\r
+ *     -FDT_ERR_BADSTATE,\r
+ *     -FDT_ERR_TRUNCATED, standard meanings\r
+ */\r
+int fdt_overlay_apply(void *fdt, void *fdto);\r
+\r
 /**********************************************************************/\r
 /* Debugging / informational functions                                */\r
 /**********************************************************************/\r
 /**********************************************************************/\r
 /* Debugging / informational functions                                */\r
 /**********************************************************************/\r