[FDT] Fix POSIX compatibility for string.h (#6923)

* [FDT] Fix POSIX compatibility for string.h

* [FDT] format libfdt code.

* [FDT] format libfdt code.

6 files changed, 716 insertions, 710 deletions

diff --git a/components/drivers/fdt/inc/dtb_node.h b/components/drivers/fdt/inc/dtb_node.h
index cc5aa1de49..b42e101dee 100644
--- a/components/drivers/fdt/inc/dtb_node.h
+++ b/components/drivers/fdt/inc/dtb_node.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2021, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -201,11 +201,11 @@ int dtb_node_property_read_string_helper(const struct dtb_node *dn,
 /**
  * of_property_read_string_index() - Find and read a string from a multiple
  * strings property.
- * @np:		device node from which the property value is to be read.
- * @propname:	name of the property to be searched.
- * @index:	index of the string in the list of strings
- * @out_string:	pointer to null terminated return string, modified only if
- *		return value is 0.
+ * @np:     device node from which the property value is to be read.
+ * @propname:   name of the property to be searched.
+ * @index:  index of the string in the list of strings
+ * @out_string: pointer to null terminated return string, modified only if
+ *      return value is 0.
  *
  * Search for a property in a device tree node and retrieve a null
  * terminated string value (pointer to data, not a copy) in the list of strings
@@ -227,8 +227,8 @@ static inline int dtb_node_property_read_string_index(const struct dtb_node *dn,
 /**
  * of_property_count_strings() - Find and return the number of strings from a
  * multiple strings property.
- * @np:		device node from which the property value is to be read.
- * @propname:	name of the property to be searched.
+ * @np:     device node from which the property value is to be read.
+ * @propname:   name of the property to be searched.
  *
  * Search for a property in a device tree node and retrieve the number of null
  * terminated string contain in it. Returns the number of strings on
diff --git a/components/drivers/fdt/libfdt/libfdt.h b/components/drivers/fdt/libfdt/libfdt.h
index 05de18d721..8593f10ae8 100644
--- a/components/drivers/fdt/libfdt/libfdt.h
+++ b/components/drivers/fdt/libfdt/libfdt.h
@@ -54,90 +54,97 @@
 #include "libfdt_env.h"
 #include "fdt.h"
 
-#define FDT_FIRST_SUPPORTED_VERSION	0x10
-#define FDT_LAST_SUPPORTED_VERSION	0x11
+#define FDT_FIRST_SUPPORTED_VERSION 0x10
+#define FDT_LAST_SUPPORTED_VERSION  0x11
 
 /* Error codes: informative error codes */
-#define FDT_ERR_NOTFOUND	1
-	/* FDT_ERR_NOTFOUND: The requested node or property does not exist */
-#define FDT_ERR_EXISTS		2
-	/* FDT_ERR_EXISTS: Attempted to create a node or property which
-	 * already exists */
-#define FDT_ERR_NOSPACE		3
-	/* FDT_ERR_NOSPACE: Operation needed to expand the device
-	 * tree, but its buffer did not have sufficient space to
-	 * contain the expanded tree. Use fdt_open_into() to move the
-	 * device tree to a buffer with more space. */
+#define FDT_ERR_NOTFOUND    1
+    /* FDT_ERR_NOTFOUND: The requested node or property does not exist */
+#define FDT_ERR_EXISTS      2
+    /* FDT_ERR_EXISTS: Attempted to create a node or property which
+     * already exists */
+#define FDT_ERR_NOSPACE     3
+    /* FDT_ERR_NOSPACE: Operation needed to expand the device
+     * tree, but its buffer did not have sufficient space to
+     * contain the expanded tree. Use fdt_open_into() to move the
+     * device tree to a buffer with more space. */
 
 /* Error codes: codes for bad parameters */
-#define FDT_ERR_BADOFFSET	4
-	/* FDT_ERR_BADOFFSET: Function was passed a structure block
-	 * offset which is out-of-bounds, or which points to an
-	 * unsuitable part of the structure for the operation. */
-#define FDT_ERR_BADPATH		5
-	/* FDT_ERR_BADPATH: Function was passed a badly formatted path
-	 * (e.g. missing a leading / for a function which requires an
-	 * absolute path) */
-#define FDT_ERR_BADPHANDLE	6
-	/* FDT_ERR_BADPHANDLE: Function was passed an invalid phandle.
-	 * This can be caused either by an invalid phandle property
-	 * length, or the phandle value was either 0 or -1, which are
-	 * not permitted. */
-#define FDT_ERR_BADSTATE	7
-	/* FDT_ERR_BADSTATE: Function was passed an incomplete device
-	 * tree created by the sequential-write functions, which is
-	 * not sufficiently complete for the requested operation. */
+#define FDT_ERR_BADOFFSET   4
+    /* FDT_ERR_BADOFFSET: Function was passed a structure block
+     * offset which is out-of-bounds, or which points to an
+     * unsuitable part of the structure for the operation. */
+#define FDT_ERR_BADPATH     5
+    /* FDT_ERR_BADPATH: Function was passed a badly formatted path
+     * (e.g. missing a leading / for a function which requires an
+     * absolute path) */
+#define FDT_ERR_BADPHANDLE  6
+    /* FDT_ERR_BADPHANDLE: Function was passed an invalid phandle.
+     * This can be caused either by an invalid phandle property
+     * length, or the phandle value was either 0 or -1, which are
+     * not permitted. */
+#define FDT_ERR_BADSTATE    7
+    /* FDT_ERR_BADSTATE: Function was passed an incomplete device
+     * tree created by the sequential-write functions, which is
+     * not sufficiently complete for the requested operation. */
 
 /* Error codes: codes for bad device tree blobs */
-#define FDT_ERR_TRUNCATED	8
-	/* FDT_ERR_TRUNCATED: Structure block of the given device tree
-	 * ends without an FDT_END tag. */
-#define FDT_ERR_BADMAGIC	9
-	/* FDT_ERR_BADMAGIC: Given "device tree" appears not to be a
-	 * device tree at all - it is missing the flattened device
-	 * tree magic number. */
-#define FDT_ERR_BADVERSION	10
-	/* FDT_ERR_BADVERSION: Given device tree has a version which
-	 * can't be handled by the requested operation.  For
-	 * read-write functions, this may mean that fdt_open_into() is
-	 * required to convert the tree to the expected version. */
-#define FDT_ERR_BADSTRUCTURE	11
-	/* FDT_ERR_BADSTRUCTURE: Given device tree has a corrupt
-	 * structure block or other serious error (e.g. misnested
-	 * nodes, or subnodes preceding properties). */
-#define FDT_ERR_BADLAYOUT	12
-	/* FDT_ERR_BADLAYOUT: For read-write functions, the given
-	 * device tree has it's sub-blocks in an order that the
-	 * function can't handle (memory reserve map, then structure,
-	 * then strings).  Use fdt_open_into() to reorganize the tree
-	 * into a form suitable for the read-write operations. */
+#define FDT_ERR_TRUNCATED   8
+    /* FDT_ERR_TRUNCATED: Structure block of the given device tree
+     * ends without an FDT_END tag. */
+#define FDT_ERR_BADMAGIC    9
+    /* FDT_ERR_BADMAGIC: Given "device tree" appears not to be a
+     * device tree at all - it is missing the flattened device
+     * tree magic number. */
+#define FDT_ERR_BADVERSION  10
+    /* FDT_ERR_BADVERSION: Given device tree has a version which
+     * can't be handled by the requested operation.  For
+     * read-write functions, this may mean that fdt_open_into() is
+     * required to convert the tree to the expected version. */
+#define FDT_ERR_BADSTRUCTURE    11
+    /* FDT_ERR_BADSTRUCTURE: Given device tree has a corrupt
+     * structure block or other serious error (e.g. misnested
+     * nodes, or subnodes preceding properties). */
+#define FDT_ERR_BADLAYOUT   12
+    /* FDT_ERR_BADLAYOUT: For read-write functions, the given
+     * device tree has it's sub-blocks in an order that the
+     * function can't handle (memory reserve map, then structure,
+     * then strings).  Use fdt_open_into() to reorganize the tree
+     * into a form suitable for the read-write operations. */
 
 /* "Can't happen" error indicating a bug in libfdt */
-#define FDT_ERR_INTERNAL	13
-	/* FDT_ERR_INTERNAL: libfdt has failed an internal assertion.
-	 * Should never be returned, if it is, it indicates a bug in
-	 * libfdt itself. */
+#define FDT_ERR_INTERNAL    13
+    /* FDT_ERR_INTERNAL: libfdt has failed an internal assertion.
+     * Should never be returned, if it is, it indicates a bug in
+     * libfdt itself. */
 
 /* Errors in device tree content */
-#define FDT_ERR_BADNCELLS	14
-	/* FDT_ERR_BADNCELLS: Device tree has a #address-cells, #size-cells
-	 * or similar property with a bad format or value */
+#define FDT_ERR_BADNCELLS   14
+    /* FDT_ERR_BADNCELLS: Device tree has a #address-cells, #size-cells
+     * or similar property with a bad format or value */
 
-#define FDT_ERR_BADVALUE	15
-	/* FDT_ERR_BADVALUE: Device tree has a property with an unexpected
-	 * value. For example: a property expected to contain a string list
-	 * is not NUL-terminated within the length of its value. */
+#define FDT_ERR_BADVALUE    15
+    /* FDT_ERR_BADVALUE: Device tree has a property with an unexpected
+     * value. For example: a property expected to contain a string list
+     * is not NUL-terminated within the length of its value. */
 
-#define FDT_ERR_BADOVERLAY	16
-	/* FDT_ERR_BADOVERLAY: The device tree overlay, while
-	 * correctly structured, cannot be applied due to some
-	 * unexpected or missing value, property or node. */
+#define FDT_ERR_BADOVERLAY  16
+    /* FDT_ERR_BADOVERLAY: The device tree overlay, while
+     * correctly structured, cannot be applied due to some
+     * unexpected or missing value, property or node. */
 
-#define FDT_ERR_NOPHANDLES	17
-	/* FDT_ERR_NOPHANDLES: The device tree doesn't have any
-	 * phandle available anymore without causing an overflow */
+#define FDT_ERR_NOPHANDLES  17
+    /* FDT_ERR_NOPHANDLES: The device tree doesn't have any
+     * phandle available anymore without causing an overflow */
 
-#define FDT_ERR_MAX		17
+#define FDT_ERR_MAX     17
+
+/* string.h for POSIX compatibility */
+#include <string.h>
+typedef unsigned int uint;
+size_t strnlen (const char *, size_t);
+char *strdup (const char *);
+char *strchrnul (const char *, int);
 
 /**********************************************************************/
 /* Low-level functions (you probably don't need these)                */
@@ -148,7 +155,7 @@ const void *fdt_offset_ptr(const void *fdt, int offset, unsigned int checklen);
 #endif
 static inline void *fdt_offset_ptr_w(void *fdt, int offset, int checklen)
 {
-	return (void *)(uintptr_t)fdt_offset_ptr(fdt, offset, checklen);
+    return (void *)(uintptr_t)fdt_offset_ptr(fdt, offset, checklen);
 }
 
 uint32_t fdt_next_tag(const void *fdt, int offset, int *nextoffset);
@@ -186,8 +193,8 @@ int fdt_next_node(const void *fdt, int offset, int *depth);
 /**
  * fdt_first_subnode() - get offset of first direct subnode
  *
- * @fdt:	FDT blob
- * @offset:	Offset of node to check
+ * @fdt:    FDT blob
+ * @offset: Offset of node to check
  * @return offset of first subnode, or -FDT_ERR_NOTFOUND if there is none
  */
 int fdt_first_subnode(const void *fdt, int offset);
@@ -198,8 +205,8 @@ int fdt_first_subnode(const void *fdt, int offset);
  * After first calling fdt_first_subnode(), call this function repeatedly to
  * get direct subnodes of a parent node.
  *
- * @fdt:	FDT blob
- * @offset:	Offset of previous subnode
+ * @fdt:    FDT blob
+ * @offset: Offset of previous subnode
  * @return offset of next subnode, or -FDT_ERR_NOTFOUND if there are no more
  * subnodes
  */
@@ -208,53 +215,53 @@ int fdt_next_subnode(const void *fdt, int offset);
 /**
  * fdt_for_each_subnode - iterate over all subnodes of a parent
  *
- * @node:	child node (int, lvalue)
- * @fdt:	FDT blob (const void *)
- * @parent:	parent node (int)
+ * @node:   child node (int, lvalue)
+ * @fdt:    FDT blob (const void *)
+ * @parent: parent node (int)
  *
  * This is actually a wrapper around a for loop and would be used like so:
  *
- *	fdt_for_each_subnode(node, fdt, parent) {
- *		Use node
- *		...
- *	}
+ *  fdt_for_each_subnode(node, fdt, parent) {
+ *      Use node
+ *      ...
+ *  }
  *
- *	if ((node < 0) && (node != -FDT_ERR_NOT_FOUND)) {
- *		Error handling
- *	}
+ *  if ((node < 0) && (node != -FDT_ERR_NOT_FOUND)) {
+ *      Error handling
+ *  }
  *
  * Note that this is implemented as a macro and @node is used as
  * iterator in the loop. The parent variable be constant or even a
  * literal.
  *
  */
-#define fdt_for_each_subnode(node, fdt, parent)		\
-	for (node = fdt_first_subnode(fdt, parent);	\
-	     node >= 0;					\
-	     node = fdt_next_subnode(fdt, node))
+#define fdt_for_each_subnode(node, fdt, parent)     \
+    for (node = fdt_first_subnode(fdt, parent); \
+         node >= 0;                 \
+         node = fdt_next_subnode(fdt, node))
 
 /**********************************************************************/
 /* General functions                                                  */
 /**********************************************************************/
 #define fdt_get_header(fdt, field) \
-	(fdt32_to_cpu(((const struct fdt_header *)(fdt))->field))
-#define fdt_magic(fdt)			(fdt_get_header(fdt, magic))
-#define fdt_totalsize(fdt)		(fdt_get_header(fdt, totalsize))
-#define fdt_off_dt_struct(fdt)		(fdt_get_header(fdt, off_dt_struct))
-#define fdt_off_dt_strings(fdt)		(fdt_get_header(fdt, off_dt_strings))
-#define fdt_off_mem_rsvmap(fdt)		(fdt_get_header(fdt, off_mem_rsvmap))
-#define fdt_version(fdt)		(fdt_get_header(fdt, version))
-#define fdt_last_comp_version(fdt)	(fdt_get_header(fdt, last_comp_version))
-#define fdt_boot_cpuid_phys(fdt)	(fdt_get_header(fdt, boot_cpuid_phys))
-#define fdt_size_dt_strings(fdt)	(fdt_get_header(fdt, size_dt_strings))
-#define fdt_size_dt_struct(fdt)		(fdt_get_header(fdt, size_dt_struct))
+    (fdt32_to_cpu(((const struct fdt_header *)(fdt))->field))
+#define fdt_magic(fdt)          (fdt_get_header(fdt, magic))
+#define fdt_totalsize(fdt)      (fdt_get_header(fdt, totalsize))
+#define fdt_off_dt_struct(fdt)      (fdt_get_header(fdt, off_dt_struct))
+#define fdt_off_dt_strings(fdt)     (fdt_get_header(fdt, off_dt_strings))
+#define fdt_off_mem_rsvmap(fdt)     (fdt_get_header(fdt, off_mem_rsvmap))
+#define fdt_version(fdt)        (fdt_get_header(fdt, version))
+#define fdt_last_comp_version(fdt)  (fdt_get_header(fdt, last_comp_version))
+#define fdt_boot_cpuid_phys(fdt)    (fdt_get_header(fdt, boot_cpuid_phys))
+#define fdt_size_dt_strings(fdt)    (fdt_get_header(fdt, size_dt_strings))
+#define fdt_size_dt_struct(fdt)     (fdt_get_header(fdt, size_dt_struct))
 
 #define __fdt_set_hdr(name) \
-	static inline void fdt_set_##name(void *fdt, uint32_t val) \
-	{ \
-		struct fdt_header *fdth = (struct fdt_header *)fdt; \
-		fdth->name = cpu_to_fdt32(val); \
-	}
+    static inline void fdt_set_##name(void *fdt, uint32_t val) \
+    { \
+        struct fdt_header *fdth = (struct fdt_header *)fdt; \
+        fdth->name = cpu_to_fdt32(val); \
+    }
 __fdt_set_hdr(magic);
 __fdt_set_hdr(totalsize);
 __fdt_set_hdr(off_dt_struct);
@@ -381,7 +388,7 @@ int fdt_get_mem_rsv(const void *fdt, int n, uint64_t *address, uint64_t *size);
  */
 #ifndef SWIG /* Not available in Python */
 int fdt_subnode_offset_namelen(const void *fdt, int parentoffset,
-			       const char *name, int namelen);
+                   const char *name, int namelen);
 #endif
 /**
  * fdt_subnode_offset - find a subnode of a given node
@@ -397,15 +404,15 @@ int fdt_subnode_offset_namelen(const void *fdt, int parentoffset,
  * whose name excluding unit address matches the given name.
  *
  * returns:
- *	structure block offset of the requested subnode (>=0), on success
- *	-FDT_ERR_NOTFOUND, if the requested subnode does not exist
- *	-FDT_ERR_BADOFFSET, if parentoffset did not point to an FDT_BEGIN_NODE
- *		tag
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_TRUNCATED, standard meanings.
+ *  structure block offset of the requested subnode (>=0), on success
+ *  -FDT_ERR_NOTFOUND, if the requested subnode does not exist
+ *  -FDT_ERR_BADOFFSET, if parentoffset did not point to an FDT_BEGIN_NODE
+ *      tag
+ *  -FDT_ERR_BADMAGIC,
+ *  -FDT_ERR_BADVERSION,
+ *  -FDT_ERR_BADSTATE,
+ *  -FDT_ERR_BADSTRUCTURE,
+ *  -FDT_ERR_TRUNCATED, standard meanings.
  */
 int fdt_subnode_offset(const void *fdt, int parentoffset, const char *name);
 
@@ -435,15 +442,15 @@ int fdt_path_offset_namelen(const void *fdt, const char *path, int namelen);
  * address).
  *
  * returns:
