初始化

start_kernel()
init/main.c
asmlinkage void __init start_kernel(void)
{
…
setup_arch(&command_line);
…
rest_init();
}

setup_arch()
arch/arm64/kernel/setup.c
void __init setup_arch(char **cmdline_p)
{
…
setup_machine_fdt(__fdt_pointer);
…
parse_early_param();
…
unflatten_device_tree();
…

ifdef CONFIG_SMP

smp_init_cpus();

endif

...

}

rest_init()
init/main.c
static noinline void __init_refok rest_init(void)
{
…
kernel_thread(kernel_init, NULL, CLONE_FS | CLONE_SIGHAND);
…
}

static int __ref kernel_init(void *unused)
{
int ret;

kernel_init_freeable();

}

static noinline void __init kernel_init_freeable(void)
{

smp_prepare_cpus(setup_max_cpus);

}

void __init smp_prepare_cpus(unsigned int max_cpus)
{
int err;
unsigned int cpu, ncores = num_possible_cpus();

init_cpu_topology();

setup_machine_fdt()
arch/arm64/kernel/setup.c
static void __init setup_machine_fdt(phys_addr_t dt_phys)
{
if (!dt_phys || !early_init_dt_scan(phys_to_virt(dt_phys))) {
while (true)
cpu_relax();
}

machine_name = of_flat_dt_get_machine_name();

}

setup_machine_fdt()调用了两个函数：
1.early_init_dt_scan()
2.of_flat_dt_get_machine_name()

of_flat_dt_get_machine_name用于获取如下属性：
model
compatible
如果model没有设置，就用compatible来设置machine_name.

early_init_dt_scan()
drivers/of/fdt.c
bool __init early_init_dt_scan(void *params)
{
if (!params)
return false;

/* Setup flat device-tree pointer */
initial_boot_params = params;

/* 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);

return true;

}

early_init_dt_scan()做了三件事，分别解析如下相关属性：
1、early_init_dt_scan_chosen()
chosen
bootargs
2、early_init_dt_scan_root()

size-cells

address-cells

3、early_init_dt_scan_memory()
device_type
linux,usable-memory

drivers/of/fdt.c
early_init_dt_scan_memory()参阅后面关于memory节点的说明。

unflatten_device_tree
start_kernel->setup_arch->unflatten_device_tree->
drivers/of/fdt.c
void __init unflatten_device_tree(void)
{
__unflatten_device_tree(initial_boot_params, &of_allnodes,
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);

}

arm64_device_init
arch/arm64/kernel/setup.c
static int __init arm64_device_init(void)
{
of_clk_init(NULL);
of_platform_populate(NULL[参数为NULL，则用根节点], of_default_bus_match_table, NULL, NULL);
return 0;
}
arch_initcall_sync启动加载级别;

drivers/of/platform.c
const struct of_device_id of_default_bus_match_table[] = {
{ .compatible = “simple-bus”, },

ifdef CONFIG_ARM_AMBA

{ .compatible = "arm,amba-bus", },

endif /* CONFIG_ARM_AMBA */

{} /* Empty terminated list */

};

of_platform_populate

drivers/of/platform.c
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("/");[如果root参数为NULL，则用根节点]
if (!root)
    return -EINVAL;

for_each_child_of_node(root, child) {
    rc = of_platform_bus_create(child, matches, lookup, parent, true);
    if (rc)
        break;
}

of_node_put(root);
return rc;

}

实际调用：
int of_platform_populate(struct device_node *root,
const struct of_device_id *matches,
const struct of_dev_auxdata *lookup,
struct device *parent)
{
for_each_child_of_node(root, child) {
rc = of_platform_bus_create(child, of_default_bus_match_table, NULL, NULL, true);
}
}

of_platform_bus_create

of_platform_populate实际调用：
of_platform_bus_create(child, of_default_bus_match_table, NULL, NULL, true);

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)
{
if (strict && (!of_get_property(bus, “compatible”, NULL))) {
pr_err(“%s() - skipping %s, no compatible prop\n”,
func, bus->full_name);
return 0;
}
dev = of_platform_device_create_pdata(bus, bus_id, platform_data, parent);
if (!dev || !of_match_node(matches, bus))
return [到这里就直接返回了。]0;

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;
    }
}
return rc;[这一段代码没有执行。]

}

关于参数true：
drivers/of/platform.c
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)
{
…
/* Make sure it has a compatible property */
if (strict && (!of_get_property(bus, “compatible”, NULL))) {
pr_debug(“%s() - skipping %s, no compatible prop\n”,
func, bus->full_name);
return 0;
}
…
}

