Linux Kernel Device Tree 配置框架

    背景:基于arm平台的soc种类繁多,硬件资源和配置各不相同。这些平台硬件相关的信息在设备树出现之前,是在kernel/arch/arm/plat-xxx目录和kernel/arch/arm/mach-xxx目录下硬编码的。在kernel看来,这些硬件细节代码只不过是些垃圾,需要一套框架抽象出来,屏蔽这些硬件细节。设备树框架被提出用来统一arm平台硬件配置,屏蔽硬件细节。

    术语介绍:

    1,DTS(Device Tree Source):设备树源码。为方便阅读和修改,设备树源文件遵循一定的格式,采用文本方式存放。

    2,DTB(Device Tree Blob):设备树对象。DTS的二进制对象表示形式,通过DTC将DTS编译成DTB。

    3,DTC(Device Tree Compiler):设备树编译器。kernel提供的一个小工具,可以将 DTS 编译成 DTB。

    DTS为什么需要转换成DTB?kernel在初始化阶段需要从设备树读取平台的各种硬件信息(如,bootargs/cpu/memory/devices等),bootloader在加载kernel image的同时,也需要加载设备树信息。bootloader将加载后的设备树物理地址传递给kernel,kernel再去配置各种硬件信息。因此,需要定义出DTB的二进制格式,通过DTC将DTS编译成DTB,经bootloader加载,kernel解析DTB,最终在kernel中形成一套完整的device tree。

    DTS的格式:

        DTS以节点和属性的形式组织设备树:节点是树枝,属性是树叶,节点中可以包含子节点。

        1,节点格式:

                label : name@address {

                }

            (1)label:标签。如果有其他属性需要引用该节点,可以通过 &label 的形式直接引用该节点。

            (2)name:节点名称。长度范围是1~31,可以使用如下字符组合:数字(0 ~ 9) 小写字母(a ~ z) 大写字母(A ~ Z) 逗号(,) 句号(.)下划线(_) 加号(+) 以及 减号(-)。并且,规范要求以字母开头。

            (3)address:节点地址。其实是用来区分同名设备的,同一空间中的不同节点可能是同一个名称,可以通过不同地址来区分。address并不仅仅指设备地址,也可能是设备编号。比如,对于cpu来说,就没有地址,但是可以通过 cpu@0,cpu@1来区分不同的cpu。

        2,属性格式:

            property_name = value

            (1)property_name:属性名称。长度范围是1~31,可以使用如下字符组合:数字(0 ~ 9) 小写字母(a ~ z)  逗号(,) 句号(.)下划线(_) 加号(+)  减号(-) 问号(?)以及 sharp(#) 。并且,规范要求以字母开头。

            (2)value:属性值。标准定义的属性值基本类型如下:<empty> <u32> <u64> <string> <prop-encoded-array> <phandle> <stringlist>。

                    <prop-encoded-array>:混合编码,自定义property的值。

                    <phandle>:作为一个句柄指向一个Node,用来引用Node。很少使用,一般使用 &label 方式引用node。

        3,标准属性:

            (1)compatible:字符串数组类型。通常用来匹配driver和device,一个设备可以定义多个匹配字符串,范围由小到大,由具体到一般。这样在匹配驱动程序时,优先匹配更具体的设备驱动。

            (2)model:字符串类型。用来表示设备型号。

            (3)#address-cells,#size-cells:一个cell表示32位。这两个属性用来定义一个node的子node中,reg属性值的格式。比如,

                        父节点中,#address-cells = <2>; #size-cells = <1>

                        子节点中,reg = <0x00010000 0x7c004000 0x00001000 >

                    这表明,子节点reg的属性值中前两个cell组成设备的64位起始地址(0x000100007c004000),后一个cell是这个设备占用的32位地址范围(大小0x00001000)。

            (4)reg:<prop-encoded-array>类型,格式是<start-addr  size>。表示设备节点资源,一般指寄存器起始地址和范围。见(3)中示例。

            (5)ranges:<prop-encoded-array>类型,格式是<subnode-addr  parent-node-addr  size>。subnode-addr占用几个cell由ranges所在的当前节点 #address-cells 决定,parent-node-addr占用几个cell由父节点 #address-cells 决定,size占用几个cell由当前节点 #size-cells 决定。

            (6)status:字符串类型。表明设备的状态。“okay”表示设备可用,“disabled”表示设备不可用。

        4,中断相关属性:

            中断节点分为三种:中断控制器,中断产生设备和中断连接器(nexus)。

            (1)中断产生设备属性:

                    interrupt-parent:<phandle>类型。指示该中断产生设备的中断父节点,即中断控制器或者中断连接器。

                    #interrupt:<prop-encoded-array>类型。每个中断编号占用几个cell由中断父节点中的 #interrupt-cells 决定。

            (2)中断控制器属性:

                    #interrupt-cells:指示连接到该中断控制器下的设备的 #interrupt 的解析格式,即每个中断编号占用几个cell。

                    interrupt-controller:<empty>类型。声明该节点是一个中断控制器。

            (3)中断连接器属性:

                    #interrupt-cells:指示连接到该中断连接器下的设备的 #interrupt 的解析格式,即每个中断编号占用几个cell。

                    interrupt-map:<prop-encoded-array>类型,格式为<child_unit_address, child_interrupt_specifier, interrupt_parent, parent_unit_address, parent_interrupt_specifier>。描述中断连接器对中断的路由。

                        其中,

                                child_unit_address:cells长度由子节点的“#address-cells”指定; 
                                child_interrupt_specifier:cells长度由子节点的“#interrupt-cells”指定; 
                                interrupt_parent:phandle指向interrupt controller的引用; 
                                parent_unit_address:cells长度由父节点的“#address-cells”指定; 
                                parent_interrupt_specifier:cells长度由父节点的“#interrupt-cells”指定;

        5,标准节点:

            (1)/  节点,即根节点:每个设备树有且只有一个根节点。根节点必须包含如下属性:compatible,model,#address-cells 和 #size-cells。

            (2)/alias  节点:定义节点别名。

            (3)/memory  节点:内存节点。一般有如下属性:device_type,reg等。

            (4)/chosen  节点:该节点并不表示某个硬件设备,而是用来传递内核启动参数和定义标准输入输出设备。一般有如下属性:bootargs,stdin-path 和 stdout-path。

            (5)/cpu  节点:定义cpu节点。

    DTB的格式:

        DTS经过DTC编译之后,生成如下格式的DTB

        (1)整体结构:分为4个block(图片来源于网络)。

        è¿éåå¾çæè¿°

                    说明:(1)boot_param_header:主要定义了后面三个block的偏移。

                            (2)device-tree structure:定义了节点和属性值的格式。

                            (3)device-tree strings:定义了属性名。

        (2)boot_param_header结构定义:

            struct boot_param_header {
                __be32    magic;            /* magic word OF_DT_HEADER */
                __be32    totalsize;        /* total size of DT block */
                __be32    off_dt_struct;        /* offset to structure */
                __be32    off_dt_strings;        /* offset to strings */
                __be32    off_mem_rsvmap;        /* offset to memory reserve map */
                __be32    version;        /* format version */
                __be32    last_comp_version;    /* last compatible version */
                /* version 2 fields below */
                __be32    boot_cpuid_phys;    /* Physical CPU id we're booting on */
                /* version 3 fields below */
                __be32    dt_strings_size;    /* size of the DT strings block */
                /* version 17 fields below */
                __be32    dt_struct_size;        /* size of the DT structure block */
};

        (3)device-tree structure:(图片来源于网络)

                è¿éåå¾çæè¿°

            说明:

                (1)FDT_BEGIN_NODE:节点开始指示符。

                (2)FDT_PROP:属性开始指示符。

                (3)FDT_END_NODE:节点结束指示符。

                (4)每个属性的格式是:4字节指示属性值的长度;接下来4字节指示属性名在 device tree strings 块中的偏移;再接下来就是实际的属性值。

    源码分析:

        kernel解析DTB分为两个部分,一部分是先进行DTB的解析,生成内核device_node节点树。第二部分是根据device_node节点树创建各个具体的设备。

        1,解析DTB

            (1)直接解析DTB,获取机器类型,kernel启动参数,内存配置信息等

            setup_arch() ->setup_machine_fdt(__atags_pointer): // __atags_pointer是bootloader提供给kernel的DTB起始物理地址

const struct machine_desc * __init setup_machine_fdt(unsigned int dt_phys)
{
    const struct machine_desc *mdesc, *mdesc_best = NULL;

#ifdef CONFIG_ARCH_MULTIPLATFORM
    DT_MACHINE_START(GENERIC_DT, "Generic DT based system")
    MACHINE_END

    mdesc_best = &__mach_desc_GENERIC_DT;
#endif

    if (!dt_phys || !early_init_dt_verify(phys_to_virt(dt_phys)))    // 物理地址转换成内核态地址,并检查DTB文件头的合法性
        return NULL;

    mdesc = of_flat_dt_match_machine(mdesc_best, arch_get_next_mach); //根据DTB配置的compatible参数,选取kernel支持的最优machine类型。

    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();

    early_init_dt_scan_nodes();    // 解析DTB中配置的bootargs,memory等信息

    /* Change machine number to match the mdesc we're using */
    __machine_arch_type = mdesc->nr;

    return mdesc;
}
 

void __init early_init_dt_scan_nodes(void)
{
    /* Retrieve various information from the /chosen node */
    of_scan_flat_dt(early_init_dt_scan_chosen, boot_command_line);    // 解析 /chosen 节点,获取kernel启动参数

    /* Initialize {size,address}-cells info */
    of_scan_flat_dt(early_init_dt_scan_root, NULL);    // 解析 根节点,获取 #address-cells 和 #size-cells等属性

    /* Setup memory, calling early_init_dt_add_memory_arch */
    of_scan_flat_dt(early_init_dt_scan_memory, NULL);    // 解析 /memory 节点,获取内存配置信息,并加入kernel管理
}

            (2)根据device tree递归创建设备树节点 device_node

                setup_arch() ->unflatten_device_tree():

void __init unflatten_device_tree(void)
{
    __unflatten_device_tree(initial_boot_params, &of_root,
                early_init_dt_alloc_memory_arch);    // 解析设备树DTB,加入到of_root根节点中

    /* Get pointer to "/chosen" and "/aliases" nodes for use everywhere */
    of_alias_scan(early_init_dt_alloc_memory_arch);    // 解析 /alias 节点
}

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;

    pr_debug(" -> unflatten_device_tree()\n");

    if (!blob) {
        pr_debug("No device tree pointer\n");
        return;
    }

    pr_debug("Unflattening device tree:\n");
    pr_debug("magic: %08x\n", fdt_magic(blob));
    pr_debug("size: %08x\n", fdt_totalsize(blob));
    pr_debug("version: %08x\n", fdt_version(blob));

    if (fdt_check_header(blob)) {
        pr_err("Invalid device tree blob header\n");
        return;
    }

    // 首次轮询,设置mem为NULL,dry_run为true,start为0,用来计算整棵设备树解析后的内存大小

    /* First pass, scan for size */
    start = 0;
    size = (unsigned long)unflatten_dt_node(blob, NULL, &start, NULL, NULL, 0, true);    // 计算解析后设备树大小
    size = ALIGN(size, 4);

    pr_debug("  size is %lx, allocating...\n", size);

    /* Allocate memory for the expanded device tree */
    mem = dt_alloc(size + 4, __alignof__(struct device_node));    // 分配解析后的设备树内存
    memset(mem, 0, size);

    *(__be32 *)(mem + size) = cpu_to_be32(0xdeadbeef);

    pr_debug("  unflattening %p...\n", mem);

    // 再次轮询,传入mem,设置dry_run为false,进行实际内存分配和设备树加载

    /* Second pass, do actual unflattening */
    start = 0;
    unflatten_dt_node(blob, mem, &start, NULL, mynodes, 0, false);    // 设备树解析,加载
    if (be32_to_cpup(mem + size) != 0xdeadbeef)
        pr_warning("End of tree marker overwritten: %08x\n",
               be32_to_cpup(mem + size));

    pr_debug(" <- unflatten_device_tree()\n");
}
 

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;

    pathp = fdt_get_name(blob, *poffset, &l);    //poffset开始为0,获取根节点路径,递归之后,获取各节点路径
    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 '/'.
     */

    // 根据版本的不同,DTB中节点名有可能是绝对路径名,也有可能是相对路径名,如果是相对路径名,需要组合成绝对路径名
    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;
        }
    }

    np = unflatten_dt_alloc(&mem, sizeof(struct device_node) + allocl,
                __alignof__(struct device_node));    // 分配存放 device_node + 节点名称 的内存

    if (!dryrun) {
        char *fn;
        of_node_init(np);
        np->full_name = fn = ((char *)np) + sizeof(*np);
        if (new_format) {    // new_format == 1 表明节点名称是相对路径名,下面的代码用于处理合成绝对路径名
            /* rebuild full path for new format */
            if (dad && dad->parent) {
                strcpy(fn, dad->full_name);
#ifdef DEBUG
                if ((strlen(fn) + l + 1) != allocl) {
                    pr_debug("%s: p: %d, l: %d, a: %d\n",
                        pathp, (int)strlen(fn),
                        l, allocl);
                }
#endif
                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;
        }
    }

    // 解析该节点下的各个属性
    /* process properties */
    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. */
            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
     */
    if (!has_name) {
        const char *p1 = pathp, *ps = pathp, *pa = NULL;
        int sz;

        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;
            pr_debug("fixed up name for %s -> %s\n", pathp,
                (char *)pp->value);
        }
    }
    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;
    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;
}
        至此,整棵设备树的节点和属性都都被加载进kernel中,以device_node形式保存在根节点 of_root 中。

        2,创建DT设备 platform_device

            start_kernel() -> reset_init() -> kernel_init() -> kernel_init_freeable() -> do_basic_setup() -> do_initcalls() -> customize_machine() -> of_platform_populate()

            kernel启动阶段会去创建各个配置好的platform_device,包括总线设备和总线下挂的子设备

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.
     */
    of_iommu_init();
    if (machine_desc->init_machine)
        machine_desc->init_machine();