- *	structure block offset of the node with the requested path (>=0), on
- *		success
- *	-FDT_ERR_BADPATH, given path does not begin with '/' or is invalid
- *	-FDT_ERR_NOTFOUND, if the requested node does not exist
+ *  structure block offset of the node with the requested path (>=0), on
+ *      success
+ *  -FDT_ERR_BADPATH, given path does not begin with '/' or is invalid
+ *  -FDT_ERR_NOTFOUND, if the requested node does not exist
  *      -FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_TRUNCATED, standard meanings.
+ *  -FDT_ERR_BADVERSION,
+ *  -FDT_ERR_BADSTATE,
+ *  -FDT_ERR_BADSTRUCTURE,
+ *  -FDT_ERR_TRUNCATED, standard meanings.
  */
 int fdt_path_offset(const void *fdt, const char *path);
 
@@ -459,16 +466,16 @@ int fdt_path_offset(const void *fdt, const char *path);
  * pointed to by lenp.
  *
  * returns:
- *	pointer to the node's name, on success
- *		If lenp is non-NULL, *lenp contains the length of that name
- *			(>=0)
- *	NULL, on error
- *		if lenp is non-NULL *lenp contains an error code (<0):
- *		-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE
- *			tag
- *		-FDT_ERR_BADMAGIC,
- *		-FDT_ERR_BADVERSION,
- *		-FDT_ERR_BADSTATE, standard meanings
+ *  pointer to the node's name, on success
+ *      If lenp is non-NULL, *lenp contains the length of that name
+ *          (>=0)
+ *  NULL, on error
+ *      if lenp is non-NULL *lenp contains an error code (<0):
+ *      -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE
+ *          tag
+ *      -FDT_ERR_BADMAGIC,
+ *      -FDT_ERR_BADVERSION,
+ *      -FDT_ERR_BADSTATE, standard meanings
  */
 const char *fdt_get_name(const void *fdt, int nodeoffset, int *lenp);
 
@@ -481,14 +488,14 @@ const char *fdt_get_name(const void *fdt, int nodeoffset, int *lenp);
  * the given structure block offset.
  *
  * returns:
- *	structure block offset of the property (>=0), on success
- *	-FDT_ERR_NOTFOUND, if the requested node has no properties
- *	-FDT_ERR_BADOFFSET, if nodeoffset did not point to an FDT_BEGIN_NODE tag
+ *  structure block offset of the property (>=0), on success
+ *  -FDT_ERR_NOTFOUND, if the requested node has no properties
+ *  -FDT_ERR_BADOFFSET, if nodeoffset did not point to an FDT_BEGIN_NODE tag
  *      -FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_TRUNCATED, standard meanings.
+ *  -FDT_ERR_BADVERSION,
+ *  -FDT_ERR_BADSTATE,
+ *  -FDT_ERR_BADSTRUCTURE,
+ *  -FDT_ERR_TRUNCATED, standard meanings.
  */
 int fdt_first_property_offset(const void *fdt, int nodeoffset);
 
@@ -502,43 +509,43 @@ int fdt_first_property_offset(const void *fdt, int nodeoffset);
  * of the same node as the given property.
  *
  * returns:
