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 fdt_node_header  {

    fdt32_t  tag;

    char  name[0];

};

struct  fdt_property  {

    fdt32_t  tag;

    fdt32_t  len;

    fdt32_t  nameoff;

    char  data[0];

};

#define FDT_BEGIN_NODE   0x1    /*  Start node: full name */

#define FDT_END_NODE  0x2    /*  End node */

#define FDT_PROP          0x3    /*  Property: name off, size, content */

#define FDT_NOP            0x4    /* nop */

#define FDT_END            0x9

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;

       }

       if  (strcmp(pname, "name") == 0)

           has_name  = 1;

       pp  = unflatten_dt_alloc(&mem, sizeof(struct property),

                  __alignof__(struct  property));

       if  (!dryrun) {

           /*  We accept flattened tree phandles either in

            * ePAPR-style "phandle"  properties, or the

            * legacy "linux,phandle"  properties.  If both

            * appear and have different values, things

            * will get weird.  Don't do that. */

           /*  處理phandle，得到phandle值 */

           if  ((strcmp(pname, "phandle") == 0) ||

               (strcmp(pname, "linux,phandle")  == 0)) {

              if  (np->phandle == 0)

                  np->phandle  = be32_to_cpup(p);

           }

           /*  And we process the "ibm,phandle" property

            * used in pSeries dynamic device tree

            * stuff */

           if  (strcmp(pname, "ibm,phandle") == 0)

              np->phandle  = be32_to_cpup(p);

           pp->name  = (char *)pname;

           pp->length  = sz;

           pp->value  = (__be32 *)p;

           *prev_pp  = pp;

           prev_pp  = &pp->next;

       }

    }

    /*  with version 0x10 we may not have the name property, recreate

     * it here from the unit name if absent

     */

    /*  為每個node節點新增一個name的屬性 */

    if  (!has_name) {

       const  char *p1 = pathp, *ps = pathp, *pa = NULL;

       int  sz;

       /*  屬性name的value值為node節點的名稱，取“/”和“@”之間的子串 */

       while  (*p1) {