11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * linux/arch/arm/kernel/setup.c 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * Copyright (C) 1995-2001 Russell King 51da177e4SLinus Torvalds * 61da177e4SLinus Torvalds * This program is free software; you can redistribute it and/or modify 71da177e4SLinus Torvalds * it under the terms of the GNU General Public License version 2 as 81da177e4SLinus Torvalds * published by the Free Software Foundation. 91da177e4SLinus Torvalds */ 101da177e4SLinus Torvalds #include <linux/module.h> 111da177e4SLinus Torvalds #include <linux/kernel.h> 121da177e4SLinus Torvalds #include <linux/stddef.h> 131da177e4SLinus Torvalds #include <linux/ioport.h> 141da177e4SLinus Torvalds #include <linux/delay.h> 151da177e4SLinus Torvalds #include <linux/utsname.h> 161da177e4SLinus Torvalds #include <linux/initrd.h> 171da177e4SLinus Torvalds #include <linux/console.h> 181da177e4SLinus Torvalds #include <linux/bootmem.h> 191da177e4SLinus Torvalds #include <linux/seq_file.h> 20894673eeSJon Smirl #include <linux/screen_info.h> 211da177e4SLinus Torvalds #include <linux/init.h> 223c57fb43SMika Westerberg #include <linux/kexec.h> 23cea0bb1bSMika Westerberg #include <linux/crash_dump.h> 241da177e4SLinus Torvalds #include <linux/root_dev.h> 251da177e4SLinus Torvalds #include <linux/cpu.h> 261da177e4SLinus Torvalds #include <linux/interrupt.h> 277bbb7940SRussell King #include <linux/smp.h> 284e950f6fSAlexey Dobriyan #include <linux/fs.h> 29e119bfffSRussell King #include <linux/proc_fs.h> 302778f620SRussell King #include <linux/memblock.h> 311da177e4SLinus Torvalds 32b86040a5SCatalin Marinas #include <asm/unified.h> 331da177e4SLinus Torvalds #include <asm/cpu.h> 340ba8b9b2SRussell King #include <asm/cputype.h> 351da177e4SLinus Torvalds #include <asm/elf.h> 361da177e4SLinus Torvalds #include <asm/procinfo.h> 3737efe642SRussell King #include <asm/sections.h> 381da177e4SLinus Torvalds #include <asm/setup.h> 39f00ec48fSRussell King #include <asm/smp_plat.h> 401da177e4SLinus Torvalds #include <asm/mach-types.h> 411da177e4SLinus Torvalds #include <asm/cacheflush.h> 4246097c7dSRussell King #include <asm/cachetype.h> 431da177e4SLinus Torvalds #include <asm/tlbflush.h> 441da177e4SLinus Torvalds 451da177e4SLinus Torvalds #include <asm/mach/arch.h> 461da177e4SLinus Torvalds #include <asm/mach/irq.h> 471da177e4SLinus Torvalds #include <asm/mach/time.h> 485cbad0ebSJason Wessel #include <asm/traps.h> 49bff595c1SCatalin Marinas #include <asm/unwind.h> 501da177e4SLinus Torvalds 5173a65b3fSUwe Kleine-König #if defined(CONFIG_DEPRECATED_PARAM_STRUCT) 520fc1c832SBen Dooks #include "compat.h" 5373a65b3fSUwe Kleine-König #endif 544cd9d6f7SRichard Purdie #include "atags.h" 55bc581770SLinus Walleij #include "tcm.h" 560fc1c832SBen Dooks 571da177e4SLinus Torvalds #ifndef MEM_SIZE 581da177e4SLinus Torvalds #define MEM_SIZE (16*1024*1024) 591da177e4SLinus Torvalds #endif 601da177e4SLinus Torvalds 611da177e4SLinus Torvalds #if defined(CONFIG_FPE_NWFPE) || defined(CONFIG_FPE_FASTFPE) 621da177e4SLinus Torvalds char fpe_type[8]; 631da177e4SLinus Torvalds 641da177e4SLinus Torvalds static int __init fpe_setup(char *line) 651da177e4SLinus Torvalds { 661da177e4SLinus Torvalds memcpy(fpe_type, line, 8); 671da177e4SLinus Torvalds return 1; 681da177e4SLinus Torvalds } 691da177e4SLinus Torvalds 701da177e4SLinus Torvalds __setup("fpe=", fpe_setup); 711da177e4SLinus Torvalds #endif 721da177e4SLinus Torvalds 734b5f32ceSNicolas Pitre extern void paging_init(struct machine_desc *desc); 741da177e4SLinus Torvalds extern void reboot_setup(char *str); 751da177e4SLinus Torvalds 761da177e4SLinus Torvalds unsigned int processor_id; 77c18f6581SKrzysztof Halasa EXPORT_SYMBOL(processor_id); 780385ebc0SRussell King unsigned int __machine_arch_type __read_mostly; 791da177e4SLinus Torvalds EXPORT_SYMBOL(__machine_arch_type); 800385ebc0SRussell King unsigned int cacheid __read_mostly; 81c0e95878SRussell King EXPORT_SYMBOL(cacheid); 821da177e4SLinus Torvalds 839d20fdd5SBill Gatliff unsigned int __atags_pointer __initdata; 849d20fdd5SBill Gatliff 851da177e4SLinus Torvalds unsigned int system_rev; 861da177e4SLinus Torvalds EXPORT_SYMBOL(system_rev); 871da177e4SLinus Torvalds 881da177e4SLinus Torvalds unsigned int system_serial_low; 891da177e4SLinus Torvalds EXPORT_SYMBOL(system_serial_low); 901da177e4SLinus Torvalds 911da177e4SLinus Torvalds unsigned int system_serial_high; 921da177e4SLinus Torvalds EXPORT_SYMBOL(system_serial_high); 931da177e4SLinus Torvalds 940385ebc0SRussell King unsigned int elf_hwcap __read_mostly; 951da177e4SLinus Torvalds EXPORT_SYMBOL(elf_hwcap); 961da177e4SLinus Torvalds 971da177e4SLinus Torvalds 981da177e4SLinus Torvalds #ifdef MULTI_CPU 990385ebc0SRussell King struct processor processor __read_mostly; 1001da177e4SLinus Torvalds #endif 1011da177e4SLinus Torvalds #ifdef MULTI_TLB 1020385ebc0SRussell King struct cpu_tlb_fns cpu_tlb __read_mostly; 1031da177e4SLinus Torvalds #endif 1041da177e4SLinus Torvalds #ifdef MULTI_USER 1050385ebc0SRussell King struct cpu_user_fns cpu_user __read_mostly; 1061da177e4SLinus Torvalds #endif 1071da177e4SLinus Torvalds #ifdef MULTI_CACHE 1080385ebc0SRussell King struct cpu_cache_fns cpu_cache __read_mostly; 1091da177e4SLinus Torvalds #endif 110953233dcSCatalin Marinas #ifdef CONFIG_OUTER_CACHE 1110385ebc0SRussell King struct outer_cache_fns outer_cache __read_mostly; 1126c09f09dSSantosh Shilimkar EXPORT_SYMBOL(outer_cache); 113953233dcSCatalin Marinas #endif 1141da177e4SLinus Torvalds 115ccea7a19SRussell King struct stack { 116ccea7a19SRussell King u32 irq[3]; 117ccea7a19SRussell King u32 abt[3]; 118ccea7a19SRussell King u32 und[3]; 119ccea7a19SRussell King } ____cacheline_aligned; 120ccea7a19SRussell King 121ccea7a19SRussell King static struct stack stacks[NR_CPUS]; 122ccea7a19SRussell King 1231da177e4SLinus Torvalds char elf_platform[ELF_PLATFORM_SIZE]; 1241da177e4SLinus Torvalds EXPORT_SYMBOL(elf_platform); 1251da177e4SLinus Torvalds 1261da177e4SLinus Torvalds static const char *cpu_name; 1271da177e4SLinus Torvalds static const char *machine_name; 12848ab7e09SJeremy Kerr static char __initdata cmd_line[COMMAND_LINE_SIZE]; 1298ff1443cSRussell King struct machine_desc *machine_desc __initdata; 1301da177e4SLinus Torvalds 1311da177e4SLinus Torvalds static char default_command_line[COMMAND_LINE_SIZE] __initdata = CONFIG_CMDLINE; 1321da177e4SLinus Torvalds static union { char c[4]; unsigned long l; } endian_test __initdata = { { 'l', '?', '?', 'b' } }; 1331da177e4SLinus Torvalds #define ENDIANNESS ((char)endian_test.l) 1341da177e4SLinus Torvalds 1351da177e4SLinus Torvalds DEFINE_PER_CPU(struct cpuinfo_arm, cpu_data); 1361da177e4SLinus Torvalds 1371da177e4SLinus Torvalds /* 1381da177e4SLinus Torvalds * Standard memory resources 1391da177e4SLinus Torvalds */ 1401da177e4SLinus Torvalds static struct resource mem_res[] = { 141740e518eSGreg Kroah-Hartman { 142740e518eSGreg Kroah-Hartman .name = "Video RAM", 143740e518eSGreg Kroah-Hartman .start = 0, 144740e518eSGreg Kroah-Hartman .end = 0, 145740e518eSGreg Kroah-Hartman .flags = IORESOURCE_MEM 146740e518eSGreg Kroah-Hartman }, 147740e518eSGreg Kroah-Hartman { 148740e518eSGreg Kroah-Hartman .name = "Kernel text", 149740e518eSGreg Kroah-Hartman .start = 0, 150740e518eSGreg Kroah-Hartman .end = 0, 151740e518eSGreg Kroah-Hartman .flags = IORESOURCE_MEM 152740e518eSGreg Kroah-Hartman }, 153740e518eSGreg Kroah-Hartman { 154740e518eSGreg Kroah-Hartman .name = "Kernel data", 155740e518eSGreg Kroah-Hartman .start = 0, 156740e518eSGreg Kroah-Hartman .end = 0, 157740e518eSGreg Kroah-Hartman .flags = IORESOURCE_MEM 158740e518eSGreg Kroah-Hartman } 1591da177e4SLinus Torvalds }; 1601da177e4SLinus Torvalds 1611da177e4SLinus Torvalds #define video_ram mem_res[0] 1621da177e4SLinus Torvalds #define kernel_code mem_res[1] 1631da177e4SLinus Torvalds #define kernel_data mem_res[2] 1641da177e4SLinus Torvalds 1651da177e4SLinus Torvalds static struct resource io_res[] = { 166740e518eSGreg Kroah-Hartman { 167740e518eSGreg Kroah-Hartman .name = "reserved", 168740e518eSGreg Kroah-Hartman .start = 0x3bc, 169740e518eSGreg Kroah-Hartman .end = 0x3be, 170740e518eSGreg Kroah-Hartman .flags = IORESOURCE_IO | IORESOURCE_BUSY 171740e518eSGreg Kroah-Hartman }, 172740e518eSGreg Kroah-Hartman { 173740e518eSGreg Kroah-Hartman .name = "reserved", 174740e518eSGreg Kroah-Hartman .start = 0x378, 175740e518eSGreg Kroah-Hartman .end = 0x37f, 176740e518eSGreg Kroah-Hartman .flags = IORESOURCE_IO | IORESOURCE_BUSY 177740e518eSGreg Kroah-Hartman }, 178740e518eSGreg Kroah-Hartman { 179740e518eSGreg Kroah-Hartman .name = "reserved", 180740e518eSGreg Kroah-Hartman .start = 0x278, 181740e518eSGreg Kroah-Hartman .end = 0x27f, 182740e518eSGreg Kroah-Hartman .flags = IORESOURCE_IO | IORESOURCE_BUSY 183740e518eSGreg Kroah-Hartman } 1841da177e4SLinus Torvalds }; 1851da177e4SLinus Torvalds 1861da177e4SLinus Torvalds #define lp0 io_res[0] 1871da177e4SLinus Torvalds #define lp1 io_res[1] 1881da177e4SLinus Torvalds #define lp2 io_res[2] 1891da177e4SLinus Torvalds 1901da177e4SLinus Torvalds static const char *proc_arch[] = { 1911da177e4SLinus Torvalds "undefined/unknown", 1921da177e4SLinus Torvalds "3", 1931da177e4SLinus Torvalds "4", 1941da177e4SLinus Torvalds "4T", 1951da177e4SLinus Torvalds "5", 1961da177e4SLinus Torvalds "5T", 1971da177e4SLinus Torvalds "5TE", 1981da177e4SLinus Torvalds "5TEJ", 1991da177e4SLinus Torvalds "6TEJ", 2006b090a25SCatalin Marinas "7", 2011da177e4SLinus Torvalds "?(11)", 2021da177e4SLinus Torvalds "?(12)", 2031da177e4SLinus Torvalds "?(13)", 2041da177e4SLinus Torvalds "?(14)", 2051da177e4SLinus Torvalds "?(15)", 2061da177e4SLinus Torvalds "?(16)", 2071da177e4SLinus Torvalds "?(17)", 2081da177e4SLinus Torvalds }; 2091da177e4SLinus Torvalds 2101da177e4SLinus Torvalds int cpu_architecture(void) 2111da177e4SLinus Torvalds { 2121da177e4SLinus Torvalds int cpu_arch; 2131da177e4SLinus Torvalds 2140ba8b9b2SRussell King if ((read_cpuid_id() & 0x0008f000) == 0) { 2151da177e4SLinus Torvalds cpu_arch = CPU_ARCH_UNKNOWN; 2160ba8b9b2SRussell King } else if ((read_cpuid_id() & 0x0008f000) == 0x00007000) { 2170ba8b9b2SRussell King cpu_arch = (read_cpuid_id() & (1 << 23)) ? CPU_ARCH_ARMv4T : CPU_ARCH_ARMv3; 2180ba8b9b2SRussell King } else if ((read_cpuid_id() & 0x00080000) == 0x00000000) { 2190ba8b9b2SRussell King cpu_arch = (read_cpuid_id() >> 16) & 7; 2201da177e4SLinus Torvalds if (cpu_arch) 2211da177e4SLinus Torvalds cpu_arch += CPU_ARCH_ARMv3; 2220ba8b9b2SRussell King } else if ((read_cpuid_id() & 0x000f0000) == 0x000f0000) { 223180005c4SCatalin Marinas unsigned int mmfr0; 224180005c4SCatalin Marinas 225180005c4SCatalin Marinas /* Revised CPUID format. Read the Memory Model Feature 226180005c4SCatalin Marinas * Register 0 and check for VMSAv7 or PMSAv7 */ 227180005c4SCatalin Marinas asm("mrc p15, 0, %0, c0, c1, 4" 228180005c4SCatalin Marinas : "=r" (mmfr0)); 229315cfe78SCatalin Marinas if ((mmfr0 & 0x0000000f) >= 0x00000003 || 230315cfe78SCatalin Marinas (mmfr0 & 0x000000f0) >= 0x00000030) 231180005c4SCatalin Marinas cpu_arch = CPU_ARCH_ARMv7; 232180005c4SCatalin Marinas else if ((mmfr0 & 0x0000000f) == 0x00000002 || 233180005c4SCatalin Marinas (mmfr0 & 0x000000f0) == 0x00000020) 234180005c4SCatalin Marinas cpu_arch = CPU_ARCH_ARMv6; 235180005c4SCatalin Marinas else 236180005c4SCatalin Marinas cpu_arch = CPU_ARCH_UNKNOWN; 237180005c4SCatalin Marinas } else 238180005c4SCatalin Marinas cpu_arch = CPU_ARCH_UNKNOWN; 2391da177e4SLinus Torvalds 2401da177e4SLinus Torvalds return cpu_arch; 2411da177e4SLinus Torvalds } 2421da177e4SLinus Torvalds 2438925ec4cSWill Deacon static int cpu_has_aliasing_icache(unsigned int arch) 2448925ec4cSWill Deacon { 2458925ec4cSWill Deacon int aliasing_icache; 2468925ec4cSWill Deacon unsigned int id_reg, num_sets, line_size; 2478925ec4cSWill Deacon 2488925ec4cSWill Deacon /* arch specifies the register format */ 2498925ec4cSWill Deacon switch (arch) { 2508925ec4cSWill Deacon case CPU_ARCH_ARMv7: 2515fb31a96SLinus Walleij asm("mcr p15, 2, %0, c0, c0, 0 @ set CSSELR" 2525fb31a96SLinus Walleij : /* No output operands */ 2538925ec4cSWill Deacon : "r" (1)); 2545fb31a96SLinus Walleij isb(); 2555fb31a96SLinus Walleij asm("mrc p15, 1, %0, c0, c0, 0 @ read CCSIDR" 2565fb31a96SLinus Walleij : "=r" (id_reg)); 2578925ec4cSWill Deacon line_size = 4 << ((id_reg & 0x7) + 2); 2588925ec4cSWill Deacon num_sets = ((id_reg >> 13) & 0x7fff) + 1; 2598925ec4cSWill Deacon aliasing_icache = (line_size * num_sets) > PAGE_SIZE; 2608925ec4cSWill Deacon break; 2618925ec4cSWill Deacon case CPU_ARCH_ARMv6: 2628925ec4cSWill Deacon aliasing_icache = read_cpuid_cachetype() & (1 << 11); 2638925ec4cSWill Deacon break; 2648925ec4cSWill Deacon default: 2658925ec4cSWill Deacon /* I-cache aliases will be handled by D-cache aliasing code */ 2668925ec4cSWill Deacon aliasing_icache = 0; 2678925ec4cSWill Deacon } 2688925ec4cSWill Deacon 2698925ec4cSWill Deacon return aliasing_icache; 2708925ec4cSWill Deacon } 2718925ec4cSWill Deacon 272c0e95878SRussell King static void __init cacheid_init(void) 273c0e95878SRussell King { 274c0e95878SRussell King unsigned int cachetype = read_cpuid_cachetype(); 275c0e95878SRussell King unsigned int arch = cpu_architecture(); 276c0e95878SRussell King 277b57ee99fSCatalin Marinas if (arch >= CPU_ARCH_ARMv6) { 278b57ee99fSCatalin Marinas if ((cachetype & (7 << 29)) == 4 << 29) { 279b57ee99fSCatalin Marinas /* ARMv7 register format */ 280c0e95878SRussell King cacheid = CACHEID_VIPT_NONALIASING; 281c0e95878SRussell King if ((cachetype & (3 << 14)) == 1 << 14) 282c0e95878SRussell King cacheid |= CACHEID_ASID_TAGGED; 2838925ec4cSWill Deacon else if (cpu_has_aliasing_icache(CPU_ARCH_ARMv7)) 2848925ec4cSWill Deacon cacheid |= CACHEID_VIPT_I_ALIASING; 2858925ec4cSWill Deacon } else if (cachetype & (1 << 23)) { 286c0e95878SRussell King cacheid = CACHEID_VIPT_ALIASING; 2878925ec4cSWill Deacon } else { 288c0e95878SRussell King cacheid = CACHEID_VIPT_NONALIASING; 2898925ec4cSWill Deacon if (cpu_has_aliasing_icache(CPU_ARCH_ARMv6)) 2908925ec4cSWill Deacon cacheid |= CACHEID_VIPT_I_ALIASING; 2918925ec4cSWill Deacon } 292c0e95878SRussell King } else { 293c0e95878SRussell King cacheid = CACHEID_VIVT; 294c0e95878SRussell King } 2952b4ae1f1SRussell King 2962b4ae1f1SRussell King printk("CPU: %s data cache, %s instruction cache\n", 2972b4ae1f1SRussell King cache_is_vivt() ? "VIVT" : 2982b4ae1f1SRussell King cache_is_vipt_aliasing() ? "VIPT aliasing" : 2992b4ae1f1SRussell King cache_is_vipt_nonaliasing() ? "VIPT nonaliasing" : "unknown", 3002b4ae1f1SRussell King cache_is_vivt() ? "VIVT" : 3012b4ae1f1SRussell King icache_is_vivt_asid_tagged() ? "VIVT ASID tagged" : 3028925ec4cSWill Deacon icache_is_vipt_aliasing() ? "VIPT aliasing" : 3032b4ae1f1SRussell King cache_is_vipt_nonaliasing() ? "VIPT nonaliasing" : "unknown"); 304c0e95878SRussell King } 305c0e95878SRussell King 3061da177e4SLinus Torvalds /* 3071da177e4SLinus Torvalds * These functions re-use the assembly code in head.S, which 3081da177e4SLinus Torvalds * already provide the required functionality. 3091da177e4SLinus Torvalds */ 3100f44ba1dSRussell King extern struct proc_info_list *lookup_processor_type(unsigned int); 3116fc31d54SRussell King 3126fc31d54SRussell King static void __init early_print(const char *str, ...) 3136fc31d54SRussell King { 3146fc31d54SRussell King extern void printascii(const char *); 3156fc31d54SRussell King char buf[256]; 3166fc31d54SRussell King va_list ap; 3176fc31d54SRussell King 3186fc31d54SRussell King va_start(ap, str); 3196fc31d54SRussell King vsnprintf(buf, sizeof(buf), str, ap); 3206fc31d54SRussell King va_end(ap); 3216fc31d54SRussell King 3226fc31d54SRussell King #ifdef CONFIG_DEBUG_LL 3236fc31d54SRussell King printascii(buf); 3246fc31d54SRussell King #endif 3256fc31d54SRussell King printk("%s", buf); 3266fc31d54SRussell King } 3276fc31d54SRussell King 328f159f4edSTony Lindgren static void __init feat_v6_fixup(void) 329f159f4edSTony Lindgren { 330f159f4edSTony Lindgren int id = read_cpuid_id(); 331f159f4edSTony Lindgren 332f159f4edSTony Lindgren if ((id & 0xff0f0000) != 0x41070000) 333f159f4edSTony Lindgren return; 334f159f4edSTony Lindgren 335f159f4edSTony Lindgren /* 336f159f4edSTony Lindgren * HWCAP_TLS is available only on 1136 r1p0 and later, 337f159f4edSTony Lindgren * see also kuser_get_tls_init. 338f159f4edSTony Lindgren */ 339f159f4edSTony Lindgren if ((((id >> 4) & 0xfff) == 0xb36) && (((id >> 20) & 3) == 0)) 340f159f4edSTony Lindgren elf_hwcap &= ~HWCAP_TLS; 341f159f4edSTony Lindgren } 342f159f4edSTony Lindgren 3431da177e4SLinus Torvalds static void __init setup_processor(void) 3441da177e4SLinus Torvalds { 3451da177e4SLinus Torvalds struct proc_info_list *list; 3461da177e4SLinus Torvalds 3471da177e4SLinus Torvalds /* 3481da177e4SLinus Torvalds * locate processor in the list of supported processor 3491da177e4SLinus Torvalds * types. The linker builds this table for us from the 3501da177e4SLinus Torvalds * entries in arch/arm/mm/proc-*.S 3511da177e4SLinus Torvalds */ 3520ba8b9b2SRussell King list = lookup_processor_type(read_cpuid_id()); 3531da177e4SLinus Torvalds if (!list) { 3541da177e4SLinus Torvalds printk("CPU configuration botched (ID %08x), unable " 3550ba8b9b2SRussell King "to continue.\n", read_cpuid_id()); 3561da177e4SLinus Torvalds while (1); 3571da177e4SLinus Torvalds } 3581da177e4SLinus Torvalds 3591da177e4SLinus Torvalds cpu_name = list->cpu_name; 3601da177e4SLinus Torvalds 3611da177e4SLinus Torvalds #ifdef MULTI_CPU 3621da177e4SLinus Torvalds processor = *list->proc; 3631da177e4SLinus Torvalds #endif 3641da177e4SLinus Torvalds #ifdef MULTI_TLB 3651da177e4SLinus Torvalds cpu_tlb = *list->tlb; 3661da177e4SLinus Torvalds #endif 3671da177e4SLinus Torvalds #ifdef MULTI_USER 3681da177e4SLinus Torvalds cpu_user = *list->user; 3691da177e4SLinus Torvalds #endif 3701da177e4SLinus Torvalds #ifdef MULTI_CACHE 3711da177e4SLinus Torvalds cpu_cache = *list->cache; 3721da177e4SLinus Torvalds #endif 3731da177e4SLinus Torvalds 3744e19025bSRussell King printk("CPU: %s [%08x] revision %d (ARMv%s), cr=%08lx\n", 3750ba8b9b2SRussell King cpu_name, read_cpuid_id(), read_cpuid_id() & 15, 376264edb35SRussell King proc_arch[cpu_architecture()], cr_alignment); 3771da177e4SLinus Torvalds 37896b644bdSSerge E. Hallyn sprintf(init_utsname()->machine, "%s%c", list->arch_name, ENDIANNESS); 3791da177e4SLinus Torvalds sprintf(elf_platform, "%s%c", list->elf_name, ENDIANNESS); 3801da177e4SLinus Torvalds elf_hwcap = list->elf_hwcap; 381adeff422SCatalin Marinas #ifndef CONFIG_ARM_THUMB 382adeff422SCatalin Marinas elf_hwcap &= ~HWCAP_THUMB; 383adeff422SCatalin Marinas #endif 3841da177e4SLinus Torvalds 385f159f4edSTony Lindgren feat_v6_fixup(); 386f159f4edSTony Lindgren 387c0e95878SRussell King cacheid_init(); 3881da177e4SLinus Torvalds cpu_proc_init(); 3891da177e4SLinus Torvalds } 3901da177e4SLinus Torvalds 391ccea7a19SRussell King /* 392ccea7a19SRussell King * cpu_init - initialise one CPU. 393ccea7a19SRussell King * 39490f1e084SRussell King * cpu_init sets up the per-CPU stacks. 395ccea7a19SRussell King */ 39636c5ed23SRussell King void cpu_init(void) 397ccea7a19SRussell King { 398ccea7a19SRussell King unsigned int cpu = smp_processor_id(); 399ccea7a19SRussell King struct stack *stk = &stacks[cpu]; 400ccea7a19SRussell King 401ccea7a19SRussell King if (cpu >= NR_CPUS) { 402ccea7a19SRussell King printk(KERN_CRIT "CPU%u: bad primary CPU number\n", cpu); 403ccea7a19SRussell King BUG(); 404ccea7a19SRussell King } 405ccea7a19SRussell King 406ccea7a19SRussell King /* 407b86040a5SCatalin Marinas * Define the placement constraint for the inline asm directive below. 408b86040a5SCatalin Marinas * In Thumb-2, msr with an immediate value is not allowed. 409b86040a5SCatalin Marinas */ 410b86040a5SCatalin Marinas #ifdef CONFIG_THUMB2_KERNEL 411b86040a5SCatalin Marinas #define PLC "r" 412b86040a5SCatalin Marinas #else 413b86040a5SCatalin Marinas #define PLC "I" 414b86040a5SCatalin Marinas #endif 415b86040a5SCatalin Marinas 416b86040a5SCatalin Marinas /* 417ccea7a19SRussell King * setup stacks for re-entrant exception handlers 418ccea7a19SRussell King */ 419ccea7a19SRussell King __asm__ ( 420ccea7a19SRussell King "msr cpsr_c, %1\n\t" 421b86040a5SCatalin Marinas "add r14, %0, %2\n\t" 422b86040a5SCatalin Marinas "mov sp, r14\n\t" 423ccea7a19SRussell King "msr cpsr_c, %3\n\t" 424b86040a5SCatalin Marinas "add r14, %0, %4\n\t" 425b86040a5SCatalin Marinas "mov sp, r14\n\t" 426ccea7a19SRussell King "msr cpsr_c, %5\n\t" 427b86040a5SCatalin Marinas "add r14, %0, %6\n\t" 428b86040a5SCatalin Marinas "mov sp, r14\n\t" 429ccea7a19SRussell King "msr cpsr_c, %7" 430ccea7a19SRussell King : 431ccea7a19SRussell King : "r" (stk), 432b86040a5SCatalin Marinas PLC (PSR_F_BIT | PSR_I_BIT | IRQ_MODE), 433ccea7a19SRussell King "I" (offsetof(struct stack, irq[0])), 434b86040a5SCatalin Marinas PLC (PSR_F_BIT | PSR_I_BIT | ABT_MODE), 435ccea7a19SRussell King "I" (offsetof(struct stack, abt[0])), 436b86040a5SCatalin Marinas PLC (PSR_F_BIT | PSR_I_BIT | UND_MODE), 437ccea7a19SRussell King "I" (offsetof(struct stack, und[0])), 438b86040a5SCatalin Marinas PLC (PSR_F_BIT | PSR_I_BIT | SVC_MODE) 439aaaa3f9eSCatalin Marinas : "r14"); 440ccea7a19SRussell King } 441ccea7a19SRussell King 4426291319dSGrant Likely static void __init dump_machine_table(void) 4431da177e4SLinus Torvalds { 444dce72dd0SNicolas Pitre struct machine_desc *p; 4451da177e4SLinus Torvalds 4466291319dSGrant Likely early_print("Available machine support:\n\nID (hex)\tNAME\n"); 4476291319dSGrant Likely for_each_machine_desc(p) 448dce72dd0SNicolas Pitre early_print("%08x\t%s\n", p->nr, p->name); 449dce72dd0SNicolas Pitre 450dce72dd0SNicolas Pitre early_print("\nPlease check your kernel config and/or bootloader.\n"); 451dce72dd0SNicolas Pitre 452dce72dd0SNicolas Pitre while (true) 453dce72dd0SNicolas Pitre /* can't use cpu_relax() here as it may require MMU setup */; 4541da177e4SLinus Torvalds } 4551da177e4SLinus Torvalds 4569eb8f674SGrant Likely int __init arm_add_memory(phys_addr_t start, unsigned long size) 4573a669411SRussell King { 4584b5f32ceSNicolas Pitre struct membank *bank = &meminfo.bank[meminfo.nr_banks]; 4594b5f32ceSNicolas Pitre 4604b5f32ceSNicolas Pitre if (meminfo.nr_banks >= NR_BANKS) { 4614b5f32ceSNicolas Pitre printk(KERN_CRIT "NR_BANKS too low, " 46229a38193SWill Deacon "ignoring memory at 0x%08llx\n", (long long)start); 4634b5f32ceSNicolas Pitre return -EINVAL; 4644b5f32ceSNicolas Pitre } 46505f96ef1SRussell King 4663a669411SRussell King /* 4673a669411SRussell King * Ensure that start/size are aligned to a page boundary. 4683a669411SRussell King * Size is appropriately rounded down, start is rounded up. 4693a669411SRussell King */ 4703a669411SRussell King size -= start & ~PAGE_MASK; 47105f96ef1SRussell King bank->start = PAGE_ALIGN(start); 47205f96ef1SRussell King bank->size = size & PAGE_MASK; 4734b5f32ceSNicolas Pitre 4744b5f32ceSNicolas Pitre /* 4754b5f32ceSNicolas Pitre * Check whether this memory region has non-zero size or 4764b5f32ceSNicolas Pitre * invalid node number. 4774b5f32ceSNicolas Pitre */ 478be370302SRussell King if (bank->size == 0) 4794b5f32ceSNicolas Pitre return -EINVAL; 4804b5f32ceSNicolas Pitre 4814b5f32ceSNicolas Pitre meminfo.nr_banks++; 4824b5f32ceSNicolas Pitre return 0; 4833a669411SRussell King } 4843a669411SRussell King 4851da177e4SLinus Torvalds /* 4861da177e4SLinus Torvalds * Pick out the memory size. We look for mem=size@start, 4871da177e4SLinus Torvalds * where start and size are "size[KkMm]" 4881da177e4SLinus Torvalds */ 4892b0d8c25SJeremy Kerr static int __init early_mem(char *p) 4901da177e4SLinus Torvalds { 4911da177e4SLinus Torvalds static int usermem __initdata = 0; 492f60892d3SWill Deacon unsigned long size; 493f60892d3SWill Deacon phys_addr_t start; 4942b0d8c25SJeremy Kerr char *endp; 4951da177e4SLinus Torvalds 4961da177e4SLinus Torvalds /* 4971da177e4SLinus Torvalds * If the user specifies memory size, we 4981da177e4SLinus Torvalds * blow away any automatically generated 4991da177e4SLinus Torvalds * size. 5001da177e4SLinus Torvalds */ 5011da177e4SLinus Torvalds if (usermem == 0) { 5021da177e4SLinus Torvalds usermem = 1; 5031da177e4SLinus Torvalds meminfo.nr_banks = 0; 5041da177e4SLinus Torvalds } 5051da177e4SLinus Torvalds 5061da177e4SLinus Torvalds start = PHYS_OFFSET; 5072b0d8c25SJeremy Kerr size = memparse(p, &endp); 5082b0d8c25SJeremy Kerr if (*endp == '@') 5092b0d8c25SJeremy Kerr start = memparse(endp + 1, NULL); 5101da177e4SLinus Torvalds 5111c97b73eSAndrew Morton arm_add_memory(start, size); 5121da177e4SLinus Torvalds 5132b0d8c25SJeremy Kerr return 0; 5141da177e4SLinus Torvalds } 5152b0d8c25SJeremy Kerr early_param("mem", early_mem); 5161da177e4SLinus Torvalds 5171da177e4SLinus Torvalds static void __init 5181da177e4SLinus Torvalds setup_ramdisk(int doload, int prompt, int image_start, unsigned int rd_sz) 5191da177e4SLinus Torvalds { 5201da177e4SLinus Torvalds #ifdef CONFIG_BLK_DEV_RAM 5211da177e4SLinus Torvalds extern int rd_size, rd_image_start, rd_prompt, rd_doload; 5221da177e4SLinus Torvalds 5231da177e4SLinus Torvalds rd_image_start = image_start; 5241da177e4SLinus Torvalds rd_prompt = prompt; 5251da177e4SLinus Torvalds rd_doload = doload; 5261da177e4SLinus Torvalds 5271da177e4SLinus Torvalds if (rd_sz) 5281da177e4SLinus Torvalds rd_size = rd_sz; 5291da177e4SLinus Torvalds #endif 5301da177e4SLinus Torvalds } 5311da177e4SLinus Torvalds 53211b9369cSDima Zavin static void __init request_standard_resources(struct machine_desc *mdesc) 5331da177e4SLinus Torvalds { 53411b9369cSDima Zavin struct memblock_region *region; 5351da177e4SLinus Torvalds struct resource *res; 5361da177e4SLinus Torvalds 53737efe642SRussell King kernel_code.start = virt_to_phys(_text); 53837efe642SRussell King kernel_code.end = virt_to_phys(_etext - 1); 539842eab40SRussell King kernel_data.start = virt_to_phys(_sdata); 54037efe642SRussell King kernel_data.end = virt_to_phys(_end - 1); 5411da177e4SLinus Torvalds 54211b9369cSDima Zavin for_each_memblock(memory, region) { 5431da177e4SLinus Torvalds res = alloc_bootmem_low(sizeof(*res)); 5441da177e4SLinus Torvalds res->name = "System RAM"; 54511b9369cSDima Zavin res->start = __pfn_to_phys(memblock_region_memory_base_pfn(region)); 54611b9369cSDima Zavin res->end = __pfn_to_phys(memblock_region_memory_end_pfn(region)) - 1; 5471da177e4SLinus Torvalds res->flags = IORESOURCE_MEM | IORESOURCE_BUSY; 5481da177e4SLinus Torvalds 5491da177e4SLinus Torvalds request_resource(&iomem_resource, res); 5501da177e4SLinus Torvalds 5511da177e4SLinus Torvalds if (kernel_code.start >= res->start && 5521da177e4SLinus Torvalds kernel_code.end <= res->end) 5531da177e4SLinus Torvalds request_resource(res, &kernel_code); 5541da177e4SLinus Torvalds if (kernel_data.start >= res->start && 5551da177e4SLinus Torvalds kernel_data.end <= res->end) 5561da177e4SLinus Torvalds request_resource(res, &kernel_data); 5571da177e4SLinus Torvalds } 5581da177e4SLinus Torvalds 5591da177e4SLinus Torvalds if (mdesc->video_start) { 5601da177e4SLinus Torvalds video_ram.start = mdesc->video_start; 5611da177e4SLinus Torvalds video_ram.end = mdesc->video_end; 5621da177e4SLinus Torvalds request_resource(&iomem_resource, &video_ram); 5631da177e4SLinus Torvalds } 5641da177e4SLinus Torvalds 5651da177e4SLinus Torvalds /* 5661da177e4SLinus Torvalds * Some machines don't have the possibility of ever 5671da177e4SLinus Torvalds * possessing lp0, lp1 or lp2 5681da177e4SLinus Torvalds */ 5691da177e4SLinus Torvalds if (mdesc->reserve_lp0) 5701da177e4SLinus Torvalds request_resource(&ioport_resource, &lp0); 5711da177e4SLinus Torvalds if (mdesc->reserve_lp1) 5721da177e4SLinus Torvalds request_resource(&ioport_resource, &lp1); 5731da177e4SLinus Torvalds if (mdesc->reserve_lp2) 5741da177e4SLinus Torvalds request_resource(&ioport_resource, &lp2); 5751da177e4SLinus Torvalds } 5761da177e4SLinus Torvalds 5771da177e4SLinus Torvalds /* 5781da177e4SLinus Torvalds * Tag parsing. 5791da177e4SLinus Torvalds * 5801da177e4SLinus Torvalds * This is the new way of passing data to the kernel at boot time. Rather 5811da177e4SLinus Torvalds * than passing a fixed inflexible structure to the kernel, we pass a list 5821da177e4SLinus Torvalds * of variable-sized tags to the kernel. The first tag must be a ATAG_CORE 5831da177e4SLinus Torvalds * tag for the list to be recognised (to distinguish the tagged list from 5841da177e4SLinus Torvalds * a param_struct). The list is terminated with a zero-length tag (this tag 5851da177e4SLinus Torvalds * is not parsed in any way). 5861da177e4SLinus Torvalds */ 5871da177e4SLinus Torvalds static int __init parse_tag_core(const struct tag *tag) 5881da177e4SLinus Torvalds { 5891da177e4SLinus Torvalds if (tag->hdr.size > 2) { 5901da177e4SLinus Torvalds if ((tag->u.core.flags & 1) == 0) 5911da177e4SLinus Torvalds root_mountflags &= ~MS_RDONLY; 5921da177e4SLinus Torvalds ROOT_DEV = old_decode_dev(tag->u.core.rootdev); 5931da177e4SLinus Torvalds } 5941da177e4SLinus Torvalds return 0; 5951da177e4SLinus Torvalds } 5961da177e4SLinus Torvalds 5971da177e4SLinus Torvalds __tagtable(ATAG_CORE, parse_tag_core); 5981da177e4SLinus Torvalds 5991da177e4SLinus Torvalds static int __init parse_tag_mem32(const struct tag *tag) 6001da177e4SLinus Torvalds { 6014b5f32ceSNicolas Pitre return arm_add_memory(tag->u.mem.start, tag->u.mem.size); 6021da177e4SLinus Torvalds } 6031da177e4SLinus Torvalds 6041da177e4SLinus Torvalds __tagtable(ATAG_MEM, parse_tag_mem32); 6051da177e4SLinus Torvalds 6061da177e4SLinus Torvalds #if defined(CONFIG_VGA_CONSOLE) || defined(CONFIG_DUMMY_CONSOLE) 6071da177e4SLinus Torvalds struct screen_info screen_info = { 6081da177e4SLinus Torvalds .orig_video_lines = 30, 6091da177e4SLinus Torvalds .orig_video_cols = 80, 6101da177e4SLinus Torvalds .orig_video_mode = 0, 6111da177e4SLinus Torvalds .orig_video_ega_bx = 0, 6121da177e4SLinus Torvalds .orig_video_isVGA = 1, 6131da177e4SLinus Torvalds .orig_video_points = 8 6141da177e4SLinus Torvalds }; 6151da177e4SLinus Torvalds 6161da177e4SLinus Torvalds static int __init parse_tag_videotext(const struct tag *tag) 6171da177e4SLinus Torvalds { 6181da177e4SLinus Torvalds screen_info.orig_x = tag->u.videotext.x; 6191da177e4SLinus Torvalds screen_info.orig_y = tag->u.videotext.y; 6201da177e4SLinus Torvalds screen_info.orig_video_page = tag->u.videotext.video_page; 6211da177e4SLinus Torvalds screen_info.orig_video_mode = tag->u.videotext.video_mode; 6221da177e4SLinus Torvalds screen_info.orig_video_cols = tag->u.videotext.video_cols; 6231da177e4SLinus Torvalds screen_info.orig_video_ega_bx = tag->u.videotext.video_ega_bx; 6241da177e4SLinus Torvalds screen_info.orig_video_lines = tag->u.videotext.video_lines; 6251da177e4SLinus Torvalds screen_info.orig_video_isVGA = tag->u.videotext.video_isvga; 6261da177e4SLinus Torvalds screen_info.orig_video_points = tag->u.videotext.video_points; 6271da177e4SLinus Torvalds return 0; 6281da177e4SLinus Torvalds } 6291da177e4SLinus Torvalds 6301da177e4SLinus Torvalds __tagtable(ATAG_VIDEOTEXT, parse_tag_videotext); 6311da177e4SLinus Torvalds #endif 6321da177e4SLinus Torvalds 6331da177e4SLinus Torvalds static int __init parse_tag_ramdisk(const struct tag *tag) 6341da177e4SLinus Torvalds { 6351da177e4SLinus Torvalds setup_ramdisk((tag->u.ramdisk.flags & 1) == 0, 6361da177e4SLinus Torvalds (tag->u.ramdisk.flags & 2) == 0, 6371da177e4SLinus Torvalds tag->u.ramdisk.start, tag->u.ramdisk.size); 6381da177e4SLinus Torvalds return 0; 6391da177e4SLinus Torvalds } 6401da177e4SLinus Torvalds 6411da177e4SLinus Torvalds __tagtable(ATAG_RAMDISK, parse_tag_ramdisk); 6421da177e4SLinus Torvalds 6431da177e4SLinus Torvalds static int __init parse_tag_serialnr(const struct tag *tag) 6441da177e4SLinus Torvalds { 6451da177e4SLinus Torvalds system_serial_low = tag->u.serialnr.low; 6461da177e4SLinus Torvalds system_serial_high = tag->u.serialnr.high; 6471da177e4SLinus Torvalds return 0; 6481da177e4SLinus Torvalds } 6491da177e4SLinus Torvalds 6501da177e4SLinus Torvalds __tagtable(ATAG_SERIAL, parse_tag_serialnr); 6511da177e4SLinus Torvalds 6521da177e4SLinus Torvalds static int __init parse_tag_revision(const struct tag *tag) 6531da177e4SLinus Torvalds { 6541da177e4SLinus Torvalds system_rev = tag->u.revision.rev; 6551da177e4SLinus Torvalds return 0; 6561da177e4SLinus Torvalds } 6571da177e4SLinus Torvalds 6581da177e4SLinus Torvalds __tagtable(ATAG_REVISION, parse_tag_revision); 6591da177e4SLinus Torvalds 6601da177e4SLinus Torvalds static int __init parse_tag_cmdline(const struct tag *tag) 6611da177e4SLinus Torvalds { 66222eeb8f6SAlexander Holler #ifndef CONFIG_CMDLINE_FORCE 6631da177e4SLinus Torvalds strlcpy(default_command_line, tag->u.cmdline.cmdline, COMMAND_LINE_SIZE); 66422eeb8f6SAlexander Holler #else 66522eeb8f6SAlexander Holler pr_warning("Ignoring tag cmdline (using the default kernel command line)\n"); 66622eeb8f6SAlexander Holler #endif /* CONFIG_CMDLINE_FORCE */ 6671da177e4SLinus Torvalds return 0; 6681da177e4SLinus Torvalds } 6691da177e4SLinus Torvalds 6701da177e4SLinus Torvalds __tagtable(ATAG_CMDLINE, parse_tag_cmdline); 6711da177e4SLinus Torvalds 6721da177e4SLinus Torvalds /* 6731da177e4SLinus Torvalds * Scan the tag table for this tag, and call its parse function. 6741da177e4SLinus Torvalds * The tag table is built by the linker from all the __tagtable 6751da177e4SLinus Torvalds * declarations. 6761da177e4SLinus Torvalds */ 6771da177e4SLinus Torvalds static int __init parse_tag(const struct tag *tag) 6781da177e4SLinus Torvalds { 6791da177e4SLinus Torvalds extern struct tagtable __tagtable_begin, __tagtable_end; 6801da177e4SLinus Torvalds struct tagtable *t; 6811da177e4SLinus Torvalds 6821da177e4SLinus Torvalds for (t = &__tagtable_begin; t < &__tagtable_end; t++) 6831da177e4SLinus Torvalds if (tag->hdr.tag == t->tag) { 6841da177e4SLinus Torvalds t->parse(tag); 6851da177e4SLinus Torvalds break; 6861da177e4SLinus Torvalds } 6871da177e4SLinus Torvalds 6881da177e4SLinus Torvalds return t < &__tagtable_end; 6891da177e4SLinus Torvalds } 6901da177e4SLinus Torvalds 6911da177e4SLinus Torvalds /* 6921da177e4SLinus Torvalds * Parse all tags in the list, checking both the global and architecture 6931da177e4SLinus Torvalds * specific tag tables. 6941da177e4SLinus Torvalds */ 6951da177e4SLinus Torvalds static void __init parse_tags(const struct tag *t) 6961da177e4SLinus Torvalds { 6971da177e4SLinus Torvalds for (; t->hdr.size; t = tag_next(t)) 6981da177e4SLinus Torvalds if (!parse_tag(t)) 6991da177e4SLinus Torvalds printk(KERN_WARNING 7001da177e4SLinus Torvalds "Ignoring unrecognised tag 0x%08x\n", 7011da177e4SLinus Torvalds t->hdr.tag); 7021da177e4SLinus Torvalds } 7031da177e4SLinus Torvalds 7041da177e4SLinus Torvalds /* 7051da177e4SLinus Torvalds * This holds our defaults. 7061da177e4SLinus Torvalds */ 7071da177e4SLinus Torvalds static struct init_tags { 7081da177e4SLinus Torvalds struct tag_header hdr1; 7091da177e4SLinus Torvalds struct tag_core core; 7101da177e4SLinus Torvalds struct tag_header hdr2; 7111da177e4SLinus Torvalds struct tag_mem32 mem; 7121da177e4SLinus Torvalds struct tag_header hdr3; 7131da177e4SLinus Torvalds } init_tags __initdata = { 7141da177e4SLinus Torvalds { tag_size(tag_core), ATAG_CORE }, 7151da177e4SLinus Torvalds { 1, PAGE_SIZE, 0xff }, 7161da177e4SLinus Torvalds { tag_size(tag_mem32), ATAG_MEM }, 717b75c178aSRussell King { MEM_SIZE }, 7181da177e4SLinus Torvalds { 0, ATAG_NONE } 7191da177e4SLinus Torvalds }; 7201da177e4SLinus Torvalds 7211da177e4SLinus Torvalds static int __init customize_machine(void) 7221da177e4SLinus Torvalds { 7231da177e4SLinus Torvalds /* customizes platform devices, or adds new ones */ 7248ff1443cSRussell King if (machine_desc->init_machine) 7258ff1443cSRussell King machine_desc->init_machine(); 7261da177e4SLinus Torvalds return 0; 7271da177e4SLinus Torvalds } 7281da177e4SLinus Torvalds arch_initcall(customize_machine); 7291da177e4SLinus Torvalds 7303c57fb43SMika Westerberg #ifdef CONFIG_KEXEC 7313c57fb43SMika Westerberg static inline unsigned long long get_total_mem(void) 7323c57fb43SMika Westerberg { 7333c57fb43SMika Westerberg unsigned long total; 7343c57fb43SMika Westerberg 7353c57fb43SMika Westerberg total = max_low_pfn - min_low_pfn; 7363c57fb43SMika Westerberg return total << PAGE_SHIFT; 7373c57fb43SMika Westerberg } 7383c57fb43SMika Westerberg 7393c57fb43SMika Westerberg /** 7403c57fb43SMika Westerberg * reserve_crashkernel() - reserves memory are for crash kernel 7413c57fb43SMika Westerberg * 7423c57fb43SMika Westerberg * This function reserves memory area given in "crashkernel=" kernel command 7433c57fb43SMika Westerberg * line parameter. The memory reserved is used by a dump capture kernel when 7443c57fb43SMika Westerberg * primary kernel is crashing. 7453c57fb43SMika Westerberg */ 7463c57fb43SMika Westerberg static void __init reserve_crashkernel(void) 7473c57fb43SMika Westerberg { 7483c57fb43SMika Westerberg unsigned long long crash_size, crash_base; 7493c57fb43SMika Westerberg unsigned long long total_mem; 7503c57fb43SMika Westerberg int ret; 7513c57fb43SMika Westerberg 7523c57fb43SMika Westerberg total_mem = get_total_mem(); 7533c57fb43SMika Westerberg ret = parse_crashkernel(boot_command_line, total_mem, 7543c57fb43SMika Westerberg &crash_size, &crash_base); 7553c57fb43SMika Westerberg if (ret) 7563c57fb43SMika Westerberg return; 7573c57fb43SMika Westerberg 7583c57fb43SMika Westerberg ret = reserve_bootmem(crash_base, crash_size, BOOTMEM_EXCLUSIVE); 7593c57fb43SMika Westerberg if (ret < 0) { 7603c57fb43SMika Westerberg printk(KERN_WARNING "crashkernel reservation failed - " 7613c57fb43SMika Westerberg "memory is in use (0x%lx)\n", (unsigned long)crash_base); 7623c57fb43SMika Westerberg return; 7633c57fb43SMika Westerberg } 7643c57fb43SMika Westerberg 7653c57fb43SMika Westerberg printk(KERN_INFO "Reserving %ldMB of memory at %ldMB " 7663c57fb43SMika Westerberg "for crashkernel (System RAM: %ldMB)\n", 7673c57fb43SMika Westerberg (unsigned long)(crash_size >> 20), 7683c57fb43SMika Westerberg (unsigned long)(crash_base >> 20), 7693c57fb43SMika Westerberg (unsigned long)(total_mem >> 20)); 7703c57fb43SMika Westerberg 7713c57fb43SMika Westerberg crashk_res.start = crash_base; 7723c57fb43SMika Westerberg crashk_res.end = crash_base + crash_size - 1; 7733c57fb43SMika Westerberg insert_resource(&iomem_resource, &crashk_res); 7743c57fb43SMika Westerberg } 7753c57fb43SMika Westerberg #else 7763c57fb43SMika Westerberg static inline void reserve_crashkernel(void) {} 7773c57fb43SMika Westerberg #endif /* CONFIG_KEXEC */ 7783c57fb43SMika Westerberg 77973a65b3fSUwe Kleine-König static void __init squash_mem_tags(struct tag *tag) 78073a65b3fSUwe Kleine-König { 78173a65b3fSUwe Kleine-König for (; tag->hdr.size; tag = tag_next(tag)) 78273a65b3fSUwe Kleine-König if (tag->hdr.tag == ATAG_MEM) 78373a65b3fSUwe Kleine-König tag->hdr.tag = ATAG_NONE; 78473a65b3fSUwe Kleine-König } 78573a65b3fSUwe Kleine-König 7866291319dSGrant Likely static struct machine_desc * __init setup_machine_tags(unsigned int nr) 7871da177e4SLinus Torvalds { 7881da177e4SLinus Torvalds struct tag *tags = (struct tag *)&init_tags; 7896291319dSGrant Likely struct machine_desc *mdesc = NULL, *p; 7901da177e4SLinus Torvalds char *from = default_command_line; 7911da177e4SLinus Torvalds 792b75c178aSRussell King init_tags.mem.start = PHYS_OFFSET; 793b75c178aSRussell King 7946291319dSGrant Likely /* 7956291319dSGrant Likely * locate machine in the list of supported machines. 7966291319dSGrant Likely */ 7976291319dSGrant Likely for_each_machine_desc(p) 7986291319dSGrant Likely if (nr == p->nr) { 7996291319dSGrant Likely printk("Machine: %s\n", p->name); 8006291319dSGrant Likely mdesc = p; 8016291319dSGrant Likely break; 8026291319dSGrant Likely } 803bff595c1SCatalin Marinas 8046291319dSGrant Likely if (!mdesc) { 8056291319dSGrant Likely early_print("\nError: unrecognized/unsupported machine ID" 8066291319dSGrant Likely " (r1 = 0x%08x).\n\n", nr); 8076291319dSGrant Likely dump_machine_table(); /* does not return */ 8086291319dSGrant Likely } 8091da177e4SLinus Torvalds 8109d20fdd5SBill Gatliff if (__atags_pointer) 8119d20fdd5SBill Gatliff tags = phys_to_virt(__atags_pointer); 8123572bea8SNicolas Pitre else if (mdesc->boot_params) { 8133572bea8SNicolas Pitre #ifdef CONFIG_MMU 8143572bea8SNicolas Pitre /* 8153572bea8SNicolas Pitre * We still are executing with a minimal MMU mapping created 8163572bea8SNicolas Pitre * with the presumption that the machine default for this 8173572bea8SNicolas Pitre * is located in the first MB of RAM. Anything else will 8183572bea8SNicolas Pitre * fault and silently hang the kernel at this point. 8193572bea8SNicolas Pitre */ 8203572bea8SNicolas Pitre if (mdesc->boot_params < PHYS_OFFSET || 8213572bea8SNicolas Pitre mdesc->boot_params >= PHYS_OFFSET + SZ_1M) { 8223572bea8SNicolas Pitre printk(KERN_WARNING 8233572bea8SNicolas Pitre "Default boot params at physical 0x%08lx out of reach\n", 8243572bea8SNicolas Pitre mdesc->boot_params); 8253572bea8SNicolas Pitre } else 8263572bea8SNicolas Pitre #endif 8273572bea8SNicolas Pitre { 828f9bd6ea4SRussell King tags = phys_to_virt(mdesc->boot_params); 8293572bea8SNicolas Pitre } 8303572bea8SNicolas Pitre } 8311da177e4SLinus Torvalds 83273a65b3fSUwe Kleine-König #if defined(CONFIG_DEPRECATED_PARAM_STRUCT) 8331da177e4SLinus Torvalds /* 8341da177e4SLinus Torvalds * If we have the old style parameters, convert them to 8351da177e4SLinus Torvalds * a tag list. 8361da177e4SLinus Torvalds */ 8371da177e4SLinus Torvalds if (tags->hdr.tag != ATAG_CORE) 8381da177e4SLinus Torvalds convert_to_tag_list(tags); 83973a65b3fSUwe Kleine-König #endif 8401da177e4SLinus Torvalds if (tags->hdr.tag != ATAG_CORE) 8411da177e4SLinus Torvalds tags = (struct tag *)&init_tags; 8421da177e4SLinus Torvalds 8431da177e4SLinus Torvalds if (mdesc->fixup) 8441da177e4SLinus Torvalds mdesc->fixup(mdesc, tags, &from, &meminfo); 8451da177e4SLinus Torvalds 8461da177e4SLinus Torvalds if (tags->hdr.tag == ATAG_CORE) { 8471da177e4SLinus Torvalds if (meminfo.nr_banks != 0) 8481da177e4SLinus Torvalds squash_mem_tags(tags); 8494cd9d6f7SRichard Purdie save_atags(tags); 8501da177e4SLinus Torvalds parse_tags(tags); 8511da177e4SLinus Torvalds } 8521da177e4SLinus Torvalds 8536291319dSGrant Likely /* parse_early_param needs a boot_command_line */ 8546291319dSGrant Likely strlcpy(boot_command_line, from, COMMAND_LINE_SIZE); 8556291319dSGrant Likely 8566291319dSGrant Likely return mdesc; 8576291319dSGrant Likely } 8586291319dSGrant Likely 8596291319dSGrant Likely 8606291319dSGrant Likely void __init setup_arch(char **cmdline_p) 8616291319dSGrant Likely { 8626291319dSGrant Likely struct machine_desc *mdesc; 8636291319dSGrant Likely 8646291319dSGrant Likely unwind_init(); 8656291319dSGrant Likely 8666291319dSGrant Likely setup_processor(); 8676291319dSGrant Likely mdesc = setup_machine_tags(machine_arch_type); 8686291319dSGrant Likely machine_desc = mdesc; 8696291319dSGrant Likely machine_name = mdesc->name; 8706291319dSGrant Likely 8716291319dSGrant Likely if (mdesc->soft_reboot) 8726291319dSGrant Likely reboot_setup("s"); 8736291319dSGrant Likely 87437efe642SRussell King init_mm.start_code = (unsigned long) _text; 87537efe642SRussell King init_mm.end_code = (unsigned long) _etext; 87637efe642SRussell King init_mm.end_data = (unsigned long) _edata; 87737efe642SRussell King init_mm.brk = (unsigned long) _end; 8781da177e4SLinus Torvalds 87948ab7e09SJeremy Kerr /* populate cmd_line too for later use, preserving boot_command_line */ 88048ab7e09SJeremy Kerr strlcpy(cmd_line, boot_command_line, COMMAND_LINE_SIZE); 88148ab7e09SJeremy Kerr *cmdline_p = cmd_line; 8822b0d8c25SJeremy Kerr 8832b0d8c25SJeremy Kerr parse_early_param(); 8842b0d8c25SJeremy Kerr 8858d717a52SRussell King arm_memblock_init(&meminfo, mdesc); 8862778f620SRussell King 8874b5f32ceSNicolas Pitre paging_init(mdesc); 88811b9369cSDima Zavin request_standard_resources(mdesc); 8891da177e4SLinus Torvalds 8907bbb7940SRussell King #ifdef CONFIG_SMP 891f00ec48fSRussell King if (is_smp()) 8927bbb7940SRussell King smp_init_cpus(); 8937bbb7940SRussell King #endif 8943c57fb43SMika Westerberg reserve_crashkernel(); 8957bbb7940SRussell King 896ccea7a19SRussell King cpu_init(); 897bc581770SLinus Walleij tcm_init(); 898ccea7a19SRussell King 89952108641Seric miao #ifdef CONFIG_MULTI_IRQ_HANDLER 90052108641Seric miao handle_arch_irq = mdesc->handle_irq; 90152108641Seric miao #endif 9021da177e4SLinus Torvalds 9031da177e4SLinus Torvalds #ifdef CONFIG_VT 9041da177e4SLinus Torvalds #if defined(CONFIG_VGA_CONSOLE) 9051da177e4SLinus Torvalds conswitchp = &vga_con; 9061da177e4SLinus Torvalds #elif defined(CONFIG_DUMMY_CONSOLE) 9071da177e4SLinus Torvalds conswitchp = &dummy_con; 9081da177e4SLinus Torvalds #endif 9091da177e4SLinus Torvalds #endif 9105cbad0ebSJason Wessel early_trap_init(); 911dec12e62SRussell King 912dec12e62SRussell King if (mdesc->init_early) 913dec12e62SRussell King mdesc->init_early(); 9141da177e4SLinus Torvalds } 9151da177e4SLinus Torvalds 9161da177e4SLinus Torvalds 9171da177e4SLinus Torvalds static int __init topology_init(void) 9181da177e4SLinus Torvalds { 9191da177e4SLinus Torvalds int cpu; 9201da177e4SLinus Torvalds 92166fb8bd2SRussell King for_each_possible_cpu(cpu) { 92266fb8bd2SRussell King struct cpuinfo_arm *cpuinfo = &per_cpu(cpu_data, cpu); 92366fb8bd2SRussell King cpuinfo->cpu.hotpluggable = 1; 92466fb8bd2SRussell King register_cpu(&cpuinfo->cpu, cpu); 92566fb8bd2SRussell King } 9261da177e4SLinus Torvalds 9271da177e4SLinus Torvalds return 0; 9281da177e4SLinus Torvalds } 9291da177e4SLinus Torvalds subsys_initcall(topology_init); 9301da177e4SLinus Torvalds 931e119bfffSRussell King #ifdef CONFIG_HAVE_PROC_CPU 932e119bfffSRussell King static int __init proc_cpu_init(void) 933e119bfffSRussell King { 934e119bfffSRussell King struct proc_dir_entry *res; 935e119bfffSRussell King 936e119bfffSRussell King res = proc_mkdir("cpu", NULL); 937e119bfffSRussell King if (!res) 938e119bfffSRussell King return -ENOMEM; 939e119bfffSRussell King return 0; 940e119bfffSRussell King } 941e119bfffSRussell King fs_initcall(proc_cpu_init); 942e119bfffSRussell King #endif 943e119bfffSRussell King 9441da177e4SLinus Torvalds static const char *hwcap_str[] = { 9451da177e4SLinus Torvalds "swp", 9461da177e4SLinus Torvalds "half", 9471da177e4SLinus Torvalds "thumb", 9481da177e4SLinus Torvalds "26bit", 9491da177e4SLinus Torvalds "fastmult", 9501da177e4SLinus Torvalds "fpa", 9511da177e4SLinus Torvalds "vfp", 9521da177e4SLinus Torvalds "edsp", 9531da177e4SLinus Torvalds "java", 9548f7f9435SPaul Gortmaker "iwmmxt", 95599e4a6ddSLennert Buytenhek "crunch", 9564369ae16SCatalin Marinas "thumbee", 9572bedbdf4SCatalin Marinas "neon", 9587279dc3eSCatalin Marinas "vfpv3", 9597279dc3eSCatalin Marinas "vfpv3d16", 9601da177e4SLinus Torvalds NULL 9611da177e4SLinus Torvalds }; 9621da177e4SLinus Torvalds 9631da177e4SLinus Torvalds static int c_show(struct seq_file *m, void *v) 9641da177e4SLinus Torvalds { 9651da177e4SLinus Torvalds int i; 9661da177e4SLinus Torvalds 9671da177e4SLinus Torvalds seq_printf(m, "Processor\t: %s rev %d (%s)\n", 9680ba8b9b2SRussell King cpu_name, read_cpuid_id() & 15, elf_platform); 9691da177e4SLinus Torvalds 9701da177e4SLinus Torvalds #if defined(CONFIG_SMP) 9711da177e4SLinus Torvalds for_each_online_cpu(i) { 97215559722SRussell King /* 97315559722SRussell King * glibc reads /proc/cpuinfo to determine the number of 97415559722SRussell King * online processors, looking for lines beginning with 97515559722SRussell King * "processor". Give glibc what it expects. 97615559722SRussell King */ 97715559722SRussell King seq_printf(m, "processor\t: %d\n", i); 9781da177e4SLinus Torvalds seq_printf(m, "BogoMIPS\t: %lu.%02lu\n\n", 9791da177e4SLinus Torvalds per_cpu(cpu_data, i).loops_per_jiffy / (500000UL/HZ), 9801da177e4SLinus Torvalds (per_cpu(cpu_data, i).loops_per_jiffy / (5000UL/HZ)) % 100); 9811da177e4SLinus Torvalds } 9821da177e4SLinus Torvalds #else /* CONFIG_SMP */ 9831da177e4SLinus Torvalds seq_printf(m, "BogoMIPS\t: %lu.%02lu\n", 9841da177e4SLinus Torvalds loops_per_jiffy / (500000/HZ), 9851da177e4SLinus Torvalds (loops_per_jiffy / (5000/HZ)) % 100); 9861da177e4SLinus Torvalds #endif 9871da177e4SLinus Torvalds 9881da177e4SLinus Torvalds /* dump out the processor features */ 9891da177e4SLinus Torvalds seq_puts(m, "Features\t: "); 9901da177e4SLinus Torvalds 9911da177e4SLinus Torvalds for (i = 0; hwcap_str[i]; i++) 9921da177e4SLinus Torvalds if (elf_hwcap & (1 << i)) 9931da177e4SLinus Torvalds seq_printf(m, "%s ", hwcap_str[i]); 9941da177e4SLinus Torvalds 9950ba8b9b2SRussell King seq_printf(m, "\nCPU implementer\t: 0x%02x\n", read_cpuid_id() >> 24); 9961da177e4SLinus Torvalds seq_printf(m, "CPU architecture: %s\n", proc_arch[cpu_architecture()]); 9971da177e4SLinus Torvalds 9980ba8b9b2SRussell King if ((read_cpuid_id() & 0x0008f000) == 0x00000000) { 9991da177e4SLinus Torvalds /* pre-ARM7 */ 10000ba8b9b2SRussell King seq_printf(m, "CPU part\t: %07x\n", read_cpuid_id() >> 4); 10011da177e4SLinus Torvalds } else { 10020ba8b9b2SRussell King if ((read_cpuid_id() & 0x0008f000) == 0x00007000) { 10031da177e4SLinus Torvalds /* ARM7 */ 10041da177e4SLinus Torvalds seq_printf(m, "CPU variant\t: 0x%02x\n", 10050ba8b9b2SRussell King (read_cpuid_id() >> 16) & 127); 10061da177e4SLinus Torvalds } else { 10071da177e4SLinus Torvalds /* post-ARM7 */ 10081da177e4SLinus Torvalds seq_printf(m, "CPU variant\t: 0x%x\n", 10090ba8b9b2SRussell King (read_cpuid_id() >> 20) & 15); 10101da177e4SLinus Torvalds } 10111da177e4SLinus Torvalds seq_printf(m, "CPU part\t: 0x%03x\n", 10120ba8b9b2SRussell King (read_cpuid_id() >> 4) & 0xfff); 10131da177e4SLinus Torvalds } 10140ba8b9b2SRussell King seq_printf(m, "CPU revision\t: %d\n", read_cpuid_id() & 15); 10151da177e4SLinus Torvalds 10161da177e4SLinus Torvalds seq_puts(m, "\n"); 10171da177e4SLinus Torvalds 10181da177e4SLinus Torvalds seq_printf(m, "Hardware\t: %s\n", machine_name); 10191da177e4SLinus Torvalds seq_printf(m, "Revision\t: %04x\n", system_rev); 10201da177e4SLinus Torvalds seq_printf(m, "Serial\t\t: %08x%08x\n", 10211da177e4SLinus Torvalds system_serial_high, system_serial_low); 10221da177e4SLinus Torvalds 10231da177e4SLinus Torvalds return 0; 10241da177e4SLinus Torvalds } 10251da177e4SLinus Torvalds 10261da177e4SLinus Torvalds static void *c_start(struct seq_file *m, loff_t *pos) 10271da177e4SLinus Torvalds { 10281da177e4SLinus Torvalds return *pos < 1 ? (void *)1 : NULL; 10291da177e4SLinus Torvalds } 10301da177e4SLinus Torvalds 10311da177e4SLinus Torvalds static void *c_next(struct seq_file *m, void *v, loff_t *pos) 10321da177e4SLinus Torvalds { 10331da177e4SLinus Torvalds ++*pos; 10341da177e4SLinus Torvalds return NULL; 10351da177e4SLinus Torvalds } 10361da177e4SLinus Torvalds 10371da177e4SLinus Torvalds static void c_stop(struct seq_file *m, void *v) 10381da177e4SLinus Torvalds { 10391da177e4SLinus Torvalds } 10401da177e4SLinus Torvalds 10412ffd6e18SJan Engelhardt const struct seq_operations cpuinfo_op = { 10421da177e4SLinus Torvalds .start = c_start, 10431da177e4SLinus Torvalds .next = c_next, 10441da177e4SLinus Torvalds .stop = c_stop, 10451da177e4SLinus Torvalds .show = c_show 10461da177e4SLinus Torvalds }; 1047