- *	structure block offset of the next property (>=0), on success
- *	-FDT_ERR_NOTFOUND, if the given property is the last in its node
- *	-FDT_ERR_BADOFFSET, if nodeoffset did not point to an FDT_PROP tag
+ *  structure block offset of the next property (>=0), on success
+ *  -FDT_ERR_NOTFOUND, if the given property is the last in its node
+ *  -FDT_ERR_BADOFFSET, if nodeoffset did not point to an FDT_PROP tag
  *      -FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_TRUNCATED, standard meanings.
+ *  -FDT_ERR_BADVERSION,
+ *  -FDT_ERR_BADSTATE,
+ *  -FDT_ERR_BADSTRUCTURE,
+ *  -FDT_ERR_TRUNCATED, standard meanings.
  */
 int fdt_next_property_offset(const void *fdt, int offset);
 
 /**
  * fdt_for_each_property_offset - iterate over all properties of a node
  *
- * @property_offset:	property offset (int, lvalue)
- * @fdt:		FDT blob (const void *)
- * @node:		node offset (int)
+ * @property_offset:    property offset (int, lvalue)
+ * @fdt:        FDT blob (const void *)
+ * @node:       node offset (int)
  *
  * This is actually a wrapper around a for loop and would be used like so:
  *
- *	fdt_for_each_property_offset(property, fdt, node) {
- *		Use property
- *		...
- *	}
+ *  fdt_for_each_property_offset(property, fdt, node) {
+ *      Use property
+ *      ...
+ *  }
  *
- *	if ((property < 0) && (property != -FDT_ERR_NOT_FOUND)) {
- *		Error handling
- *	}
+ *  if ((property < 0) && (property != -FDT_ERR_NOT_FOUND)) {
+ *      Error handling
+ *  }
  *
  * Note that this is implemented as a macro and property is used as
  * iterator in the loop. The node variable can be constant or even a
  * literal.
  */
-#define fdt_for_each_property_offset(property, fdt, node)	\
-	for (property = fdt_first_property_offset(fdt, node);	\
-	     property >= 0;					\
-	     property = fdt_next_property_offset(fdt, property))
+#define fdt_for_each_property_offset(property, fdt, node)   \
+    for (property = fdt_first_property_offset(fdt, node);   \
+         property >= 0;                 \
+         property = fdt_next_property_offset(fdt, property))
 
 /**
  * fdt_get_property_by_offset - retrieve the property at a given offset
@@ -552,21 +559,21 @@ int fdt_next_property_offset(const void *fdt, int offset);
  * also returned, in the integer pointed to by lenp.
  *
  * returns:
- *	pointer to the structure representing the property
- *		if lenp is non-NULL, *lenp contains the length of the property
- *		value (>=0)
- *	NULL, on error
- *		if lenp is non-NULL, *lenp contains an error code (<0):
- *		-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_PROP tag
- *		-FDT_ERR_BADMAGIC,
- *		-FDT_ERR_BADVERSION,
- *		-FDT_ERR_BADSTATE,
- *		-FDT_ERR_BADSTRUCTURE,
- *		-FDT_ERR_TRUNCATED, standard meanings
+ *  pointer to the structure representing the property
+ *      if lenp is non-NULL, *lenp contains the length of the property
+ *      value (>=0)
+ *  NULL, on error
+ *      if lenp is non-NULL, *lenp contains an error code (<0):
+ *      -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_PROP tag
+ *      -FDT_ERR_BADMAGIC,
+ *      -FDT_ERR_BADVERSION,
+ *      -FDT_ERR_BADSTATE,
+ *      -FDT_ERR_BADSTRUCTURE,
+ *      -FDT_ERR_TRUNCATED, standard meanings
  */
 const struct fdt_property *fdt_get_property_by_offset(const void *fdt,
-						      int offset,
-						      int *lenp);
+                              int offset,
+                              int *lenp);
 
 /**
  * fdt_get_property_namelen - find a property based on substring
@@ -581,9 +588,9 @@ const struct fdt_property *fdt_get_property_by_offset(const void *fdt,
  */
 #ifndef SWIG /* Not available in Python */
 const struct fdt_property *fdt_get_property_namelen(const void *fdt,
-						    int nodeoffset,
-						    const char *name,
-						    int namelen, int *lenp);
+                            int nodeoffset,
+                            const char *name,
+                            int namelen, int *lenp);
 #endif
 
 /**
@@ -600,28 +607,28 @@ const struct fdt_property *fdt_get_property_namelen(const void *fdt,
  * integer pointed to by lenp.
  *
  * returns:
- *	pointer to the structure representing the property
- *		if lenp is non-NULL, *lenp contains the length of the property
- *		value (>=0)
- *	NULL, on error
- *		if lenp is non-NULL, *lenp contains an error code (<0):
- *		-FDT_ERR_NOTFOUND, node does not have named property
- *		-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE
- *			tag
- *		-FDT_ERR_BADMAGIC,
- *		-FDT_ERR_BADVERSION,
- *		-FDT_ERR_BADSTATE,
- *		-FDT_ERR_BADSTRUCTURE,
- *		-FDT_ERR_TRUNCATED, standard meanings
+ *  pointer to the structure representing the property
+ *      if lenp is non-NULL, *lenp contains the length of the property
+ *      value (>=0)
+ *  NULL, on error
+ *      if lenp is non-NULL, *lenp contains an error code (<0):
+ *      -FDT_ERR_NOTFOUND, node does not have named property
+ *      -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE
+ *          tag
+ *      -FDT_ERR_BADMAGIC,
+ *      -FDT_ERR_BADVERSION,
+ *      -FDT_ERR_BADSTATE,
+ *      -FDT_ERR_BADSTRUCTURE,
+ *      -FDT_ERR_TRUNCATED, standard meanings
  */
 const struct fdt_property *fdt_get_property(const void *fdt, int nodeoffset,
-					    const char *name, int *lenp);
+                        const char *name, int *lenp);
 static inline struct fdt_property *fdt_get_property_w(void *fdt, int nodeoffset,
-						      const char *name,
-						      int *lenp)
+                              const char *name,
+                              int *lenp)
 {
-	return (struct fdt_property *)(uintptr_t)
-		fdt_get_property(fdt, nodeoffset, name, lenp);
+    return (struct fdt_property *)(uintptr_t)
+        fdt_get_property(fdt, nodeoffset, name, lenp);
 }
 
 /**
@@ -641,23 +648,23 @@ static inline struct fdt_property *fdt_get_property_w(void *fdt, int nodeoffset,
  * block, not a new copy of the name).
  *
  * returns:
- *	pointer to the property's value
- *		if lenp is non-NULL, *lenp contains the length of the property
- *		value (>=0)
- *		if namep is non-NULL *namep contiains a pointer to the property
- *		name.
- *	NULL, on error
- *		if lenp is non-NULL, *lenp contains an error code (<0):
- *		-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_PROP tag
- *		-FDT_ERR_BADMAGIC,
- *		-FDT_ERR_BADVERSION,
- *		-FDT_ERR_BADSTATE,
- *		-FDT_ERR_BADSTRUCTURE,
- *		-FDT_ERR_TRUNCATED, standard meanings
+ *  pointer to the property's value
+ *      if lenp is non-NULL, *lenp contains the length of the property
+ *      value (>=0)
+ *      if namep is non-NULL *namep contiains a pointer to the property
+ *      name.
+ *  NULL, on error
+ *      if lenp is non-NULL, *lenp contains an error code (<0):
+ *      -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_PROP tag
+ *      -FDT_ERR_BADMAGIC,
+ *      -FDT_ERR_BADVERSION,
+ *      -FDT_ERR_BADSTATE,
+ *      -FDT_ERR_BADSTRUCTURE,
+ *      -FDT_ERR_TRUNCATED, standard meanings
  */
 #ifndef SWIG /* This function is not useful in Python */
 const void *fdt_getprop_by_offset(const void *fdt, int offset,
-				  const char **namep, int *lenp);
+                  const char **namep, int *lenp);
 #endif
 
 /**
@@ -673,13 +680,13 @@ const void *fdt_getprop_by_offset(const void *fdt, int offset,
  */
 #ifndef SWIG /* Not available in Python */
 const void *fdt_getprop_namelen(const void *fdt, int nodeoffset,
-				const char *name, int namelen, int *lenp);
+                const char *name, int namelen, int *lenp);
 static inline void *fdt_getprop_namelen_w(void *fdt, int nodeoffset,
-					  const char *name, int namelen,
-					  int *lenp)
+                      const char *name, int namelen,
+                      int *lenp)
 {
-	return (void *)(uintptr_t)fdt_getprop_namelen(fdt, nodeoffset, name,
-						      namelen, lenp);
+    return (void *)(uintptr_t)fdt_getprop_namelen(fdt, nodeoffset, name,
+                              namelen, lenp);
 }
 #endif
 
@@ -697,26 +704,26 @@ static inline void *fdt_getprop_namelen_w(void *fdt, int nodeoffset,
  * returned, in the integer pointed to by lenp.
  *
  * returns:
- *	pointer to the property's value
- *		if lenp is non-NULL, *lenp contains the length of the property
- *		value (>=0)
- *	NULL, on error
- *		if lenp is non-NULL, *lenp contains an error code (<0):
- *		-FDT_ERR_NOTFOUND, node does not have named property
- *		-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE
- *			tag
- *		-FDT_ERR_BADMAGIC,
- *		-FDT_ERR_BADVERSION,
- *		-FDT_ERR_BADSTATE,
- *		-FDT_ERR_BADSTRUCTURE,
- *		-FDT_ERR_TRUNCATED, standard meanings
+ *  pointer to the property's value
+ *      if lenp is non-NULL, *lenp contains the length of the property
+ *      value (>=0)
+ *  NULL, on error
+ *      if lenp is non-NULL, *lenp contains an error code (<0):
+ *      -FDT_ERR_NOTFOUND, node does not have named property
+ *      -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE
+ *          tag
+ *      -FDT_ERR_BADMAGIC,
+ *      -FDT_ERR_BADVERSION,
+ *      -FDT_ERR_BADSTATE,
+ *      -FDT_ERR_BADSTRUCTURE,
+ *      -FDT_ERR_TRUNCATED, standard meanings
  */
 const void *fdt_getprop(const void *fdt, int nodeoffset,
-			const char *name, int *lenp);
+            const char *name, int *lenp);
 static inline void *fdt_getprop_w(void *fdt, int nodeoffset,
-				  const char *name, int *lenp)
+                  const char *name, int *lenp)
 {
-	return (void *)(uintptr_t)fdt_getprop(fdt, nodeoffset, name, lenp);
+    return (void *)(uintptr_t)fdt_getprop(fdt, nodeoffset, name, lenp);
 }
 
 /**
@@ -728,8 +735,8 @@ static inline void *fdt_getprop_w(void *fdt, int nodeoffset,
  * structure block offset nodeoffset.
  *
  * returns:
- *	the phandle of the node at nodeoffset, on success (!= 0, != -1)
- *	0, if the node has no phandle, or another error occurs
+ *  the phandle of the node at nodeoffset, on success (!= 0, != -1)
+ *  0, if the node has no phandle, or another error occurs
  */
 uint32_t fdt_get_phandle(const void *fdt, int nodeoffset);
 
