Linux DeviceTree学习（三）

傷城~ 2021-12-12 23:23 429阅读 0赞

# Linux DeviceTree学习（三） #

## 4 Linux Kernel匹配设备树 ##

### 4.1 Kernel使能device tree ###

Boot options  --->
    [*] Flattened Device Tree support  
    (0) Compressed ROM boot loader base address
    (0) Compressed ROM boot loader BSS address
    [ ] Use appended device tree blob to zImage (EXPERIMENTAL)

### 4.2 Kernel 解析Device Tree ###

Kernel会根据Device Tree的struct fdt\_header、struct fdt\_node\_header及struct fdt\_property三个结构体的信息填充至Kernel能够使用的struct property结构体，该结构体描述如下：

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文件系统挂接 */
    };

### 4.2.1 Kernel解析流程 ###

kernel的C语言阶段的入口函数是init/main.c/stsrt\_kernel()函数，在early\_init\_dt\_scan\_nodes()中会做以下三件事：

*  (1) 扫描/chosen或者/chose@0节点下面的bootargs属性值到boot\_command\_line，此外，还处理initrd相关的property，并保存在initrd\_start和initrd\_end这两个全局变量中；
 *  (2) 扫描根节点下面，获取\{size,address\}-cells信息，并保存在dt\_root\_size\_cells和dt\_root\_addr\_cells全局变量中；
 *  (3) 扫描具有device\_type = “memory”属性的/memory或者/memory@0节点下面的reg属性值，并把相关信息保存在meminfo中，全局变量meminfo保存了系统内存相关的信息。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM4MzY5MDk_size_16_color_FFFFFF_t_70]
 *  Device Tree中的每一个node节点经过kernel处理都会生成一个struct device\_node的结构体，struct device\_node最终一般会被挂接到具体的struct device结构体。struct device\_node结构体描述如下：
    
        struct device_node  {
              const  char *name;        /* node的名称，取最后一次“/”和“@”之间子串 */
              const  char *type;       /* device_type的属性名称，没有为<NULL> */
          phandle  phandle;      /* phandle属性值 */
          /* 指向该结构体结束的位置，存放node的路径全名，例如：/chosen */
          const  char *full_name;
          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;
          };

#### 4.2.2 setup\_machine\_fdt( ) ####

在Linux4.14.14内核中，首先使用setup\_machine\_fdt来setup machine描述符，如果返回NULL，才使用传统的方法setup\_machine\_tags来setup machine描述符。传统的方法需要给出\_\_machine\_arch\_type（bootloader通过r1寄存器传递给kernel的）和tag list的地址（用来进行tag parse）。\_\_machine\_arch\_type用来寻找machine描述符；tag list用于运行时参数的传递。

/**
     * setup_machine_fdt - Machine setup when an dtb was passed to the kernel
     * @dt_phys: physical address of dt blob
     *
     * If a dtb was passed to the kernel in r2, then use it to choose the
     * correct machine_desc and to setup the system.
     */
    const struct machine_desc * __init setup_machine_fdt(unsigned int dt_phys)
    {
    	const struct machine_desc *mdesc, *mdesc_best = NULL;
    
    #if defined(CONFIG_ARCH_MULTIPLATFORM) || defined(CONFIG_ARM_SINGLE_ARMV7M)
    	DT_MACHINE_START(GENERIC_DT, "Generic DT based system")
    		.l2c_aux_val = 0x0,
    		.l2c_aux_mask = ~0x0,
    	MACHINE_END
    
    	mdesc_best = &__mach_desc_GENERIC_DT;
    #endif
    
    	if (!dt_phys || !early_init_dt_verify(phys_to_virt(dt_phys)))
    		return NULL;
    
    	//获取machine描述符
    	mdesc = of_flat_dt_match_machine(mdesc_best, arch_get_next_mach);
    
    	if (!mdesc) {
    		const char *prop;
    		int size;
    		unsigned long dt_root;
    
    		early_print("\nError: unrecognized/unsupported "
    			    "device tree compatible list:\n[ ");
    
    		dt_root = of_get_flat_dt_root();
    		prop = of_get_flat_dt_prop(dt_root, "compatible", &size);
    		while (size > 0) {
    			early_print("'%s' ", prop);
    			size -= strlen(prop) + 1;
    			prop += strlen(prop) + 1;
    		}
    		early_print("]\n\n");
    
    		dump_machine_table(); /* does not return */
    	}
    
    	/* We really don't want to do this, but sometimes firmware provides buggy data */
    	if (mdesc->dt_fixup)
    		mdesc->dt_fixup();
    
    	//两个功能：为后续的DTB Scan进行准备工作，获取运行时参数bootarg传递
    	early_init_dt_scan_nodes();
    
    	/* Change machine number to match the mdesc we're using */
    	__machine_arch_type = mdesc->nr;
    
    	return mdesc;
    }

