struct fdt_header {	
    fdt32_t magic;			     /* magic word FDT_MAGIC */	
    fdt32_t totalsize;		     /* total size of DT block */	
    fdt32_t off_dt_struct;		 /* offset to structure */	
    fdt32_t off_dt_strings;		 /* offset to strings */	
    fdt32_t off_mem_rsvmap;		 /* offset to memory reserve map */	
    fdt32_t version;		      /* format version */	
    fdt32_t last_comp_version;	 /* last compatible version */ 	/* version 2 fields below */	
    fdt32_t boot_cpuid_phys;	 /* Which physical CPU id we're booting on */	/* version 3 fields below */	fdt32_t size_dt_strings;	 /* size of the strings block */ 	/* version 17 fields below */	
    fdt32_t size_dt_struct;		 /* size of the structure block */
};

struct property {	
    char *name;                          /* property full name */	
    int length;                          /* property value length */	
    void *value;                         /* property value */	
    struct property *next;             /* next property under the same node */	
    unsigned long _flags;	
    unsigned int unique_id;	
    struct bin_attribute attr;        /* 属性文件，与sysfs文件系统挂接 */
};

struct device_node {	
    const char *name;              /* node的名称，取最后一次“/”和“@”之间子串 */	
    const char *type;              /* device_type的属性名称，没有为<NULL> */	
    phandle phandle;               /* phandle属性值 */	
    const char *full_name;        /* 指向该结构体结束的位置，存放node的路径全名，例如：/chosen */	
    struct fwnode_handle fwnode; 	
    struct	property *properties;  /* 指向该节点下的第一个属性，其他属性与该属性链表相接 */	
    struct	property *deadprops;   /* removed properties */
    struct	device_node *parent;   /* 父节点 */	
    struct	device_node *child;    /* 子节点 */	
    struct	device_node *sibling;  /* 姊妹节点，与自己同等级的node */	
    struct	kobject kobj;            /* sysfs文件系统目录体现 */	
    unsigned long _flags;          /* 当前node状态标志位，见/include/linux/of.h line124-127 */	
    void	*data;
}; /* flag descriptions (need to be visible even when !CONFIG_OF) */
#define OF_DYNAMIC        1 /* node and properties were allocated via kmalloc */
#define OF_DETACHED       2 /* node has been detached from the device tree*/
#define OF_POPULATED      3 /* device already created for the node */
#define OF_POPULATED_BUS  4 /* of_platform_populate recursed to children of this node */

/** * unflatten_device_tree - create tree of device_nodes from flat blob * * unflattens the device-tree passed by the firmware, creating the * tree of struct device_node. It also fills the "name" and "type" * pointers of the nodes so the normal device-tree walking functions * can be used. */
void __init unflatten_device_tree(void){	
    __unflatten_device_tree(initial_boot_params, &of_root,early_init_dt_alloc_memory_arch); 	/* Get pointer to "/chosen" and "/aliases" nodes for use everywhere */			          of_alias_scan(early_init_dt_alloc_memory_arch);
} /** * __unflatten_device_tree - create tree of device_nodes from flat blob * * unflattens a device-tree, creating the * tree of struct device_node. It also fills the "name" and "type" * pointers of the nodes so the normal device-tree walking functions * can be used. * @blob: The blob to expand * @mynodes: The device_node tree created by the call * @dt_alloc: An allocator that provides a virtual address to memory * for the resulting tree */
static void __unflatten_device_tree(const void *blob,struct device_node **mynodes,void * (*dt_alloc)(u64 size, u64 align))
{	
    unsigned long size;	
    int start;	
    void *mem;     /* 省略部分不重要部分 */	/* First pass, scan for size */	
    start = 0;	
    size = (unsigned long)unflatten_dt_node(blob, NULL, &start, NULL, NULL, 0, true);	
    size = ALIGN(size, 4); 	/* Allocate memory for the expanded device tree */	
    mem = dt_alloc(size + 4, __alignof__(struct device_node));	
    memset(mem, 0, size); 	/* Second pass, do actual unflattening */	
    start = 0;	
    unflatten_dt_node(blob, mem, &start, NULL, mynodes, 0, false);
}

/** * unflatten_dt_node - Alloc and populate a device_node from the flat tree * @blob: The parent device tree blob * @mem: Memory chunk to use for allocating device nodes and properties * @poffset: pointer to node in flat tree * @dad: Parent struct device_node * @nodepp: The device_node tree created by the call * @fpsize: Size of the node path up at the current depth. * @dryrun: If true, do not allocate device nodes but still calculate needed * memory size */
static void * unflatten_dt_node(const void *blob,	void *mem,int *poffset,	struct device_node *dad,				struct device_node **nodepp,unsigned long fpsize,	bool dryrun)
{	
    const __be32 *p;	
    struct device_node *np;	
    struct property *pp, **prev_pp = NULL;	
    const char *pathp;	
    unsigned int l, allocl;	
    static int depth;	
    int old_depth;	
    int offset;	
    int has_name = 0;	
    int new_format = 0; 	/* 获取node节点的name指针到pathp中 */	
    pathp = fdt_get_name(blob, *poffset, &l);	
    if (!pathp)		
        return mem; 	
    allocl = ++l; 	/* version 0x10 has a more compact unit name here instead of the full	 * path. we accumulate the full path size using "fpsize", we'll rebuild	 * it later. We detect this because the first character of the name is	 * not '/'.	 */	
    if ((*pathp) != '/') {		
        new_format = 1;		
        if (fpsize == 0) {			/* root node: special case. fpsize accounts for path* plus terminating zero. root node only has '/', so			 * fpsize should be 2, but we want to avoid the first			 * level nodes to have two '/' so we use fpsize 1 here			 */			
            fpsize = 1;			
            allocl = 2;			
            l = 1;			
            pathp = "";		
        } else {			/* account for '/' and path size minus terminal 0			 * already in 'l'			 */		fpsize += l;			
                allocl = fpsize;		
         }	
    } 	/* 分配struct device_node内存，包括路径全称大小 */	
    np = unflatten_dt_alloc(&mem, sizeof(struct device_node) + allocl,	__alignof__(struct device_node));	     if (!dryrun) {		
        char *fn;		
        of_node_init(np); 		/* 填充full_name，full_name指向该node节点的全路径名称字符串 */		
        np->full_name = fn = ((char *)np) + sizeof(*np);		
        if (new_format) {			/* rebuild full path for new format */			
            if (dad && dad->parent) {				
                strcpy(fn, dad->full_name);				
                fn += strlen(fn);			
            }			
            *(fn++) = '/';		
        }		
        memcpy(fn, pathp, l); 		/* 节点挂接到相应的父节点、子节点和姊妹节点 */		
        prev_pp = &np->properties;		
        if (dad != NULL) {			
            np->parent = dad;			
            np->sibling = dad->child;			
            dad->child = np;		
        }	
    }	/* 处理该node节点下面所有的property */	
    for (offset = fdt_first_property_offset(blob, *poffset);(offset >= 0);(offset = fdt_next_property_offset(blob, offset))) {		
        const char *pname;		
        u32 sz; 		
        if (!(p = fdt_getprop_by_offset(blob, offset, &pname, &sz))) 
        {			
            offset = -FDT_ERR_INTERNAL;			
            break;		
        } 		
        if (pname == NULL) {			
            pr_info("Can't find property name in list !\n");			
            break;		
        }	
        .......
}