也就是说dts配置的节点必须有compatible属性。

节点
定义
[label:] node-name[@unit-address] {
[properties definitions]
[child nodes]
}

1、[]可选;
2、lable用于在dts中引用;
3、@后面是地址;
4、如果没有@unit-address，则node-name必须唯一；
5、如果有@unit-address，则node-name可以相同;

例1
gic: interrupt-controller@2c001000 {
compatible = “arm,cortex-a15-gic”, “arm,cortex-a9-gic”;
#interrupt-cells = <3>;
#address-cells = <0>;
interrupt-controller;
reg = <0x0 0xc4301000 0 0x1000>,
<0x0 0xc4302000 0 0x0100>;
interrupts = ;
};

编译后的dtb是：
interrupt-controller@2c001000 {
compatible = “arm,cortex-a15-gic”, “arm,cortex-a9-gic”;
#interrupt-cells = <0x00000003>;
#address-cells = <0x00000000>;
interrupt-controller;
reg = <0x00000000 0xc4301000 0x00000000 0x00001000 0x00000000 0xc4302000 0x00000000 0x00000100>;
interrupts = <0x00000001 0x00000009 0x00000f04>;
linux,phandle = <0x00000001>;
phandle = <0x00000001>;
};

例2：
gpio: banks@c11080b0 {
reg = <0x0 0xc88344b0 0x0 0x2c>,
<0x0 0xc88344e8 0x0 0x14>,
<0x0 0xc8834520 0x0 0x14>,
<0x0 0xc8834430 0x0 0x3c>;
reg-names = “mux”, “pull”, “pull-enable”, “gpio”;
gpio-controller;
#gpio-cells = <2>;
};

memory
例1：
memory@00000000 {
device_type = “memory”;
linux,usable-memory = <0x0 0x1000000 0x0 0x3f000000>;
};

这里linux,usable-memory和reg属性一样。建议统一使用reg。
前面两个数是64位的起始地址，后面两个数是64位的大小。

该节点是由early_init_dt_scan_memory()来解析。
drivers/of/fdt.c
int __init early_init_dt_scan_memory(unsigned long node, const char *uname,
int depth, void *data)
{
const char *type = of_get_flat_dt_prop(node, “device_type”, NULL);
const __be32 *reg, *endp;
int l;

/* We are scanning "memory" nodes only */
if (type == NULL) {
    /*
     * The longtrail doesn't have a device_type on the
     * /memory node, so look for the node called /memory@0.
     */
    if (depth != 1 || strcmp(uname, "memory@0") != 0)
        return 0;
} else if (strcmp(type, "memory") != 0)
    return 0;

reg = of_get_flat_dt_prop(node, "linux,usable-memory", &l);
if (reg == NULL)
    reg = of_get_flat_dt_prop(node, "reg", &l);
if (reg == NULL)
    return 0;

}

解释：
1、如果没有有device_type属性，则必须在根节点（depth=1）下这么写dts：
memory@0 {
linux,usable-memory = <0x0 0x1000000 0x0 0x3f000000>;
};

2、如果device_type属性的值不是memory，则该函数不继续解析。

3、优先使用linux,usable-memory，如果没有，则使用reg来解析memory。

cpus
例1：
cpus:cpus {
#address-cells = <2>;
#size-cells = <0>;
#cooling-cells = <2>; /* min followed by max */

cpu@0 {
    device_type = "cpu";
    compatible = "arm,cortex-a53","arm,armv8";
    reg = <0x0 0x0>;
    enable-method = "psci";
};

cpu@1 {
    device_type = "cpu";
    compatible = "arm,cortex-a53","arm,armv8";
    reg = <0x0 0x1>;
    enable-method = "psci";
};
cpu@2 {
    device_type = "cpu";
    compatible = "arm,cortex-a53","arm,armv8";
    reg = <0x0 0x2>;
    enable-method = "psci";
};

cpu@3 {
    device_type = "cpu";
    compatible = "arm,cortex-a53","arm,armv8";
    reg = <0x0 0x3>;
    enable-method = "psci";
};

};

arch/arm64/kernel/setup.c
void __init setup_arch(char **cmdline_p)
{
…
setup_machine_fdt(__fdt_pointer);
…
parse_early_param();
…
unflatten_device_tree();
…

ifdef CONFIG_SMP

smp_init_cpus();

endif

...

}