@@ -744,7 +751,7 @@ uint32_t fdt_get_phandle(const void *fdt, int nodeoffset);
  */
 #ifndef SWIG /* Not available in Python */
 const char *fdt_get_alias_namelen(const void *fdt,
-				  const char *name, int namelen);
+                  const char *name, int namelen);
 #endif
 
 /**
@@ -756,8 +763,8 @@ const char *fdt_get_alias_namelen(const void *fdt,
  * value of the property named 'name' in the node /aliases.
  *
  * returns:
- *	a pointer to the expansion of the alias named 'name', if it exists
- *	NULL, if the given alias or the /aliases node does not exist
+ *  a pointer to the expansion of the alias named 'name', if it exists
+ *  NULL, if the given alias or the /aliases node does not exist
  */
 const char *fdt_get_alias(const void *fdt, const char *name);
 
@@ -775,16 +782,16 @@ const char *fdt_get_alias(const void *fdt, const char *name);
  * structure from the start to nodeoffset.
  *
  * returns:
- *	0, on success
- *		buf contains the absolute path of the node at
- *		nodeoffset, as a NUL-terminated string.
- *	-FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag
- *	-FDT_ERR_NOSPACE, the path of the given node is longer than (bufsize-1)
- *		characters and will not fit in the given buffer.
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE, standard meanings
+ *  0, on success
+ *      buf contains the absolute path of the node at
+ *      nodeoffset, as a NUL-terminated string.
+ *  -FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag
+ *  -FDT_ERR_NOSPACE, the path of the given node is longer than (bufsize-1)
+ *      characters and will not fit in the given buffer.
+ *  -FDT_ERR_BADMAGIC,
+ *  -FDT_ERR_BADVERSION,
+ *  -FDT_ERR_BADSTATE,
+ *  -FDT_ERR_BADSTRUCTURE, standard meanings
  */
 int fdt_get_path(const void *fdt, int nodeoffset, char *buf, int buflen);
 
@@ -798,28 +805,28 @@ int fdt_get_path(const void *fdt, int nodeoffset, char *buf, int buflen);
  * fdt_supernode_atdepth_offset() finds an ancestor of the given node
  * at a specific depth from the root (where the root itself has depth
  * 0, its immediate subnodes depth 1 and so forth).  So
- *	fdt_supernode_atdepth_offset(fdt, nodeoffset, 0, NULL);
+ *  fdt_supernode_atdepth_offset(fdt, nodeoffset, 0, NULL);
  * will always return 0, the offset of the root node.  If the node at
  * nodeoffset has depth D, then:
- *	fdt_supernode_atdepth_offset(fdt, nodeoffset, D, NULL);
+ *  fdt_supernode_atdepth_offset(fdt, nodeoffset, D, NULL);
  * will return nodeoffset itself.
  *
  * NOTE: This function is expensive, as it must scan the device tree
  * structure from the start to nodeoffset.
  *
  * returns:
- *	structure block offset of the node at node offset's ancestor
- *		of depth supernodedepth (>=0), on success
- *	-FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag
- *	-FDT_ERR_NOTFOUND, supernodedepth was greater than the depth of
- *		nodeoffset
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE, standard meanings
+ *  structure block offset of the node at node offset's ancestor
+ *      of depth supernodedepth (>=0), on success
+ *  -FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag
+ *  -FDT_ERR_NOTFOUND, supernodedepth was greater than the depth of
+ *      nodeoffset
+ *  -FDT_ERR_BADMAGIC,
+ *  -FDT_ERR_BADVERSION,
+ *  -FDT_ERR_BADSTATE,
+ *  -FDT_ERR_BADSTRUCTURE, standard meanings
  */
 int fdt_supernode_atdepth_offset(const void *fdt, int nodeoffset,
-				 int supernodedepth, int *nodedepth);
+                 int supernodedepth, int *nodedepth);
 
 /**
  * fdt_node_depth - find the depth of a given node
@@ -833,12 +840,12 @@ int fdt_supernode_atdepth_offset(const void *fdt, int nodeoffset,
  * structure from the start to nodeoffset.
  *
  * returns:
- *	depth of the node at nodeoffset (>=0), on success
- *	-FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE, standard meanings
+ *  depth of the node at nodeoffset (>=0), on success
+ *  -FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag
+ *  -FDT_ERR_BADMAGIC,
+ *  -FDT_ERR_BADVERSION,
+ *  -FDT_ERR_BADSTATE,
+ *  -FDT_ERR_BADSTRUCTURE, standard meanings
  */
 int fdt_node_depth(const void *fdt, int nodeoffset);
 
@@ -855,13 +862,13 @@ int fdt_node_depth(const void *fdt, int nodeoffset);
  * structure from the start to nodeoffset, *twice*.
  *
  * returns:
- *	structure block offset of the parent of the node at nodeoffset
- *		(>=0), on success
- *	-FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE, standard meanings
+ *  structure block offset of the parent of the node at nodeoffset
+ *      (>=0), on success
+ *  -FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag
+ *  -FDT_ERR_BADMAGIC,
+ *  -FDT_ERR_BADVERSION,
+ *  -FDT_ERR_BADSTATE,
+ *  -FDT_ERR_BADSTRUCTURE, standard meanings
  */
 int fdt_parent_offset(const void *fdt, int nodeoffset);
 
@@ -880,32 +887,32 @@ int fdt_parent_offset(const void *fdt, int nodeoffset);
  *
  * To iterate through all nodes matching the criterion, the following
  * idiom can be used:
- *	offset = fdt_node_offset_by_prop_value(fdt, -1, propname,
- *					       propval, proplen);
- *	while (offset != -FDT_ERR_NOTFOUND) {
- *		// other code here
- *		offset = fdt_node_offset_by_prop_value(fdt, offset, propname,
- *						       propval, proplen);
- *	}
+ *  offset = fdt_node_offset_by_prop_value(fdt, -1, propname,
+ *                         propval, proplen);
+ *  while (offset != -FDT_ERR_NOTFOUND) {
+ *      // other code here
+ *      offset = fdt_node_offset_by_prop_value(fdt, offset, propname,
+ *                             propval, proplen);
+ *  }
  *
  * Note the -1 in the first call to the function, if 0 is used here
  * instead, the function will never locate the root node, even if it
  * matches the criterion.
  *
  * returns:
- *	structure block offset of the located node (>= 0, >startoffset),
- *		 on success
- *	-FDT_ERR_NOTFOUND, no node matching the criterion exists in the
- *		tree after startoffset
- *	-FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE, standard meanings
+ *  structure block offset of the located node (>= 0, >startoffset),
+ *       on success
+ *  -FDT_ERR_NOTFOUND, no node matching the criterion exists in the
+ *      tree after startoffset
+ *  -FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag
+ *  -FDT_ERR_BADMAGIC,
+ *  -FDT_ERR_BADVERSION,
+ *  -FDT_ERR_BADSTATE,
+ *  -FDT_ERR_BADSTRUCTURE, standard meanings
  */
 int fdt_node_offset_by_prop_value(const void *fdt, int startoffset,
-				  const char *propname,
-				  const void *propval, int proplen);
+                  const char *propname,
+                  const void *propval, int proplen);
 
 /**
  * fdt_node_offset_by_phandle - find the node with a given phandle
@@ -918,13 +925,13 @@ int fdt_node_offset_by_prop_value(const void *fdt, int startoffset,
  * undefined.
  *
  * returns:
- *	structure block offset of the located node (>= 0), on success
- *	-FDT_ERR_NOTFOUND, no node with that phandle exists
- *	-FDT_ERR_BADPHANDLE, given phandle value was invalid (0 or -1)
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE, standard meanings
+ *  structure block offset of the located node (>= 0), on success
+ *  -FDT_ERR_NOTFOUND, no node with that phandle exists
+ *  -FDT_ERR_BADPHANDLE, given phandle value was invalid (0 or -1)
+ *  -FDT_ERR_BADMAGIC,
+ *  -FDT_ERR_BADVERSION,
+ *  -FDT_ERR_BADSTATE,
+ *  -FDT_ERR_BADSTRUCTURE, standard meanings
  */
 int fdt_node_offset_by_phandle(const void *fdt, uint32_t phandle);
 
@@ -940,18 +947,18 @@ int fdt_node_offset_by_phandle(const void *fdt, uint32_t phandle);
  * it returns non-zero otherwise, or on error.
  *
  * returns:
- *	0, if the node has a 'compatible' property listing the given string
- *	1, if the node has a 'compatible' property, but it does not list
- *		the given string
- *	-FDT_ERR_NOTFOUND, if the given node has no 'compatible' property
- *	-FDT_ERR_BADOFFSET, if nodeoffset does not refer to a BEGIN_NODE tag
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE, standard meanings
+ *  0, if the node has a 'compatible' property listing the given string
+ *  1, if the node has a 'compatible' property, but it does not list
+ *      the given string
+ *  -FDT_ERR_NOTFOUND, if the given node has no 'compatible' property
+ *  -FDT_ERR_BADOFFSET, if nodeoffset does not refer to a BEGIN_NODE tag
+ *  -FDT_ERR_BADMAGIC,
+ *  -FDT_ERR_BADVERSION,
+ *  -FDT_ERR_BADSTATE,
+ *  -FDT_ERR_BADSTRUCTURE, standard meanings
  */
 int fdt_node_check_compatible(const void *fdt, int nodeoffset,
-			      const char *compatible);
+                  const char *compatible);
 
 /**
  * fdt_node_offset_by_compatible - find nodes with a given 'compatible' value
@@ -966,29 +973,29 @@ int fdt_node_check_compatible(const void *fdt, int nodeoffset,
  *
  * To iterate through all nodes matching the criterion, the following
  * idiom can be used:
- *	offset = fdt_node_offset_by_compatible(fdt, -1, compatible);
- *	while (offset != -FDT_ERR_NOTFOUND) {
- *		// other code here
- *		offset = fdt_node_offset_by_compatible(fdt, offset, compatible);
- *	}
+ *  offset = fdt_node_offset_by_compatible(fdt, -1, compatible);
+ *  while (offset != -FDT_ERR_NOTFOUND) {
+ *      // other code here
+ *      offset = fdt_node_offset_by_compatible(fdt, offset, compatible);
+ *  }
  *
  * Note the -1 in the first call to the function, if 0 is used here
  * instead, the function will never locate the root node, even if it
  * matches the criterion.
  *
  * returns:
- *	structure block offset of the located node (>= 0, >startoffset),
- *		 on success
- *	-FDT_ERR_NOTFOUND, no node matching the criterion exists in the
- *		tree after startoffset
- *	-FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE, standard meanings
+ *  structure block offset of the located node (>= 0, >startoffset),
+ *       on success
+ *  -FDT_ERR_NOTFOUND, no node matching the criterion exists in the
+ *      tree after startoffset
+ *  -FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag
+ *  -FDT_ERR_BADMAGIC,
+ *  -FDT_ERR_BADVERSION,
+ *  -FDT_ERR_BADSTATE,
+ *  -FDT_ERR_BADSTRUCTURE, standard meanings
  */
 int fdt_node_offset_by_compatible(const void *fdt, int startoffset,
-				  const char *compatible);
+                  const char *compatible);
 
 /**
  * fdt_stringlist_contains - check a string list property for a string
@@ -1036,7 +1043,7 @@ int fdt_stringlist_count(const void *fdt, int nodeoffset, const char *property);
  *                     the given string
  */
 int fdt_stringlist_search(const void *fdt, int nodeoffset, const char *property,
-			  const char *string);
+              const char *string);
 
 /**
  * fdt_stringlist_get() - obtain the string at a given index in a string list
@@ -1063,8 +1070,8 @@ int fdt_stringlist_search(const void *fdt, int nodeoffset, const char *property,
  *     -FDT_ERR_NOTFOUND if the property does not exist
  */
 const char *fdt_stringlist_get(const void *fdt, int nodeoffset,
-			       const char *property, int index,
-			       int *lenp);
+                   const char *property, int index,
+                   int *lenp);
 
 /**********************************************************************/
 /* Read-only functions (addressing related)                           */