#ifdef CONFIG_OF
    else
        of_platform_populate(NULL, of_default_bus_match_table,
                    NULL, NULL);    // 匹配 of_default_bus_match_table的节点被认为是总线设备,叶子设备则不应该匹配

#endif
    return 0;
}
arch_initcall(customize_machine);    // customize_machine被arch_initcall声明,在do_initcalls()阶段会被调用执行

const 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 */
};

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("/");    // 获取 of_root 设备树根节点
    if (!root)
        return -EINVAL;

    // 轮询设备树根节点下的子节点

    for_each_child_of_node(root, child) {
        rc = of_platform_bus_create(child, matches, lookup, parent, true);    // 检查并创建总线设备和叶子设备
        if (rc) {
            of_node_put(child);
            break;
        }
    }
    of_node_set_flag(root, OF_POPULATED_BUS);

    of_node_put(root);
    return rc;
}

 

static int of_platform_bus_create(struct device_node *bus,
                  const struct of_device_id *matches,
                  const struct of_dev_auxdata *lookup,
                  struct device *parent, bool 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;

    /* Make sure it has a compatible property */
    if (strict && (!of_get_property(bus, "compatible", NULL))) {    // 无论是总线设备还是叶子设备,都必须包含 compatible 属性
        pr_debug("%s() - skipping %s, no compatible prop\n",
             __func__, bus->full_name);
        return 0;
    }

    auxdata = of_dev_lookup(lookup, bus);
    if (auxdata) {
        bus_id = auxdata->name;
        platform_data = auxdata->platform_data;
    }

    if (of_device_is_compatible(bus, "arm,primecell")) {
        /*
         * Don't return an error here to keep compatibility with older
         * device tree files.
         */
        of_amba_device_create(bus, bus_id, platform_data, parent);
        return 0;
    }

    dev = of_platform_device_create_pdata(bus, bus_id, platform_data, parent);    // 创建总线设备或者叶子设备的platform_device
    if (!dev || !of_match_node(matches, bus))    // 如果不匹配,说明该设备是个叶子设备,递归结束;如果匹配,说明该设备是个总线设备,需要继续递归轮询其下挂的子设备
        return 0;

    // 循环创建该总线下的所有子总线设备

    for_each_child_of_node(bus, child) {
        pr_debug("   create child: %s\n", child->full_name);
        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;
}

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;

    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);    // 分配 platform_device,并从 node_device 中获取reg和irq信息
    if (!dev)
        goto err_clear_flag;

    dev->dev.bus = &platform_bus_type;    // bus type 为 platform_bus_type
    dev->dev.platform_data = platform_data;
    of_dma_configure(&dev->dev, dev->dev.of_node);
    of_msi_configure(&dev->dev, dev->dev.of_node);

    if (of_device_add(dev) != 0) {
        of_dma_deconfigure(&dev->dev);
        platform_device_put(dev);
        goto err_clear_flag;
    }

    return dev;

err_clear_flag:
    of_node_clear_flag(np, OF_POPULATED);
    return NULL;
}
    至此,从DTS到DTB,从kernel加载DTB,到整个DTB被转换成由of_root引用的device_node tree,最后到整个platform_bus总线的创建过程已经非常清晰明了了。整个arm架构的设备注册部分已经完成,剩下的就是后续各个platform_driver的register,match和probe了。

转载于:https://my.oschina.net/yepanl/blog/2966476

已标记关键词 清除标记
表情包
插入表情
评论将由博主筛选后显示,对所有人可见 | 还能输入1000个字符
相关推荐
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页