void __init setup_arch(char **cmdline_p) { *cmdline_p = boot_command_line; console_verbose(); unflatten_device_tree(); setup_cpuinfo(); microblaze_cache_init(); setup_memory(); #ifdef CONFIG_EARLY_PRINTK /* remap early console to virtual address */ remap_early_printk(); #endif xilinx_pci_init(); #if defined(CONFIG_DUMMY_CONSOLE) conswitchp = &dummy_con; #endif }
void __init setup_arch(char **cmdline_p) { *cmdline_p = cmd_line; console_verbose(); unflatten_device_tree(); /* NOTE I think that this function is not necessary to call */ /* irq_early_init(); */ setup_cpuinfo(); microblaze_cache_init(); setup_memory(); #ifdef CONFIG_EARLY_PRINTK /* remap early console to virtual address */ remap_early_printk(); #endif xilinx_pci_init(); #if defined(CONFIG_SELFMOD_INTC) || defined(CONFIG_SELFMOD_TIMER) printk(KERN_NOTICE "Self modified code enable\n"); #endif #ifdef CONFIG_VT #if defined(CONFIG_XILINX_CONSOLE) conswitchp = &xil_con; #elif defined(CONFIG_DUMMY_CONSOLE) conswitchp = &dummy_con; #endif #endif }
void __init setup_arch(char **cmdline_p) { *cmdline_p = cmd_line; console_verbose(); unflatten_device_tree(); setup_cpuinfo(); microblaze_cache_init(); setup_memory(); #ifdef CONFIG_EARLY_PRINTK /* */ remap_early_printk(); #endif xilinx_pci_init(); #if defined(CONFIG_SELFMOD_INTC) || defined(CONFIG_SELFMOD_TIMER) printk(KERN_NOTICE "Self modified code enable\n"); #endif #ifdef CONFIG_VT #if defined(CONFIG_XILINX_CONSOLE) conswitchp = &xil_con; #elif defined(CONFIG_DUMMY_CONSOLE) conswitchp = &dummy_con; #endif #endif }
void __init setup_arch(char **cmdline_p) { init_mm.start_code = (unsigned long) _stext; init_mm.end_code = (unsigned long) _etext; init_mm.end_data = (unsigned long) _edata; init_mm.brk = (unsigned long) _end; *cmdline_p = boot_command_line; parse_early_param(); setup_bootmem(); paging_init(); unflatten_device_tree(); #ifdef CONFIG_SWIOTLB swiotlb_init(1); #endif #ifdef CONFIG_SMP setup_smp(); #endif #ifdef CONFIG_DUMMY_CONSOLE conswitchp = &dummy_con; #endif riscv_fill_hwcap(); }
void __init device_tree_init(void) { unsigned long base, size; void *fdt_copy; if (!initial_boot_params) return; base = virt_to_phys((void *)initial_boot_params); size = be32_to_cpu(initial_boot_params->totalsize); /* Before we do anything, lets reserve the dt blob */ reserve_bootmem(base, size, BOOTMEM_DEFAULT); /* The strings in the flattened tree are referenced directly by the * device tree, so copy the flattened device tree from init memory * to regular memory. */ fdt_copy = alloc_bootmem(size); memcpy(fdt_copy, initial_boot_params, size); initial_boot_params = fdt_copy; unflatten_device_tree(); /* free the space reserved for the dt blob */ free_bootmem(base, size); }
static void __init device_tree_init(void) { unsigned long base, size; struct device_node *cpu; int ret; if (!initial_boot_params) return; base = __pa(initial_boot_params); size = be32_to_cpu(initial_boot_params->totalsize); /* Before we do anything, lets reserve the dt blob */ memblock_reserve(base, size); unflatten_device_tree(); /* free the space reserved for the dt blob */ memblock_free(base, size); cpu = of_find_compatible_node(NULL, NULL, "lattice,lm32"); if (!cpu) panic("No compatible CPU found in device tree\n"); ret = of_property_read_u32(cpu, "clock-frequency", &cpu_frequency); if (ret) cpu_frequency = (unsigned long)CONFIG_CPU_CLOCK; of_node_put(cpu); }
void __init setup_arch(char **cmdline_p) { /* This also populates @boot_command_line from /bootargs */ machine_desc = setup_machine_fdt(__dtb_start); if (!machine_desc) panic("Embedded DT invalid\n"); /* Append any u-boot provided cmdline */ #ifdef CONFIG_CMDLINE_UBOOT /* Add a whitespace seperator between the 2 cmdlines */ strlcat(boot_command_line, " ", COMMAND_LINE_SIZE); strlcat(boot_command_line, command_line, COMMAND_LINE_SIZE); #endif /* 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(); #ifdef CONFIG_SMP smp_init_cpus(); #endif setup_arch_memory(); /* copy flat DT out of .init and then unflatten it */ copy_devtree(); unflatten_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; console_verbose(); #if defined(CONFIG_VT) && defined(CONFIG_DUMMY_CONSOLE) conswitchp = &dummy_con; #endif arc_unwind_init(); arc_unwind_setup(); }
void __init device_tree_init(void) { unsigned long base, size; if (!initial_boot_params) return; base = virt_to_phys((void *)initial_boot_params); size = be32_to_cpu(initial_boot_params->totalsize); /* Before we do anything, lets reserve the dt blob */ reserve_bootmem(base, size, BOOTMEM_DEFAULT); unflatten_device_tree(); }
void __init device_tree_init(void) { unsigned long base, size; if (!initial_boot_params) return; base = virt_to_phys((void *)initial_boot_params); size = be32_to_cpu(initial_boot_params->totalsize); /* */ reserve_mem_mach(base, size); unflatten_device_tree(); /* */ free_mem_mach(base, size); }
void __init device_tree_init(void) { unsigned long base, size; if (!initial_boot_params) return; base = virt_to_phys((void *)initial_boot_params); size = be32_to_cpu(initial_boot_params->totalsize); /* Before we do anything, lets reserve the dt blob */ reserve_mem_mach(base, size); unflatten_device_tree(); /* free the space reserved for the dt blob */ free_mem_mach(base, size); }
void __init device_tree_init(void) { unsigned long base, size; void *fdt_copy; set_io_port_base(KSEG1); /* * Load the builtin devicetree. This causes the chosen node to be * parsed resulting in our memory appearing */ printk ("DTB: device_tree_init - DBG\n"); __dt_setup_arch(&__image_dtb); printk ("DTB: device_tree_init - after __dt_setup_arch - DBG\n"); if (!initial_boot_params) return; printk ("DTB: device_tree_init - initial_boot_params - DBG\n"); base = virt_to_phys((void *)initial_boot_params); size = be32_to_cpu(initial_boot_params->totalsize); /* Before we do anything, lets reserve the dt blob */ reserve_bootmem(base, size, BOOTMEM_DEFAULT); /* The strings in the flattened tree are referenced directly by the * device tree, so copy the flattened device tree from init memory * to regular memory. */ fdt_copy = alloc_bootmem(size); memcpy(fdt_copy, initial_boot_params, size); initial_boot_params = fdt_copy; unflatten_device_tree(); /* free the space reserved for the dt blob */ //free_bootmem(base, size); printk ("DTB: device_tree_init - end - DBG\n"); }
/** * unflatten_and_copy_device_tree - copy and create tree of device_nodes from flat blob * * Copies and 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. This should only be used when the FDT memory has not been * reserved such is the case when the FDT is built-in to the kernel init * section. If the FDT memory is reserved already then unflatten_device_tree * should be used instead. */ void __init unflatten_and_copy_device_tree(void) { int size; void *dt; if (!initial_boot_params) { pr_warn("No valid device tree found, continuing without\n"); return; } size = fdt_totalsize(initial_boot_params); dt = early_init_dt_alloc_memory_arch(size, roundup_pow_of_two(FDT_V17_SIZE)); if (dt) { memcpy(dt, initial_boot_params, size); initial_boot_params = dt; } unflatten_device_tree(); }
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(); }
static void __init mapphone_init_early(void) { omap2_init_common_infrastructure(); omap2_init_common_devices(NULL, NULL); #ifdef CONFIG_OMAP_32K_TIMER omap2_gp_clockevent_set_gptimer(1); #endif if (fdt_start_address) { struct device_node *machine_node; const void *machine_prop; const void *cpu_tier_prop; void *mem; mem = __alloc_bootmem(fdt_size, __alignof__(int), 0); BUG_ON(!mem); memcpy(mem, (const void *)fdt_start_address, fdt_size); initial_boot_params = (struct boot_param_header *)mem; pr_info("Unflattening device tree: 0x%08x\n", (u32)mem); unflatten_device_tree(); machine_node = of_find_node_by_path(DT_PATH_MACHINE); if (machine_node) { machine_prop = of_get_property(machine_node, DT_PROP_MACHINE_TYPE, NULL); if (machine_prop) set_machine_name((const char *)machine_prop); cpu_tier_prop = of_get_property(machine_node, DT_PROP_CPU_TIER, NULL); if (cpu_tier_prop) set_cpu_tier((const char *)cpu_tier_prop); of_node_put(machine_node); } } }
void __init setup_arch(char **cmdline_p) { #ifdef CONFIG_CMDLINE_FORCE strlcpy(cmd_line, CONFIG_CMDLINE, COMMAND_LINE_SIZE); strlcpy(boot_command_line, CONFIG_CMDLINE, COMMAND_LINE_SIZE); #endif *cmdline_p = cmd_line; console_verbose(); unflatten_device_tree(); /* NOTE I think that this function is not necessary to call */ /* irq_early_init(); */ setup_cpuinfo(); __invalidate_icache_all(); __enable_icache(); __invalidate_dcache_all(); __enable_dcache(); panic_timeout = 120; setup_memory(); #if defined(CONFIG_SELFMOD_INTC) || defined(CONFIG_SELFMOD_TIMER) printk(KERN_NOTICE "Self modified code enable\n"); #endif #ifdef CONFIG_VT #if defined(CONFIG_XILINX_CONSOLE) conswitchp = &xil_con; #elif defined(CONFIG_DUMMY_CONSOLE) conswitchp = &dummy_con; #endif #endif }
/* * Do some initial setup of the system. The parameters are those which * were passed in from the bootloader. */ void __init setup_system(void) { DBG(" -> setup_system()\n"); /* Apply the CPUs-specific and firmware specific fixups to kernel * text (nop out sections not relevant to this CPU or this firmware) */ do_feature_fixups(cur_cpu_spec->cpu_features, &__start___ftr_fixup, &__stop___ftr_fixup); do_feature_fixups(cur_cpu_spec->mmu_features, &__start___mmu_ftr_fixup, &__stop___mmu_ftr_fixup); do_feature_fixups(powerpc_firmware_features, &__start___fw_ftr_fixup, &__stop___fw_ftr_fixup); do_lwsync_fixups(cur_cpu_spec->cpu_features, &__start___lwsync_fixup, &__stop___lwsync_fixup); /* * Unflatten the device-tree passed by prom_init or kexec */ unflatten_device_tree(); /* * Fill the ppc64_caches & systemcfg structures with informations * retrieved from the device-tree. */ initialize_cache_info(); #ifdef CONFIG_PPC_RTAS /* * Initialize RTAS if available */ rtas_initialize(); #endif /* CONFIG_PPC_RTAS */ /* * Check if we have an initrd provided via the device-tree */ check_for_initrd(); /* * Do some platform specific early initializations, that includes * setting up the hash table pointers. It also sets up some interrupt-mapping * related options that will be used by finish_device_tree() */ if (ppc_md.init_early) ppc_md.init_early(); /* * We can discover serial ports now since the above did setup the * hash table management for us, thus ioremap works. We do that early * so that further code can be debugged */ find_legacy_serial_ports(); /* * Register early console */ register_early_udbg_console(); /* * Initialize xmon */ xmon_setup(); smp_setup_cpu_maps(); check_smt_enabled(); #ifdef CONFIG_SMP /* Release secondary cpus out of their spinloops at 0x60 now that * we can map physical -> logical CPU ids */ smp_release_cpus(); #endif printk("Starting Linux PPC64 %s\n", init_utsname()->version); printk("-----------------------------------------------------\n"); printk("ppc64_pft_size = 0x%llx\n", ppc64_pft_size); printk("physicalMemorySize = 0x%llx\n", memblock_phys_mem_size()); if (ppc64_caches.dline_size != 0x80) printk("ppc64_caches.dcache_line_size = 0x%x\n", ppc64_caches.dline_size); if (ppc64_caches.iline_size != 0x80) printk("ppc64_caches.icache_line_size = 0x%x\n", ppc64_caches.iline_size); #ifdef CONFIG_PPC_STD_MMU_64 if (htab_address) printk("htab_address = 0x%p\n", htab_address); printk("htab_hash_mask = 0x%lx\n", htab_hash_mask); #endif /* CONFIG_PPC_STD_MMU_64 */ if (PHYSICAL_START > 0) printk("physical_start = 0x%llx\n", (unsigned long long)PHYSICAL_START); printk("-----------------------------------------------------\n"); DBG(" <- setup_system()\n"); }
/* Warning, IO base is not yet inited */ void __init setup_arch(char **cmdline_p) { *cmdline_p = cmd_line; /* so udelay does something sensible, assume <= 1000 bogomips */ loops_per_jiffy = 500000000 / HZ; unflatten_device_tree(); check_for_initrd(); if (ppc_md.init_early) ppc_md.init_early(); find_legacy_serial_ports(); smp_setup_cpu_maps(); /* Register early console */ register_early_udbg_console(); xmon_setup(); /* * Set cache line size based on type of cpu as a default. * Systems with OF can look in the properties on the cpu node(s) * for a possibly more accurate value. */ dcache_bsize = cur_cpu_spec->dcache_bsize; icache_bsize = cur_cpu_spec->icache_bsize; ucache_bsize = 0; if (cpu_has_feature(CPU_FTR_UNIFIED_ID_CACHE)) ucache_bsize = icache_bsize = dcache_bsize; /* reboot on panic */ panic_timeout = 180; if (ppc_md.panic) setup_panic(); init_mm.start_code = (unsigned long)_stext; init_mm.end_code = (unsigned long) _etext; init_mm.end_data = (unsigned long) _edata; init_mm.brk = klimit; exc_lvl_early_init(); irqstack_early_init(); /* set up the bootmem stuff with available memory */ do_init_bootmem(); if ( ppc_md.progress ) ppc_md.progress("setup_arch: bootmem", 0x3eab); #ifdef CONFIG_DUMMY_CONSOLE conswitchp = &dummy_con; #endif if (ppc_md.setup_arch) ppc_md.setup_arch(); if ( ppc_md.progress ) ppc_md.progress("arch: exit", 0x3eab); paging_init(); /* Initialize the MMU context management stuff */ mmu_context_init(); }
/* * Do some initial setup of the system. The parameters are those which * were passed in from the bootloader. */ void __init setup_system(void) { DBG(" -> setup_system()\n"); #ifdef CONFIG_KEXEC kdump_move_device_tree(); #endif /* * Unflatten the device-tree passed by prom_init or kexec */ unflatten_device_tree(); #ifdef CONFIG_KEXEC kexec_setup(); /* requires unflattened device tree. */ #endif /* * Fill the ppc64_caches & systemcfg structures with informations * retrieved from the device-tree. Need to be called before * finish_device_tree() since the later requires some of the * informations filled up here to properly parse the interrupt * tree. * It also sets up the cache line sizes which allows to call * routines like flush_icache_range (used by the hash init * later on). */ initialize_cache_info(); #ifdef CONFIG_PPC_RTAS /* * Initialize RTAS if available */ rtas_initialize(); #endif /* CONFIG_PPC_RTAS */ /* * Check if we have an initrd provided via the device-tree */ check_for_initrd(); /* * Do some platform specific early initializations, that includes * setting up the hash table pointers. It also sets up some interrupt-mapping * related options that will be used by finish_device_tree() */ ppc_md.init_early(); /* * We can discover serial ports now since the above did setup the * hash table management for us, thus ioremap works. We do that early * so that further code can be debugged */ find_legacy_serial_ports(); /* * "Finish" the device-tree, that is do the actual parsing of * some of the properties like the interrupt map */ finish_device_tree(); /* * Initialize xmon */ #ifdef CONFIG_XMON_DEFAULT xmon_init(1); #endif /* * Register early console */ register_early_udbg_console(); /* Save unparsed command line copy for /proc/cmdline */ strlcpy(saved_command_line, cmd_line, COMMAND_LINE_SIZE); parse_early_param(); check_smt_enabled(); smp_setup_cpu_maps(); #ifdef CONFIG_SMP /* Release secondary cpus out of their spinloops at 0x60 now that * we can map physical -> logical CPU ids */ smp_release_cpus(); #endif printk("Starting Linux PPC64 %s\n", system_utsname.version); printk("-----------------------------------------------------\n"); printk("ppc64_pft_size = 0x%lx\n", ppc64_pft_size); printk("ppc64_interrupt_controller = 0x%ld\n", ppc64_interrupt_controller); printk("platform = 0x%x\n", _machine); printk("physicalMemorySize = 0x%lx\n", lmb_phys_mem_size()); printk("ppc64_caches.dcache_line_size = 0x%x\n", ppc64_caches.dline_size); printk("ppc64_caches.icache_line_size = 0x%x\n", ppc64_caches.iline_size); printk("htab_address = 0x%p\n", htab_address); printk("htab_hash_mask = 0x%lx\n", htab_hash_mask); #if PHYSICAL_START > 0 printk("physical_start = 0x%x\n", PHYSICAL_START); #endif printk("-----------------------------------------------------\n"); mm_init_ppc64(); DBG(" <- setup_system()\n"); }
void __init setup_arch(char **cmdline_p) { strlcpy(boot_command_line, command_line, COMMAND_LINE_SIZE); *cmdline_p = command_line; check_s32c1i(); /* 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); 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 bootmem_init(); #ifdef CONFIG_OF copy_devtree(); unflatten_device_tree(); #endif platform_setup(cmdline_p); 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 }
/* * Do some initial setup of the system. The parameters are those which * were passed in from the bootloader. */ void __init setup_system(void) { DBG(" -> setup_system()\n"); #ifdef CONFIG_PPC_ISERIES /* pSeries systems are identified in prom.c via OF. */ if (itLpNaca.xLparInstalled == 1) systemcfg->platform = PLATFORM_ISERIES_LPAR; ppc_md.init_early(); #else /* CONFIG_PPC_ISERIES */ /* * Unflatten the device-tree passed by prom_init or kexec */ unflatten_device_tree(); /* * Fill the naca & systemcfg structures with informations * retreived from the device-tree. Need to be called before * finish_device_tree() since the later requires some of the * informations filled up here to properly parse the interrupt * tree. * It also sets up the cache line sizes which allows to call * routines like flush_icache_range (used by the hash init * later on). */ initialize_naca(); #ifdef CONFIG_PPC_PSERIES /* * Initialize RTAS if available */ rtas_initialize(); #endif /* CONFIG_PPC_PSERIES */ /* * Check if we have an initrd provided via the device-tree */ check_for_initrd(); /* * Do some platform specific early initializations, that includes * setting up the hash table pointers. It also sets up some interrupt-mapping * related options that will be used by finish_device_tree() */ ppc_md.init_early(); /* * "Finish" the device-tree, that is do the actual parsing of * some of the properties like the interrupt map */ finish_device_tree(); /* * Initialize xmon */ #ifdef CONFIG_XMON_DEFAULT xmon_init(); #endif /* * Register early console */ early_console_initialized = 1; register_console(&udbg_console); /* Save unparsed command line copy for /proc/cmdline */ strlcpy(saved_command_line, cmd_line, COMMAND_LINE_SIZE); parse_early_param(); #endif /* !CONFIG_PPC_ISERIES */ #if defined(CONFIG_SMP) && !defined(CONFIG_PPC_ISERIES) /* * iSeries has already initialized the cpu maps at this point. */ setup_cpu_maps(); /* Release secondary cpus out of their spinloops at 0x60 now that * we can map physical -> logical CPU ids */ smp_release_cpus(); #endif /* defined(CONFIG_SMP) && !defined(CONFIG_PPC_ISERIES) */ printk("Starting Linux PPC64 %s\n", UTS_RELEASE); printk("-----------------------------------------------------\n"); printk("naca = 0x%p\n", naca); printk("naca->pftSize = 0x%lx\n", naca->pftSize); printk("naca->debug_switch = 0x%lx\n", naca->debug_switch); printk("naca->interrupt_controller = 0x%ld\n", naca->interrupt_controller); printk("systemcfg = 0x%p\n", systemcfg); printk("systemcfg->platform = 0x%x\n", systemcfg->platform); printk("systemcfg->processorCount = 0x%lx\n", systemcfg->processorCount); printk("systemcfg->physicalMemorySize = 0x%lx\n", systemcfg->physicalMemorySize); printk("systemcfg->dCacheL1LineSize = 0x%x\n", systemcfg->dCacheL1LineSize); printk("systemcfg->iCacheL1LineSize = 0x%x\n", systemcfg->iCacheL1LineSize); printk("htab_data.htab = 0x%p\n", htab_data.htab); printk("htab_data.num_ptegs = 0x%lx\n", htab_data.htab_num_ptegs); printk("-----------------------------------------------------\n"); mm_init_ppc64(); DBG(" <- setup_system()\n"); }
void __init setup_arch(char **cmdline_p) { *cmdline_p = cmd_line; loops_per_jiffy = 500000000 / HZ; unflatten_device_tree(); check_for_initrd(); if (ppc_md.init_early) ppc_md.init_early(); find_legacy_serial_ports(); smp_setup_cpu_maps(); register_early_udbg_console(); xmon_setup(); dcache_bsize = cur_cpu_spec->dcache_bsize; icache_bsize = cur_cpu_spec->icache_bsize; ucache_bsize = 0; if (cpu_has_feature(CPU_FTR_UNIFIED_ID_CACHE)) ucache_bsize = icache_bsize = dcache_bsize; panic_timeout = 180; if (ppc_md.panic) setup_panic(); init_mm.start_code = (unsigned long)_stext; init_mm.end_code = (unsigned long) _etext; init_mm.end_data = (unsigned long) _edata; init_mm.brk = klimit; exc_lvl_early_init(); irqstack_early_init(); do_init_bootmem(); if ( ppc_md.progress ) ppc_md.progress("setup_arch: bootmem", 0x3eab); #ifdef CONFIG_DUMMY_CONSOLE conswitchp = &dummy_con; #endif if (ppc_md.setup_arch) ppc_md.setup_arch(); if ( ppc_md.progress ) ppc_md.progress("arch: exit", 0x3eab); paging_init(); mmu_context_init(); }
/* Warning, IO base is not yet inited */ void __init setup_arch(char **cmdline_p) { extern void do_init_bootmem(void); /* so udelay does something sensible, assume <= 1000 bogomips */ loops_per_jiffy = 500000000 / HZ; unflatten_device_tree(); check_for_initrd(); finish_device_tree(); smp_setup_cpu_maps(); #ifdef CONFIG_BOOTX_TEXT init_boot_display(); #endif #ifdef CONFIG_PPC_PMAC /* This could be called "early setup arch", it must be done * now because xmon need it */ if (_machine == _MACH_Pmac) pmac_feature_init(); /* New cool way */ #endif #ifdef CONFIG_XMON_DEFAULT xmon_init(1); #endif #if defined(CONFIG_KGDB) if (ppc_md.kgdb_map_scc) ppc_md.kgdb_map_scc(); set_debug_traps(); if (strstr(cmd_line, "gdb")) { if (ppc_md.progress) ppc_md.progress("setup_arch: kgdb breakpoint", 0x4000); printk("kgdb breakpoint activated\n"); breakpoint(); } #endif /* * Set cache line size based on type of cpu as a default. * Systems with OF can look in the properties on the cpu node(s) * for a possibly more accurate value. */ if (cpu_has_feature(CPU_FTR_SPLIT_ID_CACHE)) { dcache_bsize = cur_cpu_spec->dcache_bsize; icache_bsize = cur_cpu_spec->icache_bsize; ucache_bsize = 0; } else ucache_bsize = dcache_bsize = icache_bsize = cur_cpu_spec->dcache_bsize; /* reboot on panic */ panic_timeout = 180; init_mm.start_code = PAGE_OFFSET; init_mm.end_code = (unsigned long) _etext; init_mm.end_data = (unsigned long) _edata; init_mm.brk = klimit; /* Save unparsed command line copy for /proc/cmdline */ strlcpy(saved_command_line, cmd_line, COMMAND_LINE_SIZE); *cmdline_p = cmd_line; parse_early_param(); /* set up the bootmem stuff with available memory */ do_init_bootmem(); if ( ppc_md.progress ) ppc_md.progress("setup_arch: bootmem", 0x3eab); #ifdef CONFIG_PPC_OCP /* Initialize OCP device list */ ocp_early_init(); if ( ppc_md.progress ) ppc_md.progress("ocp: exit", 0x3eab); #endif #ifdef CONFIG_DUMMY_CONSOLE conswitchp = &dummy_con; #endif ppc_md.setup_arch(); if ( ppc_md.progress ) ppc_md.progress("arch: exit", 0x3eab); paging_init(); /* this is for modules since _machine can be a define -- Cort */ ppc_md.ppc_machine = _machine; }