@@ -1079,7 +1086,7 @@ const char *fdt_stringlist_get(const void *fdt, int nodeoffset,
  * Implementations may support larger values, but in practice higher
  * values aren't used.
  */
-#define FDT_MAX_NCELLS		4
+#define FDT_MAX_NCELLS      4
 
 /**
  * fdt_address_cells - retrieve address size for a bus represented in the tree
@@ -1089,15 +1096,15 @@ const char *fdt_stringlist_get(const void *fdt, int nodeoffset,
  * When the node has a valid #address-cells property, returns its value.
  *
  * returns:
- *	0 <= n < FDT_MAX_NCELLS, on success
+ *  0 <= n < FDT_MAX_NCELLS, on success
  *      2, if the node has no #address-cells property
  *      -FDT_ERR_BADNCELLS, if the node has a badly formatted or invalid
- *		#address-cells property
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_TRUNCATED, standard meanings
+ *      #address-cells property
+ *  -FDT_ERR_BADMAGIC,
+ *  -FDT_ERR_BADVERSION,
+ *  -FDT_ERR_BADSTATE,
+ *  -FDT_ERR_BADSTRUCTURE,
+ *  -FDT_ERR_TRUNCATED, standard meanings
  */
 int fdt_address_cells(const void *fdt, int nodeoffset);
 
@@ -1110,15 +1117,15 @@ int fdt_address_cells(const void *fdt, int nodeoffset);
  * When the node has a valid #size-cells property, returns its value.
  *
  * returns:
- *	0 <= n < FDT_MAX_NCELLS, on success
+ *  0 <= n < FDT_MAX_NCELLS, on success
  *      2, if the node has no #address-cells property
  *      -FDT_ERR_BADNCELLS, if the node has a badly formatted or invalid
- *		#size-cells property
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_TRUNCATED, standard meanings
+ *      #size-cells property
+ *  -FDT_ERR_BADMAGIC,
+ *  -FDT_ERR_BADVERSION,
+ *  -FDT_ERR_BADSTATE,
+ *  -FDT_ERR_BADSTRUCTURE,
+ *  -FDT_ERR_TRUNCATED, standard meanings
  */
 int fdt_size_cells(const void *fdt, int nodeoffset);
 
@@ -1145,9 +1152,9 @@ int fdt_size_cells(const void *fdt, int nodeoffset);
  */
 #ifndef SWIG /* Not available in Python */
 int fdt_setprop_inplace_namelen_partial(void *fdt, int nodeoffset,
-					const char *name, int namelen,
-					uint32_t idx, const void *val,
-					int len);
+                    const char *name, int namelen,
+                    uint32_t idx, const void *val,
+                    int len);
 #endif
 
 /**
@@ -1168,19 +1175,19 @@ int fdt_setprop_inplace_namelen_partial(void *fdt, int nodeoffset,
  * of the tree.
  *
  * returns:
- *	0, on success
- *	-FDT_ERR_NOSPACE, if len is not equal to the property's current length
- *	-FDT_ERR_NOTFOUND, node does not have the named property
- *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_TRUNCATED, standard meanings
+ *  0, on success
+ *  -FDT_ERR_NOSPACE, if len is not equal to the property's current length
+ *  -FDT_ERR_NOTFOUND, node does not have the named property
+ *  -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
+ *  -FDT_ERR_BADMAGIC,
+ *  -FDT_ERR_BADVERSION,
+ *  -FDT_ERR_BADSTATE,
+ *  -FDT_ERR_BADSTRUCTURE,
+ *  -FDT_ERR_TRUNCATED, standard meanings
  */
 #ifndef SWIG /* Not available in Python */
 int fdt_setprop_inplace(void *fdt, int nodeoffset, const char *name,
-			const void *val, int len);
+            const void *val, int len);
 #endif
 
 /**
@@ -1201,21 +1208,21 @@ int fdt_setprop_inplace(void *fdt, int nodeoffset, const char *name,
  * of the tree.
  *
  * returns:
- *	0, on success
- *	-FDT_ERR_NOSPACE, if the property's length is not equal to 4
- *	-FDT_ERR_NOTFOUND, node does not have the named property
- *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_TRUNCATED, standard meanings
+ *  0, on success
+ *  -FDT_ERR_NOSPACE, if the property's length is not equal to 4
+ *  -FDT_ERR_NOTFOUND, node does not have the named property
+ *  -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
+ *  -FDT_ERR_BADMAGIC,
+ *  -FDT_ERR_BADVERSION,
+ *  -FDT_ERR_BADSTATE,
+ *  -FDT_ERR_BADSTRUCTURE,
+ *  -FDT_ERR_TRUNCATED, standard meanings
  */
 static inline int fdt_setprop_inplace_u32(void *fdt, int nodeoffset,
-					  const char *name, uint32_t val)
+                      const char *name, uint32_t val)
 {
-	fdt32_t tmp = cpu_to_fdt32(val);
-	return fdt_setprop_inplace(fdt, nodeoffset, name, &tmp, sizeof(tmp));
+    fdt32_t tmp = cpu_to_fdt32(val);
+    return fdt_setprop_inplace(fdt, nodeoffset, name, &tmp, sizeof(tmp));
 }
 
 /**
@@ -1236,21 +1243,21 @@ static inline int fdt_setprop_inplace_u32(void *fdt, int nodeoffset,
  * of the tree.
  *
  * returns:
- *	0, on success
- *	-FDT_ERR_NOSPACE, if the property's length is not equal to 8
- *	-FDT_ERR_NOTFOUND, node does not have the named property
- *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_TRUNCATED, standard meanings
+ *  0, on success
+ *  -FDT_ERR_NOSPACE, if the property's length is not equal to 8
+ *  -FDT_ERR_NOTFOUND, node does not have the named property
+ *  -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
+ *  -FDT_ERR_BADMAGIC,
+ *  -FDT_ERR_BADVERSION,
+ *  -FDT_ERR_BADSTATE,
+ *  -FDT_ERR_BADSTRUCTURE,
+ *  -FDT_ERR_TRUNCATED, standard meanings
  */
 static inline int fdt_setprop_inplace_u64(void *fdt, int nodeoffset,
-					  const char *name, uint64_t val)
+                      const char *name, uint64_t val)
 {
-	fdt64_t tmp = cpu_to_fdt64(val);
-	return fdt_setprop_inplace(fdt, nodeoffset, name, &tmp, sizeof(tmp));
+    fdt64_t tmp = cpu_to_fdt64(val);
+    return fdt_setprop_inplace(fdt, nodeoffset, name, &tmp, sizeof(tmp));
 }
 
 /**
@@ -1259,9 +1266,9 @@ static inline int fdt_setprop_inplace_u64(void *fdt, int nodeoffset,
  * This is an alternative name for fdt_setprop_inplace_u32()
  */
 static inline int fdt_setprop_inplace_cell(void *fdt, int nodeoffset,
-					   const char *name, uint32_t val)
+                       const char *name, uint32_t val)
 {
-	return fdt_setprop_inplace_u32(fdt, nodeoffset, name, val);
+    return fdt_setprop_inplace_u32(fdt, nodeoffset, name, val);
 }
 
 /**
@@ -1279,14 +1286,14 @@ static inline int fdt_setprop_inplace_cell(void *fdt, int nodeoffset,
  * tree.
  *
  * returns:
- *	0, on success
- *	-FDT_ERR_NOTFOUND, node does not have the named property
- *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_TRUNCATED, standard meanings
+ *  0, on success
+ *  -FDT_ERR_NOTFOUND, node does not have the named property
+ *  -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
+ *  -FDT_ERR_BADMAGIC,
+ *  -FDT_ERR_BADVERSION,
+ *  -FDT_ERR_BADSTATE,
+ *  -FDT_ERR_BADSTRUCTURE,
+ *  -FDT_ERR_TRUNCATED, standard meanings
  */
 int fdt_nop_property(void *fdt, int nodeoffset, const char *name);
 
@@ -1304,13 +1311,13 @@ int fdt_nop_property(void *fdt, int nodeoffset, const char *name);
  * move any other part of the tree.
  *
  * returns:
- *	0, on success
- *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_TRUNCATED, standard meanings
+ *  0, on success
+ *  -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
+ *  -FDT_ERR_BADMAGIC,
+ *  -FDT_ERR_BADVERSION,
+ *  -FDT_ERR_BADSTATE,
+ *  -FDT_ERR_BADSTRUCTURE,
+ *  -FDT_ERR_TRUNCATED, standard meanings
  */
 int fdt_nop_node(void *fdt, int nodeoffset);
 
@@ -1326,20 +1333,20 @@ int fdt_begin_node(void *fdt, const char *name);
 int fdt_property(void *fdt, const char *name, const void *val, int len);
 static inline int fdt_property_u32(void *fdt, const char *name, uint32_t val)
 {
-	fdt32_t tmp = cpu_to_fdt32(val);
-	return fdt_property(fdt, name, &tmp, sizeof(tmp));
+    fdt32_t tmp = cpu_to_fdt32(val);
+    return fdt_property(fdt, name, &tmp, sizeof(tmp));
 }
 static inline int fdt_property_u64(void *fdt, const char *name, uint64_t val)
 {
-	fdt64_t tmp = cpu_to_fdt64(val);
-	return fdt_property(fdt, name, &tmp, sizeof(tmp));
+    fdt64_t tmp = cpu_to_fdt64(val);
+    return fdt_property(fdt, name, &tmp, sizeof(tmp));
 }
 static inline int fdt_property_cell(void *fdt, const char *name, uint32_t val)
 {
-	return fdt_property_u32(fdt, name, val);
+    return fdt_property_u32(fdt, name, val);
 }
 #define fdt_property_string(fdt, name, str) \