解析过程：
第一阶段：
start_kernel()->setup_arch()->smp_init_cpus()
第二阶段：
start_kernel()->rest_init()
->kernel_init(kernel_thread)->…->smp_prepare_cpus()

smp_init_cpus()
start_kernel()->setup_arch()->smp_init_cpus()

arch/arm64/kernel/smp.c
void __init smp_init_cpus(void)
{
struct device_node *dn = NULL;
unsigned int i, cpu = 1;
bool bootcpu_valid = false;

while ((dn = of_find_node_by_type(dn, "cpu"))) {
    cell = of_get_property(dn, "reg", NULL);
    hwid = of_read_number(cell, of_n_addr_cells(dn));

    if (cpu_read_ops(dn, cpu) != 0)
        goto next;

    if (cpu_ops[cpu]->cpu_init(dn, cpu))
        goto next;

    cpu_logical_map(cpu) = hwid;

    cpu++;
}

for (i = 0; i < NR_CPUS; i++)
    if (cpu_logical_map(i) != INVALID_HWID)
        set_cpu_possible(i, true);

}

smp_prepare_cpus
start_kernel()->rest_init()
->kernel_init(kernel_thread)->kernel_init_freeable()->
smp_prepare_cpus()
do_pre_smp_initcalls()
smp_init()
sched_init_smp()

init/main.c
static noinline void __init kernel_init_freeable(void)
{

cad_pid = task_pid(current);

smp_prepare_cpus(setup_max_cpus);

do_pre_smp_initcalls();
lockup_detector_init();

smp_init();
sched_init_smp();

do_basic_setup();

}

smp_prepare_cpus()->init_cpu_topology()->
parse_dt_topology()
parse_dt_cpu_power

arch/arm64/kernel/topology.c
void __init init_cpu_topology(void)
{
reset_cpu_topology();

/*
 * Discard anything that was parsed if we hit an error so we
 * don't use partial information.
 */
if (parse_dt_topology())
    reset_cpu_topology();

reset_cpu_power();
parse_dt_cpu_power();

}

static int __init parse_dt_topology(void)
{
cn = of_find_node_by_path(“/cpus”);

map = of_get_child_by_name(cn, "cpu-map");
if (!map)
    goto out;

out:
of_node_put(cn);
return ret;
}

static void __init parse_dt_cpu_power(void)
{

for_each_possible_cpu(cpu) {
    cn = of_get_cpu_node(cpu, NULL);

    for (cpu_eff = table_efficiency; cpu_eff->compatible; cpu_eff++)
        if (of_device_is_compatible(cn, cpu_eff->compatible))
            break;
    rate = of_get_property(cn, "clock-frequency", &len);
    if (!rate || len != 4) {
        pr_err("%s: Missing clock-frequency property\n",
            cn->full_name);
        continue;
    }

    capacity = ((be32_to_cpup(rate)) >> 20) * cpu_eff->efficiency;
    cpu_capacity(cpu) = capacity;

}

}

enable-method
cpu@0 {
device_type = “cpu”;
compatible = “arm,cortex-a53”,”arm,armv8”;
reg = <0x0 0x0>;
enable-method = “psci”;
};

arch/arm64/kernel/cpu_ops.c
int __init cpu_read_ops(struct device_node *dn, int cpu)
{
const char *enable_method = of_get_property(dn, “enable-method”, NULL);

cpu_ops[cpu] = cpu_get_ops(enable_method);

return 0;

}

static const struct cpu_operations * __init cpu_get_ops(const char *name)
{
const struct cpu_operations **ops = supported_cpu_ops;

while (*ops) {
    if (!strcmp(name, (*ops)->name))
        return *ops;

    ops++;
}

return NULL;

}

static const struct cpu_operations *supported_cpu_ops[] __initconst = {

ifdef CONFIG_SMP

&smp_spin_table_ops,
&cpu_psci_ops,

endif

NULL,

};

const struct cpu_operations cpu_psci_ops = {
.name = “psci”,
.cpu_init = cpu_psci_cpu_init,
.cpu_prepare = cpu_psci_cpu_prepare,
.cpu_boot = cpu_psci_cpu_boot,
.cpu_suspend = cpu_psci_cpu_suspend,

ifdef CONFIG_HOTPLUG_CPU

.cpu_disable    = cpu_psci_cpu_disable,
.cpu_die    = cpu_psci_cpu_die,

endif

};