#### 4.2.3 early\_init\_dt\_scan\_nodes( ) ####

运行时参数bootarg是在扫描DTB的chosen node时候完成的，具体的工作就是获取chosen node的bootargs、initrd等属性的value，并将其保存到全局变量（boot\_command\_line、initrd\_start、initrd\_end）中。

void __init early_init_dt_scan_nodes(void)
    {
        /* 扫描 /chosen node，保存运行时参数（bootargs）
        到boot_command_line， 此外，还处理initrd相关的property，
        并保存在initrd_start和initrd_end这两个全局变量中 */
    	of_scan_flat_dt(early_init_dt_scan_chosen, boot_command_line);
    
    	/* 扫描根节点，获取 {size,address}-cells信息，
    	并保存在dt_root_size_cells和dt_root_addr_cells全局变量中 */
    	of_scan_flat_dt(early_init_dt_scan_root, NULL);
    
       	/* 扫描DTB中的memory node，并把相关信息保存在meminfo中，
       	全局变量meminfo保存了系统内存相关的信息。*/
    	of_scan_flat_dt(early_init_dt_scan_memory, NULL);
    }

#### 4.2.4 unflatten\_device\_tree( ) ####

Device Tree的解析首先从unflatten\_device\_tree()开始，代码列出如下：

/**
     * 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()中，调用函数\_\_unflatten\_device\_tree()，参数initial\_boot\_params指向Device Tree在内存中的首地址，of\_root在经过该函数处理之后，会指向根节点，early\_init\_dt\_alloc\_memory\_arch是一个函数指针，为struct device\_node和struct property结构体分配内存的回调函数（callback）。

### 4.2.5 \_\_unflatten\_device\_tree( ) ###

/**
     * __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,	//需要扫描的DTB
                    struct device_node **mynodes,		//global list指针
                    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\_device\_tree()函数中，两次调用unflatten\_dt\_node()函数，第一次是为了得到Device Tree转换成struct device\_node和struct property结构体需要分配的内存大小，第二次调用才是具体填充每一个struct device\_node和struct property结构体。

#### 4.2.6 unflatten\_dt\_node( ) ####

/**
     * 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) {
               if  ((*p1) == '@')
                  pa  = p1;
               if  ((*p1) == '/')
                  ps  = p1 + 1;
               p1++;
           }
           
           if  (pa < ps)
               pa  = p1;
               
           sz  = (pa - ps) + 1;
           pp  = unflatten_dt_alloc(&mem, sizeof(struct property) + sz,
                      __alignof__(struct  property));
           if  (!dryrun) {
               pp->name  = "name";
               pp->length  = sz;
               pp->value  = pp + 1;
               *prev_pp  = pp;
               prev_pp  = &pp->next;
               memcpy(pp->value,  ps, sz - 1);
               ((char  *)pp->value)[sz - 1] = 0;
           }
        }
        
        /*  填充device_node结构体中的name和type成员 */
        if  (!dryrun) {
           *prev_pp  = NULL;
           np->name  = of_get_property(np, "name", NULL);
           np->type  = of_get_property(np, "device_type", NULL);
     
           if  (!np->name)
               np->name  = "<NULL>";
           if  (!np->type)
               np->type  = "<NULL>";
        }
     
        old_depth  = depth;
        *poffset  = fdt_next_node(blob, *poffset, &depth);
        if  (depth < 0)
           depth  = 0;
           
        /*  递归调用node节点下面的子节点 */
        while  (*poffset > 0 && depth > old_depth)
           mem  = unflatten_dt_node(blob, mem, poffset, np, NULL,
                      fpsize,  dryrun);
     
        if  (*poffset < 0 && *poffset != -FDT_ERR_NOTFOUND)
           pr_err("unflatten:  error %d processing FDT\n", *poffset);
     
        /*
         * Reverse the child list. Some drivers  assumes node order matches .dts
         * node order
         */
        if  (!dryrun && np->child) {
           struct  device_node *child = np->child;
           np->child  = NULL;
           while  (child) {
               struct  device_node *next = child->sibling;
               child->sibling  = np->child;
               np->child  = child;
               child  = next;
           }
        }
     
        if  (nodepp)
           *nodepp  = np;
     
        return  mem;
    }