-	fdt_property(fdt, name, str, strlen(str)+1)
+    fdt_property(fdt, name, str, strlen(str)+1)
 int fdt_end_node(void *fdt);
 int fdt_finish(void *fdt);
 
@@ -1363,15 +1370,15 @@ int fdt_pack(void *fdt);
  * therefore change the indexes of some entries in the table.
  *
  * returns:
- *	0, on success
- *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to
- *		contain the new reservation entry
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_TRUNCATED, standard meanings
+ *  0, on success
+ *  -FDT_ERR_NOSPACE, there is insufficient free space in the blob to
+ *      contain the new reservation entry
+ *  -FDT_ERR_BADMAGIC,
+ *  -FDT_ERR_BADVERSION,
+ *  -FDT_ERR_BADSTATE,
+ *  -FDT_ERR_BADSTRUCTURE,
+ *  -FDT_ERR_BADLAYOUT,
+ *  -FDT_ERR_TRUNCATED, standard meanings
  */
 int fdt_add_mem_rsv(void *fdt, uint64_t address, uint64_t size);
 
@@ -1387,15 +1394,15 @@ int fdt_add_mem_rsv(void *fdt, uint64_t address, uint64_t size);
  * therefore change the indexes of some entries in the table.
  *
  * returns:
- *	0, on success
- *	-FDT_ERR_NOTFOUND, there is no entry of the given index (i.e. there
- *		are less than n+1 reserve map entries)
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_TRUNCATED, standard meanings
+ *  0, on success
+ *  -FDT_ERR_NOTFOUND, there is no entry of the given index (i.e. there
+ *      are less than n+1 reserve map entries)
+ *  -FDT_ERR_BADMAGIC,
+ *  -FDT_ERR_BADVERSION,
+ *  -FDT_ERR_BADSTATE,
+ *  -FDT_ERR_BADSTRUCTURE,
+ *  -FDT_ERR_BADLAYOUT,
+ *  -FDT_ERR_TRUNCATED, standard meanings
  */
 int fdt_del_mem_rsv(void *fdt, int n);
 
@@ -1415,13 +1422,13 @@ int fdt_del_mem_rsv(void *fdt, int n);
  * therefore change the offsets of some existing nodes.
  *
  * returns:
- *	0, on success
- *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob
- *		to contain the new name
- *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE, standard meanings
+ *  0, on success
+ *  -FDT_ERR_NOSPACE, there is insufficient free space in the blob
+ *      to contain the new name
+ *  -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
+ *  -FDT_ERR_BADMAGIC,
+ *  -FDT_ERR_BADVERSION,
+ *  -FDT_ERR_BADSTATE, standard meanings
  */
 int fdt_set_name(void *fdt, int nodeoffset, const char *name);
 
@@ -1441,20 +1448,20 @@ int fdt_set_name(void *fdt, int nodeoffset, const char *name);
  * therefore change the offsets of some existing nodes.
  *
  * returns:
- *	0, on success
- *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to
- *		contain the new property value
- *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_TRUNCATED, standard meanings
+ *  0, on success
+ *  -FDT_ERR_NOSPACE, there is insufficient free space in the blob to
+ *      contain the new property value
+ *  -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
+ *  -FDT_ERR_BADLAYOUT,
+ *  -FDT_ERR_BADMAGIC,
+ *  -FDT_ERR_BADVERSION,
+ *  -FDT_ERR_BADSTATE,
+ *  -FDT_ERR_BADSTRUCTURE,
+ *  -FDT_ERR_BADLAYOUT,
+ *  -FDT_ERR_TRUNCATED, standard meanings
  */
 int fdt_setprop(void *fdt, int nodeoffset, const char *name,
-		const void *val, int len);
+        const void *val, int len);
 
 /**
  * fdt_setprop_u32 - set a property to a 32-bit integer
@@ -1472,23 +1479,23 @@ int fdt_setprop(void *fdt, int nodeoffset, const char *name,
  * therefore change the offsets of some existing nodes.
  *
  * returns:
- *	0, on success
- *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to
- *		contain the new property value
- *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_TRUNCATED, standard meanings
+ *  0, on success
+ *  -FDT_ERR_NOSPACE, there is insufficient free space in the blob to
+ *      contain the new property value
+ *  -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
+ *  -FDT_ERR_BADLAYOUT,
+ *  -FDT_ERR_BADMAGIC,
+ *  -FDT_ERR_BADVERSION,
+ *  -FDT_ERR_BADSTATE,
+ *  -FDT_ERR_BADSTRUCTURE,
+ *  -FDT_ERR_BADLAYOUT,
+ *  -FDT_ERR_TRUNCATED, standard meanings
  */
 static inline int fdt_setprop_u32(void *fdt, int nodeoffset, const char *name,
-				  uint32_t val)
+                  uint32_t val)
 {
-	fdt32_t tmp = cpu_to_fdt32(val);
-	return fdt_setprop(fdt, nodeoffset, name, &tmp, sizeof(tmp));
+    fdt32_t tmp = cpu_to_fdt32(val);
+    return fdt_setprop(fdt, nodeoffset, name, &tmp, sizeof(tmp));
 }
 
 /**
@@ -1507,23 +1514,23 @@ static inline int fdt_setprop_u32(void *fdt, int nodeoffset, const char *name,
  * therefore change the offsets of some existing nodes.
  *
  * returns:
- *	0, on success
- *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to
- *		contain the new property value
- *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_TRUNCATED, standard meanings
+ *  0, on success
+ *  -FDT_ERR_NOSPACE, there is insufficient free space in the blob to
+ *      contain the new property value
+ *  -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
+ *  -FDT_ERR_BADLAYOUT,
+ *  -FDT_ERR_BADMAGIC,
+ *  -FDT_ERR_BADVERSION,
+ *  -FDT_ERR_BADSTATE,
+ *  -FDT_ERR_BADSTRUCTURE,
+ *  -FDT_ERR_BADLAYOUT,
+ *  -FDT_ERR_TRUNCATED, standard meanings
  */
 static inline int fdt_setprop_u64(void *fdt, int nodeoffset, const char *name,
-				  uint64_t val)
+                  uint64_t val)
 {
-	fdt64_t tmp = cpu_to_fdt64(val);
-	return fdt_setprop(fdt, nodeoffset, name, &tmp, sizeof(tmp));
+    fdt64_t tmp = cpu_to_fdt64(val);
+    return fdt_setprop(fdt, nodeoffset, name, &tmp, sizeof(tmp));
 }
 
 /**
@@ -1532,9 +1539,9 @@ static inline int fdt_setprop_u64(void *fdt, int nodeoffset, const char *name,
  * This is an alternative name for fdt_setprop_u32()
  */
 static inline int fdt_setprop_cell(void *fdt, int nodeoffset, const char *name,
-				   uint32_t val)
+                   uint32_t val)
 {
-	return fdt_setprop_u32(fdt, nodeoffset, name, val);
+    return fdt_setprop_u32(fdt, nodeoffset, name, val);
 }
 
 /**
@@ -1553,20 +1560,20 @@ static inline int fdt_setprop_cell(void *fdt, int nodeoffset, const char *name,
  * therefore change the offsets of some existing nodes.
  *
  * returns:
- *	0, on success
- *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to
- *		contain the new property value
- *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_TRUNCATED, standard meanings
+ *  0, on success
+ *  -FDT_ERR_NOSPACE, there is insufficient free space in the blob to
+ *      contain the new property value
+ *  -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
+ *  -FDT_ERR_BADLAYOUT,
+ *  -FDT_ERR_BADMAGIC,
+ *  -FDT_ERR_BADVERSION,
+ *  -FDT_ERR_BADSTATE,
+ *  -FDT_ERR_BADSTRUCTURE,
+ *  -FDT_ERR_BADLAYOUT,
+ *  -FDT_ERR_TRUNCATED, standard meanings
  */
 #define fdt_setprop_string(fdt, nodeoffset, name, str) \
-	fdt_setprop((fdt), (nodeoffset), (name), (str), strlen(str)+1)
+    fdt_setprop((fdt), (nodeoffset), (name), (str), strlen(str)+1)
 
 
 /**
@@ -1583,20 +1590,20 @@ static inline int fdt_setprop_cell(void *fdt, int nodeoffset, const char *name,
  * therefore change the offsets of some existing nodes.
  *
  * returns:
- *	0, on success
- *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to
- *		contain the new property value
- *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_TRUNCATED, standard meanings
+ *  0, on success
+ *  -FDT_ERR_NOSPACE, there is insufficient free space in the blob to
+ *      contain the new property value
+ *  -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
+ *  -FDT_ERR_BADLAYOUT,
+ *  -FDT_ERR_BADMAGIC,
+ *  -FDT_ERR_BADVERSION,
+ *  -FDT_ERR_BADSTATE,
+ *  -FDT_ERR_BADSTRUCTURE,
+ *  -FDT_ERR_BADLAYOUT,
+ *  -FDT_ERR_TRUNCATED, standard meanings
  */
 #define fdt_setprop_empty(fdt, nodeoffset, name) \