reserved-memory
exmaple
reserved-memory {
#address-cells = <2>;
#size-cells = <2>;
ranges;
/* global autoconfigured region for contiguous allocations */
secmon_reserved:linux,secmon {
compatible = “amlogic, aml_secmon_memory”;
reg = <0x0 0x10000000 0x0 0x200000>;
no-map;
};
pstore:aml_pstore {
compatible = “amlogic, pstore”;
reg = <0x0 0x07300000 0x0 0x100000>;
no-map;
};
di_reserved:linux,di {
compatible = “amlogic, di-mem”;
size = <0x0 0x3300000>; //51M for support nr10bit
multi-use;
};
…
};

sequence
start_kernel()->setup_arch()->arm64_memblock_init()->
early_init_fdt_scan_reserved_mem()->
of_scan_flat_dt(__fdt_scan_reserved_mem)
fdt_init_reserved_mem()

early_init_fdt_scan_reserved_mem()

arch/arm64/kernel/setup.c
void __init setup_arch(char **cmdline_p)
{
…
setup_machine_fdt(__fdt_pointer);
…
parse_early_param();
arm64_memblock_init();
…
unflatten_device_tree();
…

ifdef CONFIG_SMP

smp_init_cpus();

endif

...

}

arch/arm64/mm/init.c
void __init arm64_memblock_init(void)
{
…
early_init_fdt_scan_reserved_mem();
…
}

drivers/of/fdt.c
void __init early_init_fdt_scan_reserved_mem(void)
{
if (!initial_boot_params)
return;

of_scan_flat_dt(__fdt_scan_reserved_mem, NULL);
fdt_init_reserved_mem();

}

__fdt_scan_reserved_mem()
drivers/of/fdt.c
static int __init __fdt_scan_reserved_mem(unsigned long node, const char *uname,
int depth, void *data)
{

if (!found && depth == 1 && strcmp(uname, "reserved-memory") == 0) {
    if (__reserved_mem_check_root(node) != 0) {
        pr_err("Reserved memory: unsupported node format, ignoring\n");
        /* break scan */
        return 1;
    }
    found = 1;
    /* scan next node */
    return 0;
} else if (!found) {
    /* scan next node */
    return 0;
} else if (found && depth < 2) {
    /* scanning of /reserved-memory has been finished */
    return 1;
}

status = of_get_flat_dt_prop(node, "status[如果没有status，则默认status =okay]", NULL);
if (status && strcmp(status, "okay") != 0 && strcmp(status, "ok") != 0)
    return 0;

err = __reserved_mem_reserve_reg(node, uname);
if (err == -ENOENT && of_get_flat_dt_prop(node, "size", NULL))
    fdt_reserved_mem_save_node(node, uname, 0, 0);

/* scan next node */
return 0;

}

__reserved_mem_check_root()
static int __init __reserved_mem_check_root(unsigned long node)
{
const __be32 *prop;

prop = of_get_flat_dt_prop(node, "#size-cells", NULL);
if (!prop || be32_to_cpup(prop) != dt_root_size_cells)
    return -EINVAL;

prop = of_get_flat_dt_prop(node, "#address-cells", NULL);
if (!prop || be32_to_cpup(prop) != dt_root_addr_cells)
    return -EINVAL;

prop = of_get_flat_dt_prop(node, "ranges", NULL);
if (!prop)
    return -EINVAL;
return 0;

}

必须提供以下三个属性：

size-cells

address-cells

ranges

而且#size-cells和#address-cells的值必须和根节点的值（由dt_root_size_cells和dt_root_addr_cells保存）相同。

reserved_mem[]
drivers/of/of_reserved_mem.c

define MAX_RESERVED_REGIONS 16

static struct reserved_mem reserved_mem[MAX_RESERVED_REGIONS];

从上面代码看，reserved memory最多只能有16个。

属性
property[=value]

1、单个字符串
2、字符串列表
3、单个无符号整型数
4、无符号整型数列表
5、无参数值属性

address-cells

drivers/of/base.c

int of_n_addr_cells(struct device_node *np)
{
const __be32 *ip;

do {
    if (np->parent)
        np = np->parent;
    ip = of_get_property(np, "#address-cells", NULL);
    if (ip)
        return be32_to_cpup(ip);
} while (np->parent);
/* No #address-cells property for the root node */
return OF_ROOT_NODE_ADDR_CELLS_DEFAULT;

}
EXPORT_SYMBOL(of_n_addr_cells);