*  通过以上函数处理就得到了所有的struct device\_node结构体，为每一个node都会自动添加一个名称为“name”的property，property.length的值为当前node的名称取最后一个“/”和“@”之间的子串（包括‘\\0’）。例如：/serial@e2900800，则length = 7，property.value = device\_node.name = “serial”。

### 4.3 platform\_device和device\_node绑定 ###

machine初始化的代码可以沿着start\_kernel->rest\_init->kernel\_init->kernel\_init\_freeable->do\_basic\_setup->do\_initcalls路径寻找。在do\_initcalls函数中，kernel会依次执行各个initcall函数，在这个过程中，会调用customize\_machine，具体如下：

static int __init customize_machine(void)
    {
    	/*
    	 * customizes platform devices, or adds new ones
    	 * On DT based machines, we fall back to populating the
    	 * machine from the device tree, if no callback is provided,
    	 * otherwise we would always need an init_machine callback.
    	 */
    	if (machine_desc->init_machine)
    		machine_desc->init_machine();
    
    	return 0;
    }

*  经过以上解析，DeviceTree的数据已经全部解析出具体的struct device\_node和struct property结构体，下面需要和具体的device进行绑定。首先讲解platform\_device和device\_node的绑定过程。在arch/arm/kernel/setup.c文件中，customize\_machine()函数负责填充struct platform\_device结构体。platform\_device生成函数调用过程如下图所示：  
    ![在这里插入图片描述][20190712225500299.png]

onst struct of_device_id  of_default_bus_match_table[ ] = {
        {  .compatible = "simple-bus", },
        {  .compatible = "simple-mfd", },
    #ifdef CONFIG_ARM_AMBA
        {  .compatible = "arm,amba-bus", },
    #endif /* CONFIG_ARM_AMBA */
        {}  /* Empty terminated list */
    };