-	fdt_setprop((fdt), (nodeoffset), (name), NULL, 0)
+    fdt_setprop((fdt), (nodeoffset), (name), NULL, 0)
 
 /**
  * fdt_appendprop - append to or create a property
@@ -1613,20 +1620,20 @@ static inline int fdt_setprop_cell(void *fdt, int nodeoffset, const char *name,
  * change the offsets of some existing nodes.
  *
  * returns:
- *	0, on success
- *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to
- *		contain the new property value
- *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_TRUNCATED, standard meanings
+ *  0, on success
+ *  -FDT_ERR_NOSPACE, there is insufficient free space in the blob to
+ *      contain the new property value
+ *  -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
+ *  -FDT_ERR_BADLAYOUT,
+ *  -FDT_ERR_BADMAGIC,
+ *  -FDT_ERR_BADVERSION,
+ *  -FDT_ERR_BADSTATE,
+ *  -FDT_ERR_BADSTRUCTURE,
+ *  -FDT_ERR_BADLAYOUT,
+ *  -FDT_ERR_TRUNCATED, standard meanings
  */
 int fdt_appendprop(void *fdt, int nodeoffset, const char *name,
-		   const void *val, int len);
+           const void *val, int len);
 
 /**
  * fdt_appendprop_u32 - append a 32-bit integer value to a property
@@ -1644,23 +1651,23 @@ int fdt_appendprop(void *fdt, int nodeoffset, const char *name,
  * change the offsets of some existing nodes.
  *
  * returns:
- *	0, on success
- *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to
- *		contain the new property value
- *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_TRUNCATED, standard meanings
+ *  0, on success
+ *  -FDT_ERR_NOSPACE, there is insufficient free space in the blob to
+ *      contain the new property value
+ *  -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
+ *  -FDT_ERR_BADLAYOUT,
+ *  -FDT_ERR_BADMAGIC,
+ *  -FDT_ERR_BADVERSION,
+ *  -FDT_ERR_BADSTATE,
+ *  -FDT_ERR_BADSTRUCTURE,
+ *  -FDT_ERR_BADLAYOUT,
+ *  -FDT_ERR_TRUNCATED, standard meanings
  */
 static inline int fdt_appendprop_u32(void *fdt, int nodeoffset,
-				     const char *name, uint32_t val)
+                     const char *name, uint32_t val)
 {
-	fdt32_t tmp = cpu_to_fdt32(val);
-	return fdt_appendprop(fdt, nodeoffset, name, &tmp, sizeof(tmp));
+    fdt32_t tmp = cpu_to_fdt32(val);
+    return fdt_appendprop(fdt, nodeoffset, name, &tmp, sizeof(tmp));
 }
 
 /**
@@ -1679,23 +1686,23 @@ static inline int fdt_appendprop_u32(void *fdt, int nodeoffset,
  * change the offsets of some existing nodes.
  *
  * returns:
- *	0, on success
- *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to
- *		contain the new property value
- *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_TRUNCATED, standard meanings
+ *  0, on success
+ *  -FDT_ERR_NOSPACE, there is insufficient free space in the blob to
+ *      contain the new property value
+ *  -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
+ *  -FDT_ERR_BADLAYOUT,
+ *  -FDT_ERR_BADMAGIC,
+ *  -FDT_ERR_BADVERSION,
+ *  -FDT_ERR_BADSTATE,
+ *  -FDT_ERR_BADSTRUCTURE,
+ *  -FDT_ERR_BADLAYOUT,
+ *  -FDT_ERR_TRUNCATED, standard meanings
  */
 static inline int fdt_appendprop_u64(void *fdt, int nodeoffset,
-				     const char *name, uint64_t val)
+                     const char *name, uint64_t val)
 {
-	fdt64_t tmp = cpu_to_fdt64(val);
-	return fdt_appendprop(fdt, nodeoffset, name, &tmp, sizeof(tmp));
+    fdt64_t tmp = cpu_to_fdt64(val);
+    return fdt_appendprop(fdt, nodeoffset, name, &tmp, sizeof(tmp));
 }
 
 /**
@@ -1704,9 +1711,9 @@ static inline int fdt_appendprop_u64(void *fdt, int nodeoffset,
  * This is an alternative name for fdt_appendprop_u32()
  */
 static inline int fdt_appendprop_cell(void *fdt, int nodeoffset,
-				      const char *name, uint32_t val)
+                      const char *name, uint32_t val)
 {
-	return fdt_appendprop_u32(fdt, nodeoffset, name, val);
+    return fdt_appendprop_u32(fdt, nodeoffset, name, val);
 }
 
 /**
@@ -1724,20 +1731,20 @@ static inline int fdt_appendprop_cell(void *fdt, int nodeoffset,
  * change the offsets of some existing nodes.
  *
  * returns:
- *	0, on success
- *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to
- *		contain the new property value
- *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_TRUNCATED, standard meanings
+ *  0, on success
+ *  -FDT_ERR_NOSPACE, there is insufficient free space in the blob to
+ *      contain the new property value
+ *  -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
+ *  -FDT_ERR_BADLAYOUT,
+ *  -FDT_ERR_BADMAGIC,
+ *  -FDT_ERR_BADVERSION,
+ *  -FDT_ERR_BADSTATE,
+ *  -FDT_ERR_BADSTRUCTURE,
+ *  -FDT_ERR_BADLAYOUT,
+ *  -FDT_ERR_TRUNCATED, standard meanings
  */
 #define fdt_appendprop_string(fdt, nodeoffset, name, str) \
-	fdt_appendprop((fdt), (nodeoffset), (name), (str), strlen(str)+1)
+    fdt_appendprop((fdt), (nodeoffset), (name), (str), strlen(str)+1)
 
 /**
  * fdt_delprop - delete a property
@@ -1751,15 +1758,15 @@ static inline int fdt_appendprop_cell(void *fdt, int nodeoffset,
  * change the offsets of some existing nodes.
  *
  * returns:
- *	0, on success
- *	-FDT_ERR_NOTFOUND, node does not have the named property
- *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_TRUNCATED, standard meanings
+ *  0, on success
+ *  -FDT_ERR_NOTFOUND, node does not have the named property
+ *  -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
+ *  -FDT_ERR_BADLAYOUT,
+ *  -FDT_ERR_BADMAGIC,
+ *  -FDT_ERR_BADVERSION,
+ *  -FDT_ERR_BADSTATE,
+ *  -FDT_ERR_BADSTRUCTURE,
+ *  -FDT_ERR_TRUNCATED, standard meanings
  */
 int fdt_delprop(void *fdt, int nodeoffset, const char *name);
 
@@ -1777,7 +1784,7 @@ int fdt_delprop(void *fdt, int nodeoffset, const char *name);
  */
 #ifndef SWIG /* Not available in Python */
 int fdt_add_subnode_namelen(void *fdt, int parentoffset,
-			    const char *name, int namelen);
+                const char *name, int namelen);
 #endif
 
 /**
@@ -1794,22 +1801,22 @@ int fdt_add_subnode_namelen(void *fdt, int parentoffset,
  * change the offsets of some existing nodes.
 
  * returns:
- *	structure block offset of the created nodeequested subnode (>=0), on
- *		success
- *	-FDT_ERR_NOTFOUND, if the requested subnode does not exist
- *	-FDT_ERR_BADOFFSET, if parentoffset did not point to an FDT_BEGIN_NODE
- *		tag
- *	-FDT_ERR_EXISTS, if the node at parentoffset already has a subnode of
- *		the given name
- *	-FDT_ERR_NOSPACE, if there is insufficient free space in the
- *		blob to contain the new node
- *	-FDT_ERR_NOSPACE
- *	-FDT_ERR_BADLAYOUT
+ *  structure block offset of the created nodeequested subnode (>=0), on
+ *      success
+ *  -FDT_ERR_NOTFOUND, if the requested subnode does not exist
+ *  -FDT_ERR_BADOFFSET, if parentoffset did not point to an FDT_BEGIN_NODE
+ *      tag
+ *  -FDT_ERR_EXISTS, if the node at parentoffset already has a subnode of
+ *      the given name
+ *  -FDT_ERR_NOSPACE, if there is insufficient free space in the
+ *      blob to contain the new node
+ *  -FDT_ERR_NOSPACE
+ *  -FDT_ERR_BADLAYOUT
  *      -FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_TRUNCATED, standard meanings.
+ *  -FDT_ERR_BADVERSION,
+ *  -FDT_ERR_BADSTATE,
+ *  -FDT_ERR_BADSTRUCTURE,
+ *  -FDT_ERR_TRUNCATED, standard meanings.
  */
 int fdt_add_subnode(void *fdt, int parentoffset, const char *name);
 
@@ -1825,14 +1832,14 @@ int fdt_add_subnode(void *fdt, int parentoffset, const char *name);
  * change the offsets of some existing nodes.
  *
  * returns:
- *	0, on success
- *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_TRUNCATED, standard meanings
+ *  0, on success
+ *  -FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
+ *  -FDT_ERR_BADLAYOUT,
+ *  -FDT_ERR_BADMAGIC,
+ *  -FDT_ERR_BADVERSION,
+ *  -FDT_ERR_BADSTATE,
+ *  -FDT_ERR_BADSTRUCTURE,
+ *  -FDT_ERR_TRUNCATED, standard meanings
  */
 int fdt_del_node(void *fdt, int nodeoffset);
 
@@ -1848,22 +1855,22 @@ int fdt_del_node(void *fdt, int nodeoffset);
  * returns an error.
  *
  * returns:
- *	0, on success
- *	-FDT_ERR_NOSPACE, there's not enough space in the base device tree
- *	-FDT_ERR_NOTFOUND, the overlay points to some inexistant nodes or
- *		properties in the base DT
- *	-FDT_ERR_BADPHANDLE,
- *	-FDT_ERR_BADOVERLAY,
- *	-FDT_ERR_NOPHANDLES,
- *	-FDT_ERR_INTERNAL,
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADOFFSET,
- *	-FDT_ERR_BADPATH,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_TRUNCATED, standard meanings
+ *  0, on success
+ *  -FDT_ERR_NOSPACE, there's not enough space in the base device tree
+ *  -FDT_ERR_NOTFOUND, the overlay points to some inexistant nodes or
+ *      properties in the base DT
+ *  -FDT_ERR_BADPHANDLE,
+ *  -FDT_ERR_BADOVERLAY,
+ *  -FDT_ERR_NOPHANDLES,
+ *  -FDT_ERR_INTERNAL,
+ *  -FDT_ERR_BADLAYOUT,
+ *  -FDT_ERR_BADMAGIC,
+ *  -FDT_ERR_BADOFFSET,
+ *  -FDT_ERR_BADPATH,
+ *  -FDT_ERR_BADVERSION,
+ *  -FDT_ERR_BADSTRUCTURE,
+ *  -FDT_ERR_BADSTATE,
+ *  -FDT_ERR_TRUNCATED, standard meanings
  */
 int fdt_overlay_apply(void *fdt, void *fdto);
 
diff --git a/components/drivers/fdt/src/dtb_access.c b/components/drivers/fdt/src/dtb_access.c
index 71de2989db..e80192e7b4 100644
--- a/components/drivers/fdt/src/dtb_access.c
+++ b/components/drivers/fdt/src/dtb_access.c
@@ -1,10 +1,8 @@
 /*
- * Copyright (c) 2006-2022, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  */
-#define _GNU_SOURCE
-
 #include "libfdt.h"
 #include "dtb_node.h"
 