int of_n_size_cells(struct device_node *np)
{
const __be32 *ip;

do {
    if (np->parent)
        np = np->parent;
    ip = of_get_property(np, "#size-cells", NULL);
    if (ip)
        return be32_to_cpup(ip);
} while (np->parent);
/* No #size-cells property for the root node */
return OF_ROOT_NODE_SIZE_CELLS_DEFAULT;

}
EXPORT_SYMBOL(of_n_size_cells);

size-cells

描述子节点的reg属性。#address-cells表示地址域占用几个cell，#size-cells表示地址长度占用几个cell。

针对reg格式：
reg =

address-cells 表示address1/2 包含几个cell。

size-cells表示length1/2包含几个cell

例1:
/ {
#address-cells = <2>;
#size-cells = <2>;

sd {
reg = <0x0 0xd0072000 0x0 0x2000>;
}
}

例1的sd节点的reg属性，address是0x0 0xd0072000,length是0x0 0x2000。这个例子的地址实际都是64bit地址。

例2：

/ {
#address-cells = <2>;
#size-cells = <2>;

i2c {

address-cells = <1>;

size-cells = <0>;

at24 {
reg = <0x50>;
}
}
}

reg
格式：
reg =

address-cells

size-cells

也就是说节点的reg属性，需要使用父节点的#address-cells、#size-cells的值来解析。