4.3.1 of\_platform\_populate( )  
int of\_platform\_populate(struct device\_node \*root,  
const struct of\_device\_id \*matches,  
const struct of\_dev\_auxdata \*lookup,  
struct device \*parent)  
\{  
struct device\_node \*child;  
int rc = 0;

/*  获取根节点 */
    root  = root ? of_node_get(root) : of_find_node_by_path("/");
    if  (!root)
       return  -EINVAL;
    
    /*  为根节点下面的每一个节点创建platform_device结构体 */
    for_each_child_of_node(root,  child) {
       rc  = of_platform_bus_create(child, matches, lookup, parent, true);
       if  (rc) {
           of_node_put(child);
           break;
       }
    }
    /*  更新device_node flag标志位 */
    of_node_set_flag(root,  OF_POPULATED_BUS);
    
    of_node_put(root);
    return  rc;

#### 4.3.2 of\_platform\_bus\_create( ) ####

static int of_platform_bus_create(struct  device_node *bus,	//要创建的那个device node
                    const struct of_device_id *matches,		//要匹配的list
                    const struct of_dev_auxdata *lookup,		//附属数据
                 struct device *parent, bool strict)//parent指向父节点，strict是否要求完全匹配
    {
        const  struct of_dev_auxdata *auxdata;
        struct  device_node *child;
        struct  platform_device *dev;
        const  char *bus_id = NULL;
        void  *platform_data = NULL;
        int  rc = 0;
     
        /*  只有包含"compatible"属性的node节点才会生成相应的platform_device结构体 */
        /*  Make sure it has a compatible property */
        if  (strict && (!of_get_property(bus, "compatible", NULL))) {
           return  0;
        }
        /*  省略部分代码 */
        /*  
         * 针对节点下面得到status = "ok" 或者status = "okay"或者不存在status属性的
         * 节点分配内存并填充platform_device结构体
         */
        dev  = of_platform_device_create_pdata(bus, bus_id, platform_data, parent);
        if  (!dev || !of_match_node(matches, bus))
           return  0;
     
    /* 递归调用节点解析函数，为子节点继续生成platform_device结构体，前提是父节点
    * 的”compatible”=”simple-bus”，也就是匹配of_default_bus_match_table结构体中的数据
    */
        for_each_child_of_node(bus,  child) {
           rc  = of_platform_bus_create(child, matches, lookup, &dev->dev, strict);
           if  (rc) {
               of_node_put(child);
               break;
           }
        }
        of_node_set_flag(bus,  OF_POPULATED_BUS);
        return  rc;
    }

#### 4.3.3 of\_platform\_device\_create\_pdata( ) ####

/**
     * of_platform_device_create_pdata - Alloc, initialize and register an of_device
     * @np: pointer to node to create device for
     * @bus_id: name to assign device
     * @platform_data: pointer to populate platform_data pointer with
     * @parent: Linux device model parent device.
     *
     * Returns pointer to created platform device, or NULL if a device was not
     * registered.  Unavailable devices will not get registered.
     */
    static struct platform_device *of_platform_device_create_pdata(
    					struct device_node *np,
    					const char *bus_id,
    					void *platform_data,
    					struct device *parent)
    {
    	struct platform_device *dev;
    /*  
         * 针对节点下面得到status = "ok" 或者status = "okay"或者不存在status属性的
         * 节点分配内存并填充platform_device结构体
         */
    	if (!of_device_is_available(np) ||
    	    of_node_test_and_set_flag(np, OF_POPULATED))
    		return NULL;
    
    	dev = of_device_alloc(np, bus_id, parent);
    	if (!dev)
    		goto err_clear_flag;
    
    	//配置platform_device中的其他成员
    	dev->dev.bus = &platform_bus_type;
    	dev->dev.platform_data = platform_data;
    	of_msi_configure(&dev->dev, dev->dev.of_node);
    
    	//把platform_device加入统一的设备模型系统中
    	if (of_device_add(dev) != 0) {
    		platform_device_put(dev);
    		goto err_clear_flag;
    	}
    
    	return dev;
    
    err_clear_flag:
    	of_node_clear_flag(np, OF_POPULATED);
    	return NULL;
    }

*  总的来说，当of\_platform\_populate()函数执行完毕，kernel就为DTB中所有包含compatible属性名的第一级node创建platform\_device结构体，并向平台设备总线注册设备信息。如果第一级node的compatible属性值等于“simple-bus”、“simple-mfd”或者"arm,amba-bus"的话，kernel会继续为当前node的第二级包含compatible属性的node创建platform\_device结构体，并注册设备。Linux系统下的设备大多都是挂载在平台总线下的，因此在平台总线被注册后，会根据of\_root节点的树结构，去寻找该总线的子节点，所有的子节点将被作为设备注册到该总线上。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM4MzY5MDk_size_16_color_FFFFFF_t_70]: /images/20211210/64fb2c6f848346d6a91fcfded4ce7ecc.png
[20190712225500299.png]: /images/20211210/0eb42fe359be43b185a307374d904156.png