@@ -324,7 +322,7 @@ void *dtb_node_get_dtb_node_property_value(const struct dtb_node *dtb_node, cons
 
     if (property_size != NULL)
     {
-        *property_size = dtb_property->size;        
+        *property_size = dtb_property->size;
     }
 
     return dtb_property->value;
@@ -450,11 +448,11 @@ int dtb_node_property_match_string(const struct dtb_node *dn, const char *propna
 
 /**
  * of_property_read_string_helper() - Utility helper for parsing string properties
- * @np:		device node from which the property value is to be read.
- * @propname:	name of the property to be searched.
- * @out_strs:	output array of string pointers.
- * @sz:		number of array elements to read.
- * @skip:	Number of strings to skip over at beginning of list.
+ * @np:     device node from which the property value is to be read.
+ * @propname:   name of the property to be searched.
+ * @out_strs:   output array of string pointers.
+ * @sz:     number of array elements to read.
+ * @skip:   Number of strings to skip over at beginning of list.
  *
  * Don't call this function directly. It is a utility helper for the
  * of_property_read_string*() family of functions.
diff --git a/components/drivers/fdt/src/dtb_addr.c b/components/drivers/fdt/src/dtb_addr.c
index e4a296ea7f..5516ff1e6c 100644
--- a/components/drivers/fdt/src/dtb_addr.c
+++ b/components/drivers/fdt/src/dtb_addr.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2022, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -7,51 +7,51 @@
 #include "dtb_node.h"
 
 /* Max address size we deal with */
-#define FDT_MAX_ADDR_CELLS	4
-#define FDT_CHECK_ADDR_COUNT(na)	((na) > 0 && (na) <= FDT_MAX_ADDR_CELLS)
-#define FDT_CHECK_COUNTS(na, ns)	(FDT_CHECK_ADDR_COUNT(na) && (ns) > 0)
+#define FDT_MAX_ADDR_CELLS  4
+#define FDT_CHECK_ADDR_COUNT(na)    ((na) > 0 && (na) <= FDT_MAX_ADDR_CELLS)
+#define FDT_CHECK_COUNTS(na, ns)    (FDT_CHECK_ADDR_COUNT(na) && (ns) > 0)
 
 static void dtb_node_default_count_cells(const struct dtb_node *dn,
-				       int *addrc, int *sizec)
+                       int *addrc, int *sizec)
 {
-	if (addrc)
-		*addrc = dtb_node_n_addr_cells(dn);
-	if (sizec)
-		*sizec = dtb_node_n_size_cells(dn);
+    if (addrc)
+        *addrc = dtb_node_n_addr_cells(dn);
+    if (sizec)
+        *sizec = dtb_node_n_size_cells(dn);
 }
 
 const uint32_t *dtb_node_get_address(const struct dtb_node *dev, int index,
-			     uint64_t *size, unsigned int *flags)
+                 uint64_t *size, unsigned int *flags)
 {
-	const uint32_t *prop;
-	int psize;
-	struct dtb_node *parent;
-	int onesize, i, na, ns;
+    const uint32_t *prop;
+    int psize;
+    struct dtb_node *parent;
+    int onesize, i, na, ns;
 
-	/* Get parent */
-	parent = dtb_node_get_parent(dev);
-	if (parent == NULL)
-		return NULL;
+    /* Get parent */
+    parent = dtb_node_get_parent(dev);
+    if (parent == NULL)
+        return NULL;
 
-	dtb_node_default_count_cells(dev, &na, &ns);
-	if (!FDT_CHECK_ADDR_COUNT(na))
-		return NULL;
+    dtb_node_default_count_cells(dev, &na, &ns);
+    if (!FDT_CHECK_ADDR_COUNT(na))
+        return NULL;
 
-	/* Get "reg" or "assigned-addresses" property */
-	prop = dtb_node_get_dtb_node_property_value(dev, "reg", &psize);
-	if (prop == NULL)
-		return NULL;
-	psize /= 4;
+    /* Get "reg" or "assigned-addresses" property */
+    prop = dtb_node_get_dtb_node_property_value(dev, "reg", &psize);
+    if (prop == NULL)
+        return NULL;
+    psize /= 4;
 
-	onesize = na + ns;
-	for (i = 0; psize >= onesize; psize -= onesize, prop += onesize, i++)
-		if (i == index)
-		{
-			if (size)
-				*size = dtb_node_read_number(prop + na, ns);
-			if (flags)
-				*flags = 0x200;
-			return prop;
-		}
-	return NULL;
-}
\ No newline at end of file
+    onesize = na + ns;
+    for (i = 0; psize >= onesize; psize -= onesize, prop += onesize, i++)
+        if (i == index)
+        {
+            if (size)
+                *size = dtb_node_read_number(prop + na, ns);
+            if (flags)
+                *flags = 0x200;
+            return prop;
+        }
+    return NULL;
+}
diff --git a/components/drivers/fdt/src/dtb_base.c b/components/drivers/fdt/src/dtb_base.c
index d89e5dad9e..d3378a0151 100644
--- a/components/drivers/fdt/src/dtb_base.c
+++ b/components/drivers/fdt/src/dtb_base.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2022, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -189,7 +189,7 @@ const char *dtb_node_get_name(const struct dtb_node *node)
 
 }
 
-struct dtb_node *dtb_node_get_by_phandle(uint phandle)
+struct dtb_node *dtb_node_get_by_phandle(uint32_t phandle)
 {
     if (dtb_node_active())
         return dtb_node_find_node_by_phandle(phandle);
@@ -418,63 +418,63 @@ int dtb_node_set_enabled(const struct dtb_node *node, rt_bool_t value)
  */
 static struct dtb_node *dtb_node_irq_find_parent(struct dtb_node *child)
 {
-	struct dtb_node *p;
-	phandle parent;
+    struct dtb_node *p;
+    phandle parent;
 
-	if (!dtb_node_get(child))
-		return NULL;
-	do
+    if (!dtb_node_get(child))
+        return NULL;
+    do
     {
-		if (dtb_node_read_u32_array(child, "interrupt-parent", &parent, 1))
+        if (dtb_node_read_u32_array(child, "interrupt-parent", &parent, 1))
         {
-			p = dtb_node_get_parent(child);
-		}
+            p = dtb_node_get_parent(child);
+        }
         else
         {
-			p = dtb_node_get_by_phandle(parent);         
-		}
-		dtb_node_put(child);
-		child = p;
-	} while (p && dtb_node_get_property(p, "#interrupt-cells", NULL) == NULL);
+            p = dtb_node_get_by_phandle(parent);
+        }
+        dtb_node_put(child);
+        child = p;
+    } while (p && dtb_node_get_property(p, "#interrupt-cells", NULL) == NULL);
 
-	return p;
+    return p;
 }
 
 int dtb_node_irq_get(struct dtb_node *dev, int index)
 {
-	int rc = 0;
-	struct fdt_phandle_args out_irq;
+    int rc = 0;
+    struct fdt_phandle_args out_irq;
     struct dtb_node *p;
-	uint32_t intsize;
-	int res, i;
+    uint32_t intsize;
+    int res, i;
 
-	p = dtb_node_irq_find_parent(dev);
-	if (p == NULL)
-		return -EINVAL;
-	/* Get size of interrupt specifier */
-	if (dtb_node_read_u32_array(p, "#interrupt-cells", &intsize, 1))
+    p = dtb_node_irq_find_parent(dev);
+    if (p == NULL)
+        return -EINVAL;
+    /* Get size of interrupt specifier */
+    if (dtb_node_read_u32_array(p, "#interrupt-cells", &intsize, 1))
     {
-		res = -EINVAL;
-		goto out;
-	}
+        res = -EINVAL;
+        goto out;
+    }
 
-	debug(" path:%s, parent=%pOF, intsize=%d\n", p->path,p, intsize);
-    
-	/* Copy intspec into irq structure */
-	out_irq.np = p;
-	out_irq.args_count = intsize;
-	for (i = 0; i < intsize; i++)
+    debug(" path:%s, parent=%pOF, intsize=%d\n", p->path,p, intsize);
+
+    /* Copy intspec into irq structure */
+    out_irq.np = p;
+    out_irq.args_count = intsize;
+    for (i = 0; i < intsize; i++)
     {
-		res = dtb_node_read_u32_index(dev, "interrupts",
-						 (index * 3 + i),
-						 out_irq.args + i);
-		if (res)
-			goto out;
-	}
+        res = dtb_node_read_u32_index(dev, "interrupts",
+                         (index * 3 + i),
+                         out_irq.args + i);
+        if (res)
+            goto out;
+    }
     rc = out_irq.args[1];
  out:
-	dtb_node_put(p);
-	return rc;
+    dtb_node_put(p);
+    return rc;
 
 }
 
@@ -489,16 +489,16 @@ int dtb_node_irq_get(struct dtb_node *dev, int index)
  */
 int dtb_node_irq_get_byname(struct dtb_node *dev, const char *name)
 {
-	int index;
+    int index;
 
-	if (!name)
-		return -EINVAL;
+    if (!name)
+        return -EINVAL;
 
-	index = dtb_node_stringlist_search(dev, "interrupt-names", name);
-	if (index < 0)
-		return index;
+    index = dtb_node_stringlist_search(dev, "interrupt-names", name);
+    if (index < 0)
+        return index;
 
-	return dtb_node_irq_get(dev, index);
+    return dtb_node_irq_get(dev, index);
 }
 
 /**
@@ -508,21 +508,21 @@ int dtb_node_irq_get_byname(struct dtb_node *dev, const char *name)
 int dtb_node_irq_count(struct dtb_node *device)
 {
     struct dtb_node *p;
-	uint32_t intsize;
-	int nr = 0, res = 0;
+    uint32_t intsize;
+    int nr = 0, res = 0;
 
-	p = dtb_node_irq_find_parent(device);
-	if (p == NULL)
-		return -EINVAL;
+    p = dtb_node_irq_find_parent(device);
+    if (p == NULL)
+        return -EINVAL;
 
-	/* Get size of interrupt specifier */
-	if (dtb_node_read_u32_array(p, "#interrupt-cells", &intsize, 1))
+    /* Get size of interrupt specifier */
+    if (dtb_node_read_u32_array(p, "#interrupt-cells", &intsize, 1))
     {
-		res = -EINVAL;
-		goto out;
-	}
+        res = -EINVAL;
+        goto out;
+    }
 
-	debug(" path:%s, parent=%pOF, intsize=%d\n", p->path,p, intsize);
+    debug(" path:%s, parent=%pOF, intsize=%d\n", p->path,p, intsize);
 
     res = dtb_node_read_size(device, "interrupts");
     if (res < 0)
@@ -531,7 +531,7 @@ int dtb_node_irq_count(struct dtb_node *device)
     }
     nr = res / (intsize * 4);
  out:
-	dtb_node_put(p);
+    dtb_node_put(p);
 
-	return nr;
-}
\ No newline at end of file
+    return nr;
+}
diff --git a/components/drivers/fdt/src/dtb_load.c b/components/drivers/fdt/src/dtb_load.c
index a6c6dca6f9..ba47c383e9 100644
--- a/components/drivers/fdt/src/dtb_load.c
+++ b/components/drivers/fdt/src/dtb_load.c
@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 #include "libfdt.h"
+#include <stdio.h>
 #include <unistd.h>
 #include "dtb_node.h"