本文主要是介绍Linux设备树学习(二)设备树的传递和使用，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

• 一、uboot与设备树
• 二、Linux与设备树
  • head.S的内容
  • start_kernel的调用过程如下：
  • 内核如何匹配板子
  • 对设备树信息的处理
  • 节点信息转化为device_node 结构体信息：
  • device_node转换为platform_device

参考：https://blog.csdn.net/thisway_diy/article/details/84336817
韦东山设备树文章地址：http://wiki.100ask.org/Linux_devicetree

一、uboot与设备树

bootloader启动内核时,会设置r0,r1,r2三个寄存器,
r0一般设置为0；
r1一般设置为machine id (uboot和Linux中都有专门的文件定义机器码)(在使用设备树时该参数没有被使用)；
r2一般设置ATAGS或DTB的开始地址；

这里的machine id，是让内核知道是哪个CPU，从而调用对应的初始化函数。
以前没有使用设备树时，需要bootloader传一个machine id给内核，现在使用设备树的话，这个参数就不需要设置了！
r2要么是以前的ATAGS开始地址，使用设备树后是DTB文件开始地址！

uboot加载dtb：
可以从flash读取；
或者在线加载，例如 tftpboot 32000000 smdk.dtb，把设备树加载到0x32000000

uboot传递dtb：
bootm 31000000 - 32000000 (uImage地址、文件系统地址、DTB设备树地址)

二、Linux与设备树

head.S的内容

内核head.S所做工作如下：
a. __lookup_processor_type : 使用汇编指令读取CPU ID, 根据该ID找到对应的proc_info_list结构体(里面含有这类CPU的初始化函数、信息)
b. __vet_atags : 判断是否存在可用的ATAGS或DTB
c. __create_page_tables : 创建页表, 即创建虚拟地址和物理地址的映射关系
d. __enable_mmu : 使能MMU, 以后就要使用虚拟地址了
e. __mmap_switched : 上述函数里将会调用__mmap_switched
f. 把bootloader传入的r2参数, 保存到变量__atags_pointer中
g. 调用C函数start_kernel

head.S和head-common.S最终效果：
把bootloader传来的r1值, 赋给了C变量: __machine_arch_type
把bootloader传来的r2值, 赋给了C变量: __atags_pointer
例如：
__atags_pointer = 80000100,__machine_arch_type=1685

start_kernel的调用过程如下：

