void __init setup_arch(char **cmdline_p) { #ifdef CONFIG_ARC_UBOOT_SUPPORT /* make sure that uboot passed pointer to cmdline/dtb is valid */ if (uboot_tag && is_kernel((unsigned long)uboot_arg)) panic("Invalid uboot arg\n"); /* See if u-boot passed an external Device Tree blob */ machine_desc = setup_machine_fdt(uboot_arg); /* uboot_tag == 2 */ if (!machine_desc) #endif { /* No, so try the embedded one */ machine_desc = setup_machine_fdt(__dtb_start); if (!machine_desc) panic("Embedded DT invalid\n"); /* * If we are here, it is established that @uboot_arg didn't * point to DT blob. Instead if u-boot says it is cmdline, * Appent to embedded DT cmdline. * setup_machine_fdt() would have populated @boot_command_line */ if (uboot_tag == 1) { /* Ensure a whitespace between the 2 cmdlines */ strlcat(boot_command_line, " ", COMMAND_LINE_SIZE); strlcat(boot_command_line, uboot_arg, COMMAND_LINE_SIZE); } } /* Save unparsed command line copy for /proc/cmdline */ *cmdline_p = boot_command_line; /* To force early parsing of things like mem=xxx */ parse_early_param(); /* Platform/board specific: e.g. early console registration */ if (machine_desc->init_early) machine_desc->init_early(); setup_processor(); smp_init_cpus(); setup_arch_memory(); /* copy flat DT out of .init and then unflatten it */ unflatten_and_copy_device_tree(); /* Can be issue if someone passes cmd line arg "ro" * But that is unlikely so keeping it as it is */ root_mountflags &= ~MS_RDONLY; #if defined(CONFIG_VT) && defined(CONFIG_DUMMY_CONSOLE) conswitchp = &dummy_con; #endif arc_unwind_init(); }
void __init device_tree_init(void) { struct device_node *np; unflatten_and_copy_device_tree(); /* Disable SMP boot unless both CPUs are listed in DT and !disabled */ np = of_find_node_by_name(NULL, "cpus"); if (np && of_get_available_child_count(np) <= 1) bmips_smp_enabled = 0; of_node_put(np); }
static void __init sh_of_setup(char **cmdline_p) { struct device_node *root; #ifdef CONFIG_USE_BUILTIN_DTB unflatten_and_copy_device_tree(); #else unflatten_device_tree(); #endif board_time_init = sh_of_time_init; sh_mv.mv_name = "Unknown SH model"; root = of_find_node_by_path("/"); if (root) { of_property_read_string(root, "model", &sh_mv.mv_name); of_node_put(root); } sh_of_smp_probe(); }
void __init device_tree_init(void) { unflatten_and_copy_device_tree(); }
void __init setup_arch(char **cmdline_p) { extern void init_etrax_debug(void); unsigned long bootmap_size; unsigned long start_pfn, max_pfn; unsigned long memory_start; #ifdef CONFIG_OF early_init_dt_scan(__dtb_start); #endif /* register an initial console printing routine for printk's */ init_etrax_debug(); /* we should really poll for DRAM size! */ high_memory = &dram_end; if(romfs_in_flash || !romfs_length) { /* if we have the romfs in flash, or if there is no rom filesystem, * our free area starts directly after the BSS */ memory_start = (unsigned long) &_end; } else { /* otherwise the free area starts after the ROM filesystem */ printk("ROM fs in RAM, size %lu bytes\n", romfs_length); memory_start = romfs_start + romfs_length; } /* process 1's initial memory region is the kernel code/data */ init_mm.start_code = (unsigned long) &text_start; init_mm.end_code = (unsigned long) &_etext; init_mm.end_data = (unsigned long) &_edata; init_mm.brk = (unsigned long) &_end; /* min_low_pfn points to the start of DRAM, start_pfn points * to the first DRAM pages after the kernel, and max_low_pfn * to the end of DRAM. */ /* * partially used pages are not usable - thus * we are rounding upwards: */ start_pfn = PFN_UP(memory_start); /* usually c0000000 + kernel + romfs */ max_pfn = PFN_DOWN((unsigned long)high_memory); /* usually c0000000 + dram size */ /* * Initialize the boot-time allocator (start, end) * * We give it access to all our DRAM, but we could as well just have * given it a small slice. No point in doing that though, unless we * have non-contiguous memory and want the boot-stuff to be in, say, * the smallest area. * * It will put a bitmap of the allocated pages in the beginning * of the range we give it, but it won't mark the bitmaps pages * as reserved. We have to do that ourselves below. * * We need to use init_bootmem_node instead of init_bootmem * because our map starts at a quite high address (min_low_pfn). */ max_low_pfn = max_pfn; min_low_pfn = PAGE_OFFSET >> PAGE_SHIFT; bootmap_size = init_bootmem_node(NODE_DATA(0), start_pfn, min_low_pfn, max_low_pfn); /* And free all memory not belonging to the kernel (addr, size) */ free_bootmem(PFN_PHYS(start_pfn), PFN_PHYS(max_pfn - start_pfn)); /* * Reserve the bootmem bitmap itself as well. We do this in two * steps (first step was init_bootmem()) because this catches * the (very unlikely) case of us accidentally initializing the * bootmem allocator with an invalid RAM area. * * Arguments are start, size */ reserve_bootmem(PFN_PHYS(start_pfn), bootmap_size, BOOTMEM_DEFAULT); unflatten_and_copy_device_tree(); /* paging_init() sets up the MMU and marks all pages as reserved */ paging_init(); *cmdline_p = cris_command_line; #ifdef CONFIG_ETRAX_CMDLINE if (!strcmp(cris_command_line, "")) { strlcpy(cris_command_line, CONFIG_ETRAX_CMDLINE, COMMAND_LINE_SIZE); cris_command_line[COMMAND_LINE_SIZE - 1] = '\0'; } #endif /* Save command line for future references. */ memcpy(boot_command_line, cris_command_line, COMMAND_LINE_SIZE); boot_command_line[COMMAND_LINE_SIZE - 1] = '\0'; /* give credit for the CRIS port */ show_etrax_copyright(); /* Setup utsname */ strcpy(init_utsname()->machine, cris_machine_name); }
void __init setup_arch(char **cmdline_p) { strlcpy(boot_command_line, command_line, COMMAND_LINE_SIZE); *cmdline_p = command_line; /* Reserve some memory regions */ #ifdef CONFIG_BLK_DEV_INITRD if (initrd_start < initrd_end) { initrd_is_mapped = mem_reserve(__pa(initrd_start), __pa(initrd_end), 0) == 0; initrd_below_start_ok = 1; } else { initrd_start = 0; } #endif mem_reserve(__pa(&_stext),__pa(&_end), 1); mem_reserve(__pa(&_WindowVectors_text_start), __pa(&_WindowVectors_text_end), 0); mem_reserve(__pa(&_DebugInterruptVector_literal_start), __pa(&_DebugInterruptVector_text_end), 0); mem_reserve(__pa(&_KernelExceptionVector_literal_start), __pa(&_KernelExceptionVector_text_end), 0); mem_reserve(__pa(&_UserExceptionVector_literal_start), __pa(&_UserExceptionVector_text_end), 0); mem_reserve(__pa(&_DoubleExceptionVector_literal_start), __pa(&_DoubleExceptionVector_text_end), 0); #if XCHAL_EXCM_LEVEL >= 2 mem_reserve(__pa(&_Level2InterruptVector_text_start), __pa(&_Level2InterruptVector_text_end), 0); #endif #if XCHAL_EXCM_LEVEL >= 3 mem_reserve(__pa(&_Level3InterruptVector_text_start), __pa(&_Level3InterruptVector_text_end), 0); #endif #if XCHAL_EXCM_LEVEL >= 4 mem_reserve(__pa(&_Level4InterruptVector_text_start), __pa(&_Level4InterruptVector_text_end), 0); #endif #if XCHAL_EXCM_LEVEL >= 5 mem_reserve(__pa(&_Level5InterruptVector_text_start), __pa(&_Level5InterruptVector_text_end), 0); #endif #if XCHAL_EXCM_LEVEL >= 6 mem_reserve(__pa(&_Level6InterruptVector_text_start), __pa(&_Level6InterruptVector_text_end), 0); #endif #ifdef CONFIG_SMP mem_reserve(__pa(&_SecondaryResetVector_text_start), __pa(&_SecondaryResetVector_text_end), 0); #endif parse_early_param(); bootmem_init(); unflatten_and_copy_device_tree(); platform_setup(cmdline_p); #ifdef CONFIG_SMP smp_init_cpus(); #endif paging_init(); zones_init(); #ifdef CONFIG_VT # if defined(CONFIG_VGA_CONSOLE) conswitchp = &vga_con; # elif defined(CONFIG_DUMMY_CONSOLE) conswitchp = &dummy_con; # endif #endif #ifdef CONFIG_PCI platform_pcibios_init(); #endif }