linux 4.1设备树解析源码跟踪

asmlinkage __visible void __init start_kernel(void)
{
char *command_line;
setup_arch(&command_line);
setup_command_line(command_line);
}

//这个setup_arch就是各个架构自己的设置函数，哪个参与了编译就调用哪个，arm架构应当是arch/arm/kernel/setup.c中的 setup_arch。void __init setup_arch(char **cmdline_p)
{
const struct machine_desc *mdesc;

setup_processor();

setup_machine_fdt函数获取内核前期初始化所需的bootargs，cmd_line等系统引导参数
//__atags_pointer是bootloader传递参数的物理地址
mdesc = setup_machine_fdt(__atags_pointer);
if (!mdesc)
mdesc = setup_machine_tags(__atags_pointer, __machine_arch_type);

/* populate cmd_line too for later use, preserving boot_command_line */
strlcpy(cmd_line, boot_command_line, COMMAND_LINE_SIZE);

//这是setup_arch的参数出参赋值
*cmdline_p = cmd_line;

parse_early_param();

解析设备树
unflatten_device_tree();

arm_dt_init_cpu_maps();
psci_init();

if (!is_smp())
    hyp_mode_check();

reserve_crashkernel();


if (mdesc->init_early)
    mdesc->init_early();

}

/**

• 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);
  }

///

/*

• arm_dt_init_cpu_maps - Function retrieves cpu nodes from the device tree

• and builds the cpu logical map array containing MPIDR values related to

• logical cpus

• Updates the cpu possible mask with the number of parsed cpu nodes
  /
  void __init arm_dt_init_cpu_maps(void)
  {
  /

  • Temp logical map is initialized with UINT_MAX values that are
  • considered invalid logical map entries since the logical map must
  • contain a list of MPIDR[23:0] values where MPIDR[31:24] must
  • read as 0.
    */
    struct device_node *cpu, *cpus;
    int found_method = 0;
    u32 i, j, cpuidx = 1;
    u32 mpidr = is_smp() ? read_cpuid_mpidr() & MPIDR_HWID_BITMASK : 0;

  u32 tmp_map[NR_CPUS] = { [0 … NR_CPUS-1] = MPIDR_INVALID };
  bool bootcpu_valid = false;
  cpus = of_find_node_by_path(“/cpus”);

  if (!cpus)
  return;

  for_each_child_of_node(cpus, cpu) {
  u32 hwid;

   if (of_node_cmp(cpu->type, "cpu"))
       continue;
  
   pr_debug(" * %s...\n", cpu->full_name);
   /*
    * A device tree containing CPU nodes with missing "reg"
    * properties is considered invalid to build the
    * cpu_logical_map.
    */
   if (of_property_read_u32(cpu, "reg", &hwid)) {
       pr_debug(" * %s missing reg property\n",
                cpu->full_name);
       return;
   }
  
   /*
    * 8 MSBs must be set to 0 in the DT since the reg property
    * defines the MPIDR[23:0].
    */
   if (hwid & ~MPIDR_HWID_BITMASK)
       return;
  
   /*
    * Duplicate MPIDRs are a recipe for disaster.
    * Scan all initialized entries and check for
    * duplicates. If any is found just bail out.
    * temp values were initialized to UINT_MAX
    * to avoid matching valid MPIDR[23:0] values.
    */
   for (j = 0; j < cpuidx; j++)
       if (WARN(tmp_map[j] == hwid, "Duplicate /cpu reg "
                        "properties in the DT\n"))
           return;
  
   /*
    * Build a stashed array of MPIDR values. Numbering scheme
    * requires that if detected the boot CPU must be assigned
    * logical id 0. Other CPUs get sequential indexes starting
    * from 1. If a CPU node with a reg property matching the
    * boot CPU MPIDR is detected, this is recorded so that the
    * logical map built from DT is validated and can be used
    * to override the map created in smp_setup_processor_id().
    */
   if (hwid == mpidr) {
       i = 0;
       bootcpu_valid = true;
   } else {
       i = cpuidx++;
   }
  
   if (WARN(cpuidx > nr_cpu_ids, "DT /cpu %u nodes greater than "
                      "max cores %u, capping them\n",
                      cpuidx, nr_cpu_ids)) {
       cpuidx = nr_cpu_ids;
       break;
   }
  
   tmp_map[i] = hwid;
  
   if (!found_method)
       found_method = set_smp_ops_by_method(cpu);
  

  }

  /*

  • Fallback to an enable-method in the cpus node if nothing found in
  • a cpu node.
    */
    if (!found_method)
    set_smp_ops_by_method(cpus);

  if (!bootcpu_valid) {
  pr_warn(“DT missing boot CPU MPIDR[23:0], fall back to default cpu_logical_map\n”);
  return;
  }

  /*

  • Since the boot CPU node contains proper data, and all nodes have
  • a reg property, the DT CPU list can be considered valid and the
  • logical map created in smp_setup_processor_id() can be overridden
    */
    for (i = 0; i < cpuidx; i++) {
    set_cpu_possible(i, true);
    cpu_logical_map(i) = tmp_map[i];
    pr_debug(“cpu logical map 0x%x\n”, cpu_logical_map(i));
    }
    }
    ///

static const struct of_device_id psci_of_match[] __initconst = {
{ .compatible = “arm,psci”, .data = psci_0_1_init},
{ .compatible = “arm,psci-0.2”, .data = psci_0_2_init},
{},
};

int __init psci_init(void)
{
struct device_node *np;
const struct of_device_id *matched_np;
psci_initcall_t init_fn;

np = of_find_matching_node_and_match(NULL, psci_of_match, &matched_np);
if (!np)
    return -ENODEV;

init_fn = (psci_initcall_t)matched_np->data;
return init_fn(np);

}