start_kernel // init/main.c
    setup_arch(&command_line);  // arch/arm/kernel/setup.c
        mdesc = setup_machine_fdt(__atags_pointer);  // arch/arm/kernel/devtree.c
                    early_init_dt_verify(phys_to_virt(dt_phys)  // 判断是否有效的dtb, drivers/of/ftd.c
                                    initial_boot_params = params;
                    mdesc = of_flat_dt_match_machine(mdesc_best, arch_get_next_mach);  // 找到最匹配的machine_desc, drivers/of/ftd.c
                                    while ((data = get_next_compat(&compat))) {
                                        score = of_flat_dt_match(dt_root, compat);
                                        if (score > 0 && score < best_score) {
                                            best_data = data;
                                            best_score = score;
                                        }
                                    }
        machine_desc = mdesc;

内核如何匹配板子

1、不适用设备树时：
uboot传递的machine id 与 内核machine_desc结构体的.nr比较，相等就表示找到了对应的machine_desc。

2、使用设备树时：

	model = "SMDK24440";
	compatible = "samsung,smdk2440"，"samsung,smdk24140"，"samsung,smdk24xx";

使用compatile属性的值, 跟每一个machine_desc.dt_compat 比较,匹配。

static const char *const s3c2416_dt_compat[] __initconst = {
	"samsung,s3c2416",
	"samsung,s3c2450",
	NULL
};

DT_MACHINE_START(S3C2416_DT, "Samsung S3C2416 (Flattened Device Tree)")
	.dt_compat	= s3c2416_dt_compat,
	.map_io		= s3c2416_dt_map_io,
	.init_irq	= irqchip_init,
	.init_machine	= s3c2416_dt_machine_init,
MACHINE_END

扩展为：

static const struct machine_desc __mach_desc_S3C2416_DT __used __attribute__((__section__(".arch.info.init"))) = { 
.nr = ~0, 
.name = "Samsung S3C2416 (Flattened Device Tree)",
.dt_compat	= s3c2416_dt_compat,
.map_io		= s3c2416_dt_map_io,
.init_irq	= irqchip_init,
.init_machine	= s3c2416_dt_machine_init,
}

对设备树信息的处理

start_kernel // init/main.c
    setup_arch(&command_line);  // arch/arm/kernel/setup.c
        mdesc = setup_machine_fdt(__atags_pointer);  // arch/arm/kernel/devtree.c
                    early_init_dt_scan_nodes();      // drivers/of/ftd.c
                        /* Retrieve various information from the /chosen node */
                        of_scan_flat_dt(early_init_dt_scan_chosen, boot_command_line);
                       /* Initialize {size,address}-cells info */
                        of_scan_flat_dt(early_init_dt_scan_root, NULL);
                        /* Setup memory, calling early_init_dt_add_memory_arch */
                        of_scan_flat_dt(early_init_dt_scan_memory, NULL);

总结：
a. /chosen节点中bootargs属性的值, 存入全局变量： boot_command_line
b. 确定根节点的这2个属性的值: #address-cells,#size-cells,存入全局变量: dt_root_addr_cells, dt_root_size_cells
c. 解析/memory中的reg属性, 提取出"base, size", 最终调用memblock_add(base, size);

节点信息转化为device_node 结构体信息：

struct device_node {
	const char *name;  // 来自节点中的name属性, 如果没有该属性, 则设为"NULL"
	const char *type;  // 来自节点中的device_type属性, 如果没有该属性, 则设为"NULL"
	phandle phandle;
	const char *full_name;  // 节点的名字, node-name[@unit-address]
	struct fwnode_handle fwnode;
	struct  property *properties;  // 节点的属性
	struct  property *deadprops;    /* removed properties */
	struct  device_node *parent;   // 节点的父亲
    struct  device_node *child;    // 节点的孩子(子节点)
    struct  device_node *sibling;  // 节点的兄弟(同级节点)
#if defined(CONFIG_OF_KOBJ)
    struct  kobject kobj;
#endif
    unsigned long _flags;
    void    *data;
#if defined(CONFIG_SPARC)
    const char *path_component_name;
    unsigned int unique_id;
    struct of_irq_controller *irq_trans;
#endif
};

device_node结构体表示一个节点，property结构体表示节点的具体属性。
properties结构体的定义如下：

struct property {
	char    *name;    // 属性名字, 指向dtb文件中的字符串
	int length;       // 属性值的长度
	void    *value;   // 属性值, 指向dtb文件中value所在位置, 数据仍以big endian存储
	struct property *next;
#if defined(CONFIG_OF_DYNAMIC) || defined(CONFIG_SPARC)
    unsigned long _flags;
#endif
#if defined(CONFIG_OF_PROMTREE)
	unsigned int unique_id;
#endif
#if defined(CONFIG_OF_KOBJ)
	struct bin_attribute attr;
#endif
};

device_node转换为platform_device

a. 内核函数of_platform_default_populate_init, 遍历device_node树, 生成platform_device
b. 并非所有的device_node都会转换为platform_device只有以下的device_node会转换:
b.1 该节点必须含有compatible属性
b.2 根节点的子节点(节点必须含有compatible属性)
b.3 含有特殊compatible属性的节点的子节点(子节点必须含有compatible属性):
这些特殊的compatilbe属性为: “simple-bus”,“simple-mfd”,“isa”,"arm,amba-bus "
根节点是例外的，生成platfrom_device时，即使有compatible属性也不会处理

/mytest会被转换为platform_device,
因为它兼容"simple-bus", 它的子节点/mytest/mytest@0 也会被转换为platform_device

/i2c节点一般表示i2c控制器, 它会被转换为platform_device, 在内核中有对应的platform_driver;

/i2c/at24c02节点不会被转换为platform_device, 它被如何处理完全由父节点的platform_driver决定, 一般是被创建为一个i2c_client。

类似的也有/spi节点, 它一般也是用来表示SPI控制器, 它会被转换为platform_device, 在内核中有对应的platform_driver;

/spi/flash@0节点不会被转换为platform_device, 它被如何处理完全由父节点的platform_driver决定, 一般是被创建为一个spi_device。

of_platform_default_populate_init (drivers/of/platform.c) 生成platform_device的过程:
遍历device树：

of_platform_default_populate_init
    of_platform_default_populate(NULL, NULL, NULL);
        of_platform_populate(NULL, of_default_bus_match_table, NULL, NULL)
            for_each_child_of_node(root, child) {
                rc = of_platform_bus_create(child, matches, lookup, parent, true);  // 调用过程看下面
                            dev = of_device_alloc(np, bus_id, parent);   // 根据device_node节点的属性设置platform_device的resource
                if (rc) {
                    of_node_put(child);
                    break;
                }
            }

of_platform_bus_create(bus, matches, …)的调用过程(处理bus节点生成platform_devie, 并决定是否处理它的子节点):

        dev = of_platform_device_create_pdata(bus, bus_id, platform_data, parent);  // 生成bus节点的platform_device结构体
        if (!dev || !of_match_node(matches, bus))  // 如果bus节点的compatile属性不吻合matches成表, 就不处理它的子节点
            return 0;
        for_each_child_of_node(bus, child) {    // 取出每一个子节点
            pr_debug("   create child: %pOF\n", child);
            rc = of_platform_bus_create(child, matches, lookup, &dev->dev, strict);   // 处理它的子节点, of_platform_bus_create是一个递归调用
            if (rc) {
                of_node_put(child);
                break;
            }
        }

a. 注册 platform_driver 的过程:

platform_driver_register
    __platform_driver_register
        drv->driver.probe = platform_drv_probe;
        driver_register
            bus_add_driver
                klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers);    // 把 platform_driver 放入 platform_bus_type 的driver链表中
                driver_attach
                    bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);  // 对于plarform_bus_type下的每一个设备, 调用__driver_attach
                        __driver_attach
                            ret = driver_match_device(drv, dev);  // 判断dev和drv是否匹配成功
                                        return drv->bus->match ? drv->bus->match(dev, drv) : 1;  // 调用 platform_bus_type.match
                            driver_probe_device(drv, dev);
                                        really_probe
                                            drv->probe  // platform_drv_probe
                                                platform_drv_probe
                                                    struct platform_driver *drv = to_platform_driver(_dev->driver);
                                                    drv->probe

b. 注册 platform_device 的过程:

platform_device_register
    platform_device_add
        device_add
            bus_add_device
                klist_add_tail(&dev->p->knode_bus, &bus->p->klist_devices); // 把 platform_device 放入 platform_bus_type的device链表中
            bus_probe_device(dev);
                device_initial_probe
                    __device_attach
                        ret = bus_for_each_drv(dev->bus, NULL, &data, __device_attach_driver); // // 对于plarform_bus_type下的每一个driver, 调用 __device_attach_driver
                                    __device_attach_driver
                                        ret = driver_match_device(drv, dev);
                                                    return drv->bus->match ? drv->bus->match(dev, drv) : 1;  // 调用platform_bus_type.match
                                        driver_probe_device

匹配函数是platform_bus_type.match, 即platform_match,
匹配过程按优先顺序罗列如下:

比较 platform_dev.driver_override 和 platform_driver.drv->name
比较 platform_dev.dev.of_node的compatible属性 和 platform_driver.drv->of_match_table
比较 platform_dev.name 和 platform_driver.id_table
比较 platform_dev.name 和 platform_driver.drv->name
有一个成功, 即匹配成功

这篇关于Linux设备树学习(二)设备树的传递和使用的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！