linux设备驱动(20)设备树详解4-kernel解析dts

r0一般设置为0；
r1一般设置为machine id (在使用设备树时该参数没有被使用)；
r2一般设置ATAGS或DTB的开始地址；

 1 ENTRY(stext)
 2  ARM_BE8(setend    be )            @ ensure we are in BE8 mode
 3 
 4  THUMB(    adr    r9, BSYM(1f)    )    @ Kernel is always entered in ARM.
 5  THUMB(    bx    r9        )    @ If this is a Thumb-2 kernel,
 6  THUMB(    .thumb            )    @ switch to Thumb now.
 7  THUMB(1:            )
 8 
 9 #ifdef CONFIG_ARM_VIRT_EXT
10     bl    __hyp_stub_install
11 #endif
12     @ ensure svc mode and all interrupts masked
13     safe_svcmode_maskall r9
14 
15     mrc    p15, 0, r9, c0, c0        @ get processor id
16     bl    __lookup_processor_type        @ r5=procinfo r9=cpuid
17     movs    r10, r5                @ invalid processor (r5=0)?
18  THUMB( it    eq )        @ force fixup-able long branch encoding
19     beq    __error_p            @ yes, error 'p'
20 
21 #ifdef CONFIG_ARM_LPAE
22     mrc    p15, 0, r3, c0, c1, 4        @ read ID_MMFR0
23     and    r3, r3, #0xf            @ extract VMSA support
24     cmp    r3, #5                @ long-descriptor translation table format?
25  THUMB( it    lo )                @ force fixup-able long branch encoding
26     blo    __error_lpae            @ only classic page table format
27 #endif
28 
29 #ifndef CONFIG_XIP_KERNEL
30     adr    r3, 2f
31     ldmia    r3, {r4, r8}
32     sub    r4, r3, r4            @ (PHYS_OFFSET - PAGE_OFFSET)
33     add    r8, r8, r4            @ PHYS_OFFSET
34 #else
35     ldr    r8, =PLAT_PHYS_OFFSET        @ always constant in this case
36 #endif
37 
38     /*
39      * r1 = machine no, r2 = atags or dtb,
40      * r8 = phys_offset, r9 = cpuid, r10 = procinfo
41      */
42     bl    __vet_atags
43 #ifdef CONFIG_SMP_ON_UP
44     bl    __fixup_smp
45 #endif
46 #ifdef CONFIG_ARM_PATCH_PHYS_VIRT
47     bl    __fixup_pv_table
48 #endif
49     bl    __create_page_tables
50 
51     /*
52      * The following calls CPU specific code in a position independent
53      * manner.  See arch/arm/mm/proc-*.S for details.  r10 = base of
54      * xxx_proc_info structure selected by __lookup_processor_type
55      * above.  On return, the CPU will be ready for the MMU to be
56      * turned on, and r0 will hold the CPU control register value.
57      */
58     ldr    r13, =__mmap_switched        @ address to jump to after
59                         @ mmu has been enabled
60     adr    lr, BSYM(1f)            @ return (PIC) address
61     mov    r8, r4                @ set TTBR1 to swapper_pg_dir
62  ARM(    add    pc, r10, #PROCINFO_INITFUNC    )
63  THUMB(    add    r12, r10, #PROCINFO_INITFUNC    )
64  THUMB(    ret    r12                )
65 1:    b    __enable_mmu
66 ENDPROC(stext)
67     .ltorg
68 #ifndef CONFIG_XIP_KERNEL
69 2:    .long    .
70     .long    PAGE_OFFSET
71 #endif

 1 asmlinkage __visible void __init start_kernel(void)
 2 {
 3     char *command_line;
 4     char *after_dashes;
 5 
 6     set_task_stack_end_magic(&init_task);
 7     smp_setup_processor_id();
 8     debug_objects_early_init();
 9 
10     /*
11      * Set up the the initial canary ASAP:
12      */
13     boot_init_stack_canary();
14 
15     cgroup_init_early();
16 
17     local_irq_disable();
18     early_boot_irqs_disabled = true;
19 
20 /*
21  * Interrupts are still disabled. Do necessary setups, then
22  * enable them
23  */
24     boot_cpu_init();
25     page_address_init();
26     pr_notice("%s", linux_banner);
27     setup_arch(&command_line);//设置架构相关的内容
28 
29     ...
30 
31 }

 1 void __init setup_arch(char **cmdline_p)
 2 {
 3     const struct machine_desc *mdesc;
 4 
 5     setup_processor();
 6     mdesc = setup_machine_fdt(__atags_pointer);__atags_pointer是一个物理地址，即__atags_pointer 是一个指针
 7     if (!mdesc)
 8         mdesc = setup_machine_tags(__atags_pointer, __machine_arch_type);//从dts中找到对应的设备描述结构体
 9     machine_desc = mdesc;
10     machine_name = mdesc->name;
11     ...
12 
13     unflatten_device_tree();//根据设备描述结构体生成对应设备节点结构体
14         ...
15 }

1 struct machine_desc {
2 ...
3     unsigned int        nr;        /* architecture number    */
4     const char        *name;        /* architecture name    */
5     unsigned long        atag_offset;    /* tagged list (relative) */
6     const char *const     *dt_compat;    /* array of device tree
7 ...
8 }

 1 const struct machine_desc * __init setup_machine_fdt(unsigned int dt_phys)
 2 {
 3     const struct machine_desc *mdesc, *mdesc_best = NULL;
 4     if (!dt_phys || !early_init_dt_verify(phys_to_virt(dt_phys)))//phys_to_virt 字面上的意思是物理地址转换成虚拟地址
 5         return NULL;
 6 
 7     mdesc = of_flat_dt_match_machine(mdesc_best, arch_get_next_mach);
 8 
 9     if (!mdesc) {
10         const char *prop;
11         int size;
12         unsigned long dt_root;
13 
14         early_print("nError: unrecognized/unsupported "
15                 "device tree compatible list:n[ ");
16 
17         dt_root = of_get_flat_dt_root();
18         prop = of_get_flat_dt_prop(dt_root, "compatible", &size);
19         while (size > 0) {
20             early_print("'%s' ", prop);
21             size -= strlen(prop) + 1;
22             prop += strlen(prop) + 1;
23         }
24         early_print("]nn");
25 
26         dump_machine_table(); /* does not return */
27     }
28 
29     /* We really don't want to do this, but sometimes firmware provides buggy data */
30     if (mdesc->dt_fixup)
31         mdesc->dt_fixup();
32 
33     early_init_dt_scan_nodes();
34 
35     /* Change machine number to match the mdesc we're using */
36     __machine_arch_type = mdesc->nr;
37 
38     return mdesc;
39 }

 1 static const void * __init arch_get_next_mach(const char *const **match)
 2 {
 3     static const struct machine_desc *mdesc = __arch_info_begin;
 4     const struct machine_desc *m = mdesc;
 5 
 6     if (m >= __arch_info_end)
 7         return NULL;
 8 
 9     mdesc++;
10     *match = m->dt_compat;
11     return m;
12 }

 1 void __init early_init_dt_scan_nodes(void)
 2 {
 3     /* Retrieve various information from the /chosen node */
 4     of_scan_flat_dt(early_init_dt_scan_chosen, boot_command_line);
 5 
 6     /* Initialize {size,address}-cells info */
 7     of_scan_flat_dt(early_init_dt_scan_root, NULL);
 8 
 9     /* Setup memory, calling early_init_dt_add_memory_arch */
10     of_scan_flat_dt(early_init_dt_scan_memory, NULL);
11 }

chosen {
        bootargs = "earlycon=sprd_serial,0x70100000,115200n8 loglevel=8 console=ttyS1,115200n8 init=/init root=/dev/ram0 rw androidboot.hardware=sc9830";
        linux,initrd-start = <0x85500000>;
        linux,initrd-end = <0x855a3212>;
    };

 1 void __init early_init_fdt_scan_reserved_mem(void)
 2 {
 3     int n;
 4     u64 base, size;
 5 
 6     if (!initial_boot_params)
 7         return;
 8 
 9     /* Reserve the dtb region */
10     early_init_dt_reserve_memory_arch(__pa(initial_boot_params),
11                       fdt_totalsize(initial_boot_params),
12                       0);
13 
14     /* Process header /memreserve/ fields */
15     for (n = 0; ; n++) {
16         fdt_get_mem_rsv(initial_boot_params, n, &base, &size);
17         if (!size)
18             break;
19         early_init_dt_reserve_memory_arch(base, size, 0);
20     }
21 
22     of_scan_flat_dt(__fdt_scan_reserved_mem, NULL);
23     fdt_init_reserved_mem();
24 }

1 void __init unflatten_device_tree(void)
2 {
3     __unflatten_device_tree(initial_boot_params, NULL, &of_root,
4                 early_init_dt_alloc_memory_arch, false);
5 
6     /* Get pointer to "/chosen" and "/aliases" nodes for use everywhere */
7     of_alias_scan(early_init_dt_alloc_memory_arch);
8 }

struct device_node *of_root;

 1 struct device_node {
 2     const char *name;//device node name
 3     const char *type;//对应device_type的属性
 4     phandle phandle;//对应该节点的phandle属性
 5     const char *full_name;//从“/”开始的，表示该node的full path
 6     struct fwnode_handle fwnode;
 7 
 8     struct    property *properties;//该节点的属性列表
 9     struct    property *deadprops;    /* removed properties如果需要，删除某些属性，并挂入到deadprops的列表 */
10     struct    device_node *parent;//parent、child以及sibling将所有的device node连接起来
11     struct    device_node *child;
12     struct    device_node *sibling;
13     struct    kobject kobj;
14     unsigned long _flags;
15     void    *data;
16 #if defined(CONFIG_SPARC)
17     const char *path_component_name;
18     unsigned int unique_id;
19     struct of_irq_controller *irq_trans;
20 #endif
21 };

1 struct device {
2     ...
3 
4     struct device_node    *of_node; /* associated device tree node */
5     ...
6 }

 1 static void *__unflatten_device_tree(const void *blob,
 2                      struct device_node *dad,
 3                      struct device_node **mynodes,
 4                      void *(*dt_alloc)(u64 size, u64 align),
 5                      bool detached)
 6 {
 7     int size;
 8     void *mem;
 9 
10     pr_debug(" -> unflatten_device_tree()n");
11 
12     if (!blob) {
13         pr_debug("No device tree pointern");
14         return NULL;
15     }
16 
17     pr_debug("Unflattening device tree:n");
18     pr_debug("magic: %08xn", fdt_magic(blob));
19     pr_debug("size: %08xn", fdt_totalsize(blob));
20     pr_debug("version: %08xn", fdt_version(blob));
21     /*health check代码，例如检查DTB header的magic，确认blob的确指向一个DTB*/
22     if (fdt_check_header(blob)) {
23         pr_err("Invalid device tree blob headern");
24         return NULL;
25     }
26     /*scan过程分成两轮，第一轮主要是确定device-tree structure的长度，保存在size变量中*/
27     /* First pass, scan for size */
28     size = unflatten_dt_nodes(blob, NULL, dad, NULL);//第一次调用此函数，为了得到Device Tree转换成struct device_node和struct property结构体需要分配的内存大小
29     if (size < 0)
30         return NULL;
31 
32     size = ALIGN(size, 4);
33     pr_debug("  size is %d, allocating...n", size);
34     /*初始化的时候，并不是扫描到一个node或者property就分配相应的内存，实际上内核是一次性的分配了一大片内存，这些内存包括了所有的struct device_node、node name、struct property所需要的内存*/
35     /* Allocate memory for the expanded device tree */
36     mem = dt_alloc(size + 4, __alignof__(struct device_node));
37     if (!mem)
38         return NULL;
39 
40     memset(mem, 0, size);
41 
42     *(__be32 *)(mem + size) = cpu_to_be32(0xdeadbeef);
43 
44     pr_debug("  unflattening %p...n", mem);
45 
46     /* Second pass, do actual unflattening */
47     unflatten_dt_nodes(blob, mem, dad, mynodes);//第二次调用才是具体填充每一个struct device_node和struct property结构体
48     if (be32_to_cpup(mem + size) != 0xdeadbeef)
49         pr_warning("End of tree marker overwritten: %08xn",
50                be32_to_cpup(mem + size));
51 
52     if (detached && mynodes) {
53         of_node_set_flag(*mynodes, OF_DETACHED);
54         pr_debug("unflattened tree is detachedn");
55     }
56 
57     pr_debug(" <- unflatten_device_tree()n");
58     return mem;
59 }

 1 static int __init customize_machine(void)
 2 {
 3     /*
 4      * customizes platform devices, or adds new ones
 5      * On DT based machines, we fall back to populating the
 6      * machine from the device tree, if no callback is provided,
 7      * otherwise we would always need an init_machine callback.
 8      */
 9     if (machine_desc->init_machine)
10         machine_desc->init_machine();
11 
12     return 0;
13 }
14 arch_initcall(customize_machine);

1 const struct of_device_id of_default_bus_match_table[] = {
2     { .compatible = "simple-bus", },
3 #ifdef CONFIG_ARM_AMBA
4     { .compatible = "arm,amba-bus", },
5 #endif /* CONFIG_ARM_AMBA */
6     {} /* Empty terminated list */
7 };

 1 ap-apb {
 2         compatible = "simple-bus";
 3         #address-cells = <1>;
 4         #size-cells = <1>;
 5         ranges;
 6 
 7         uart0: serial@70000000 {
 8             compatible = "sprd,sc9836-uart";
 9             reg = <0x70000000 0x100>;
10             interrupts = <GIC_SPI 2 IRQ_TYPE_LEVEL_HIGH>;
11             clock-names = "uart", "source","enable";
12             clocks = <&clk_uart0>, <&ext_26m>,
13                 <&clk_ap_apb_gates 13>;
14             status = "disabled";
15         };
16 }

 1 int of_platform_populate(struct device_node *root,
 2             const struct of_device_id *matches,
 3             const struct of_dev_auxdata *lookup,
 4             struct device *parent)
 5 {
 6     struct device_node *child;
 7     int rc = 0;
 8 
 9     root = root ? of_node_get(root) : of_find_node_by_path("/");
10     if (!root)
11         return -EINVAL;
12 
13     for_each_child_of_node(root, child) {
14         rc = of_platform_bus_create(child, matches, lookup, parent, true);
15         if (rc)
16             break;
17     }
18 
19     of_node_put(root);
20     return rc;
21 }

 1 struct device_node *of_find_node_opts_by_path(const char *path, const char **opts)
 2 {
 3     struct device_node *np = NULL;
 4     struct property *pp;
 5     unsigned long flags;
 6     const char *separator = strchr(path, ':');
 7 
 8     if (opts)
 9         *opts = separator ? separator + 1 : NULL;
10 
11     if (strcmp(path, "/") == 0)
12         return of_node_get(of_root);
13 
14     /* The path could begin with an alias */
15     if (*path != '/') {
16         int len;
17         const char *p = separator;
18 
19         if (!p)
20             p = strchrnul(path, '/');
21         len = p - path;
22 
23         /* of_aliases must not be NULL */
24         if (!of_aliases)
25             return NULL;
26 
27         for_each_property_of_node(of_aliases, pp) {
28             if (strlen(pp->name) == len && !strncmp(pp->name, path, len)) {
29                 np = of_find_node_by_path(pp->value);
30                 break;
31             }
32         }
33         if (!np)
34             return NULL;
35         path = p;
36     }
37 
38     /* Step down the tree matching path components */
39     raw_spin_lock_irqsave(&devtree_lock, flags);
40     if (!np)
41         np = of_node_get(of_root);
42     while (np && *path == '/') {
43         path++; /* Increment past '/' delimiter */
44         np = __of_find_node_by_path(np, path);
45         path = strchrnul(path, '/');
46         if (separator && separator < path)
47             break;
48     }
49     raw_spin_unlock_irqrestore(&devtree_lock, flags);
50     return np;
51 }

 1 static int of_platform_bus_create(struct device_node *bus,//要创建的device node
 2                   const struct of_device_id *matches,//要匹配的list
 3                   const struct of_dev_auxdata *lookup,//附属数据
 4                   struct device *parent, bool strict)//parent指向父节点,strict是否要求完全匹配
 5 {
 6     const struct of_dev_auxdata *auxdata;
 7     struct device_node *child;
 8     struct platform_device *dev;
 9     const char *bus_id = NULL;
10     void *platform_data = NULL;
11     int rc = 0;
12 
13     /* Make sure it has a compatible property */
14     if (strict && (!of_get_property(bus, "compatible", NULL))) {
15         pr_debug("%s() - skipping %s, no compatible propn",
16              __func__, bus->full_name);
17         return 0;
18     }
19 
20     auxdata = of_dev_lookup(lookup, bus);//在传入lookup table寻找和该device node匹配的附加数据
21     if (auxdata) {//如果找到，那么就用附加数据中的静态定义的内容
22         bus_id = auxdata->name;
23         platform_data = auxdata->platform_data;
24     }
25     /*ARM公司提供了CPU core，除此之外，它设计了AMBA的总线来连接SOC内的各个block。符合这个总线标准的SOC上的外设叫做ARM Primecell Peripherals。如果一个device node的compatible属性值是arm,primecell的话，可以调用of_amba_device_create来向amba总线上增加一个amba device*/
26     if (of_device_is_compatible(bus, "arm,primecell")) {
27         /*
28          * Don't return an error here to keep compatibility with older
29          * device tree files.
30          */
31         of_amba_device_create(bus, bus_id, platform_data, parent);
32         return 0;
33     }
34     /*如果不是ARM Primecell Peripherals，那么我们就需要向platform bus上增加一个platform device了*/
35     dev = of_platform_device_create_pdata(bus, bus_id, platform_data, parent);
36     if (!dev || !of_match_node(matches, bus))
37         return 0;
38 
39     for_each_child_of_node(bus, child) {
40         pr_debug("   create child: %sn", child->full_name);
41         rc = of_platform_bus_create(child, matches, lookup, &dev->dev, strict);
42         if (rc) {
43             of_node_put(child);
44             break;
45         }
46     }
47     of_node_set_flag(bus, OF_POPULATED_BUS);
48     return rc;
49 }

 1 static struct platform_device *of_platform_device_create_pdata(
 2                     struct device_node *np,
 3                     const char *bus_id,
 4                     void *platform_data,
 5                     struct device *parent)
 6 {
 7     struct platform_device *dev;
 8 
 9     if (!of_device_is_available(np) ||   //检查status属性，确保是enable或者OK的
10         of_node_test_and_set_flag(np, OF_POPULATED))
11         return NULL;
12 
13     dev = of_device_alloc(np, bus_id, parent);
14     if (!dev)
15         goto err_clear_flag;
16 
17     of_dma_configure(&dev->dev);
18     dev->dev.bus = &platform_bus_type;
19     dev->dev.platform_data = platform_data;
20 
21     /* We do not fill the DMA ops for platform devices by default.
22      * This is currently the responsibility of the platform code
23      * to do such, possibly using a device notifier
24      */
25 
26     if (of_device_add(dev) != 0) {
27         platform_device_put(dev);
28         goto err_clear_flag;
29     }
30 
31     return dev;
32 
33 err_clear_flag:
34     of_node_clear_flag(np, OF_POPULATED);
35     return NULL;
36 }