例子
reserved-memory {
#address-cells = <2>;
#size-cells = <2>;
ranges;
/* global autoconfigured region for contiguous allocations */
secmon_reserved:linux,secmon {
compatible = “amlogic, aml_secmon_memory”;
reg = <0x0 0x10000000 0x0 0x200000>;
no-map;
};

model

const char * __init of_flat_dt_get_machine_name(void)
{
const char *name;
unsigned long dt_root = of_get_flat_dt_root();

name = of_get_flat_dt_prop(dt_root, "model", NULL);
if (!name)
    name = of_get_flat_dt_prop(dt_root, "compatible", NULL);
return name;

}
从代码看，如果定义了model，就用model来设置machine_name，否则就是用compatible.

有两处使用：
of_flat_dt_match_machine()
pr_info(“Machine model: %s\n”, of_flat_dt_get_machine_name());

start_kernel->setup_arch->setup_machine_fdt->

machine_name = of_flat_dt_get_machine_name();

compatible
格式：
[manufacturer], [model]

例1：
compatible = “amlogic, gxtvbb”;

interrupt-parent
例子
interrupt-parent = <&gic>;

gic: interrupt-controller@2c001000 {
compatible = “arm,cortex-a15-gic”, “arm,cortex-a9-gic”;
#interrupt-cells = <3>;
#address-cells = <0>;
interrupt-controller;
reg = <0x0 0xc4301000 0 0x1000>,
<0x0 0xc4302000 0 0x0100>;
interrupts = ;
};

1、定义interrupt-parent属性是定义在root节点，这样其他有中断的节点就不需要再定义了，直接继承。

系统在启动时，按照如下过程，分解irq dts：
of_irq_find_parent+0x68/0x6c
of_irq_init+0xb0/0x2c4
irqchip_init+0x10/0x1c
init_IRQ+0x8/0x2c arch/arm64/kernel/irq.c:80: irqchip_init();
start_kernel+0x1ec/0x354

分解
drivers/of/irq.c

device_name
drivers/of/platform.c

void of_device_make_bus_id(struct device *dev)
{

name = of_get_property(node, "device_name", NULL);
if (name) {
    dev_set_name(dev, "%s", name);
    return;
}
reg = of_get_property(node, "reg", NULL);
if (reg) {
    if (of_can_translate_address(node)) {
        addr = of_translate_address(node, reg);
    } else {
        addrp = of_get_address(node, 0, NULL, NULL);
        if (addrp)
            addr = of_read_number(addrp, 1);
        else
            addr = OF_BAD_ADDR;
    }
    if (addr != OF_BAD_ADDR) {
        dev_set_name(dev, "%llx.%s",
                 (unsigned long long)addr, node->name);
        return;
    }
}

/*
 * No BusID, use the node name and add a globally incremented
 * counter (and pray...)
 */
magic = atomic_add_return(1, &bus_no_reg_magic);
dev_set_name(dev, "%s.%d", node->name, magic - 1);

}

优先使用device_name属性作为设备名。
例1：
aml_sensor0: aml-sensor@0 {
compatible = “amlogic, aml-thermal”;
device_name = “thermal”;
#thermal-sensor-cells = <1>;
cpu_dyn_coeff = <140>;
/* cpu_freq gpu_freq cpu_core gpu_core */
min_state = <1000000 400 1 1>;
};

platform->dev->name：thermal
node->full_name：/aml-sensor@0

如果没有device_name，则使用reg参数作为设备名。
例2：
gpu_clk:gpu_clk@c883c00 {
compatible = “meson, gpu-clkgen-1.00.a”;
#clock-cells = <0>;
reg = <0 0xc883c000 0 0x00100>;

platform->dev->name：c883c000.gpu_clk
node->full_name: /gpu_clk@c883c00

如果没有reg，则动态分配（atomic）一个整数。
例3：
timer {
compatible = “arm,armv8-timer”;
interrupts = ,
,
,
;
};

platform->dev->name：/timer
node->full_name: timer.0

static atomic_t bus_no_reg_magic;
magic = atomic_add_return(1, &bus_no_reg_magic);
dev_set_name(dev, “%s.%d”, node->name, magic - 1);

第一个返回的值是0，依次是1, 2, 3, 4, …
格式是：节点的短名.编号
timer.0 timer.1 timer2 tmier.3

结构体
of_device_id

函数
of_get_flat_dt_root()

例1：
unsigned long root = of_get_flat_dt_root();

drivers/of/fdt.c
unsigned long __init of_get_flat_dt_root(void)
{
return 0;
}

of_flat_dt_is_compatible()

drivers/of/fdt.c
int __init of_flat_dt_is_compatible(unsigned long node, const char *compat)
{
return of_fdt_is_compatible(initial_boot_params, node, compat);
}

of_scan_flat_dt()

drivers/of/fdt.c
int __init of_scan_flat_dt(int (*it)(unsigned long node,
const char *uname, int depth,
void *data),
void *data)
{
const void *blob = initial_boot_params;
const char *pathp;
int offset, rc = 0, depth = -1;

    for (offset = fdt_next_node(blob, -1, &depth);
         offset >= 0 && depth >= 0 && !rc;
         offset = fdt_next_node(blob, offset, &depth)) {

    pathp = fdt_get_name(blob, offset, NULL);
    if (*pathp == '/')
        pathp = kbasename(pathp);
    rc = it(offset, pathp, depth, data);
}
return rc;

}

每一个节点，包括其子节点，都会扫描一遍。
如果一旦回调函数返回非零值，则不再继续。

有如下几处调用：
drivers/of/fdt.c
void __init early_init_fdt_scan_reserved_mem(void)
{
if (!initial_boot_params)
return;

of_scan_flat_dt(__fdt_scan_reserved_mem, NULL);
fdt_init_reserved_mem();

}

bool __init early_init_dt_scan(void *params)
{
if (!params)
return false;

/* Setup flat device-tree pointer */
initial_boot_params = params;

/* check device tree validity */
if (be32_to_cpu(initial_boot_params->magic) != OF_DT_HEADER) {
    initial_boot_params = NULL;
    return false;
}

/* 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);

return true;

}

of_flat_dt_is_compatible()

drivers/of/of_reserved_mem.c
static int __init __reserved_mem_init_node(struct reserved_mem *rmem)
{
extern const struct of_device_id __reservedmem_of_table[];
const struct of_device_id *i;
int ret = 0;

for (i = __reservedmem_of_table; i < &__rmem_of_table_sentinel; i++) {
    reservedmem_of_init_fn initfn = i->data;
    const char *compat = i->compatible;

    if (!of_flat_dt_is_compatible(rmem->fdt_node, compat))
        continue;

    /*
     * scan whole table to set up all initfn, if one memory region
     * is used by multi-users.
     */
    if (initfn(rmem) == 0) {
        pr_debug("Reserved memory: initialized node %s, compatible id %s\n",
            rmem->name, compat);
    } else
        ret--;
}
return ret;

}

of_find_node_by_path()

例1：
struct device_node *root = of_find_node_by_path(“/”)

例2：
struct device_node *memory;
memory = of_find_node_by_path(“/memory”);

of_find_node_by_name()

如果第一个参数为NULL，则是在全局中查找结点。
例1：
np = of_find_node_by_name(NULL, “thermal-zones”)

of_device_is_compatible

of_get_property

of_property_read_u32_index
of_property_read_u32_array
of_property_read_u64

of_property_read_string
of_property_read_string_index
of_property_count_strings

of_iomap

of_irq_get
irq_of_parse_and_map
of_irq_to_resource
of_irq_count

gpiolib-of
drivers/gpio/gpiolib-of.c