1 /* 2 * linux/arch/arm/kernel/setup.c 3 * 4 * Copyright (C) 1995-2001 Russell King 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 as 8 * published by the Free Software Foundation. 9 */ 10 #include <linux/efi.h> 11 #include <linux/export.h> 12 #include <linux/kernel.h> 13 #include <linux/stddef.h> 14 #include <linux/ioport.h> 15 #include <linux/delay.h> 16 #include <linux/utsname.h> 17 #include <linux/initrd.h> 18 #include <linux/console.h> 19 #include <linux/bootmem.h> 20 #include <linux/seq_file.h> 21 #include <linux/screen_info.h> 22 #include <linux/of_iommu.h> 23 #include <linux/of_platform.h> 24 #include <linux/init.h> 25 #include <linux/kexec.h> 26 #include <linux/of_fdt.h> 27 #include <linux/cpu.h> 28 #include <linux/interrupt.h> 29 #include <linux/smp.h> 30 #include <linux/proc_fs.h> 31 #include <linux/memblock.h> 32 #include <linux/bug.h> 33 #include <linux/compiler.h> 34 #include <linux/sort.h> 35 #include <linux/psci.h> 36 37 #include <asm/unified.h> 38 #include <asm/cp15.h> 39 #include <asm/cpu.h> 40 #include <asm/cputype.h> 41 #include <asm/efi.h> 42 #include <asm/elf.h> 43 #include <asm/early_ioremap.h> 44 #include <asm/fixmap.h> 45 #include <asm/procinfo.h> 46 #include <asm/psci.h> 47 #include <asm/sections.h> 48 #include <asm/setup.h> 49 #include <asm/smp_plat.h> 50 #include <asm/mach-types.h> 51 #include <asm/cacheflush.h> 52 #include <asm/cachetype.h> 53 #include <asm/tlbflush.h> 54 #include <asm/xen/hypervisor.h> 55 56 #include <asm/prom.h> 57 #include <asm/mach/arch.h> 58 #include <asm/mach/irq.h> 59 #include <asm/mach/time.h> 60 #include <asm/system_info.h> 61 #include <asm/system_misc.h> 62 #include <asm/traps.h> 63 #include <asm/unwind.h> 64 #include <asm/memblock.h> 65 #include <asm/virt.h> 66 67 #include "atags.h" 68 69 70 #if defined(CONFIG_FPE_NWFPE) || defined(CONFIG_FPE_FASTFPE) 71 char fpe_type[8]; 72 73 static int __init fpe_setup(char *line) 74 { 75 memcpy(fpe_type, line, 8); 76 return 1; 77 } 78 79 __setup("fpe=", fpe_setup); 80 #endif 81 82 extern void init_default_cache_policy(unsigned long); 83 extern void paging_init(const struct machine_desc *desc); 84 extern void early_paging_init(const struct machine_desc *); 85 extern void sanity_check_meminfo(void); 86 extern enum reboot_mode reboot_mode; 87 extern void setup_dma_zone(const struct machine_desc *desc); 88 89 unsigned int processor_id; 90 EXPORT_SYMBOL(processor_id); 91 unsigned int __machine_arch_type __read_mostly; 92 EXPORT_SYMBOL(__machine_arch_type); 93 unsigned int cacheid __read_mostly; 94 EXPORT_SYMBOL(cacheid); 95 96 unsigned int __atags_pointer __initdata; 97 98 unsigned int system_rev; 99 EXPORT_SYMBOL(system_rev); 100 101 const char *system_serial; 102 EXPORT_SYMBOL(system_serial); 103 104 unsigned int system_serial_low; 105 EXPORT_SYMBOL(system_serial_low); 106 107 unsigned int system_serial_high; 108 EXPORT_SYMBOL(system_serial_high); 109 110 unsigned int elf_hwcap __read_mostly; 111 EXPORT_SYMBOL(elf_hwcap); 112 113 unsigned int elf_hwcap2 __read_mostly; 114 EXPORT_SYMBOL(elf_hwcap2); 115 116 117 #ifdef MULTI_CPU 118 struct processor processor __read_mostly; 119 #endif 120 #ifdef MULTI_TLB 121 struct cpu_tlb_fns cpu_tlb __read_mostly; 122 #endif 123 #ifdef MULTI_USER 124 struct cpu_user_fns cpu_user __read_mostly; 125 #endif 126 #ifdef MULTI_CACHE 127 struct cpu_cache_fns cpu_cache __read_mostly; 128 #endif 129 #ifdef CONFIG_OUTER_CACHE 130 struct outer_cache_fns outer_cache __read_mostly; 131 EXPORT_SYMBOL(outer_cache); 132 #endif 133 134 /* 135 * Cached cpu_architecture() result for use by assembler code. 136 * C code should use the cpu_architecture() function instead of accessing this 137 * variable directly. 138 */ 139 int __cpu_architecture __read_mostly = CPU_ARCH_UNKNOWN; 140 141 struct stack { 142 u32 irq[3]; 143 u32 abt[3]; 144 u32 und[3]; 145 u32 fiq[3]; 146 } ____cacheline_aligned; 147 148 #ifndef CONFIG_CPU_V7M 149 static struct stack stacks[NR_CPUS]; 150 #endif 151 152 char elf_platform[ELF_PLATFORM_SIZE]; 153 EXPORT_SYMBOL(elf_platform); 154 155 static const char *cpu_name; 156 static const char *machine_name; 157 static char __initdata cmd_line[COMMAND_LINE_SIZE]; 158 const struct machine_desc *machine_desc __initdata; 159 160 static union { char c[4]; unsigned long l; } endian_test __initdata = { { 'l', '?', '?', 'b' } }; 161 #define ENDIANNESS ((char)endian_test.l) 162 163 DEFINE_PER_CPU(struct cpuinfo_arm, cpu_data); 164 165 /* 166 * Standard memory resources 167 */ 168 static struct resource mem_res[] = { 169 { 170 .name = "Video RAM", 171 .start = 0, 172 .end = 0, 173 .flags = IORESOURCE_MEM 174 }, 175 { 176 .name = "Kernel code", 177 .start = 0, 178 .end = 0, 179 .flags = IORESOURCE_MEM 180 }, 181 { 182 .name = "Kernel data", 183 .start = 0, 184 .end = 0, 185 .flags = IORESOURCE_MEM 186 } 187 }; 188 189 #define video_ram mem_res[0] 190 #define kernel_code mem_res[1] 191 #define kernel_data mem_res[2] 192 193 static struct resource io_res[] = { 194 { 195 .name = "reserved", 196 .start = 0x3bc, 197 .end = 0x3be, 198 .flags = IORESOURCE_IO | IORESOURCE_BUSY 199 }, 200 { 201 .name = "reserved", 202 .start = 0x378, 203 .end = 0x37f, 204 .flags = IORESOURCE_IO | IORESOURCE_BUSY 205 }, 206 { 207 .name = "reserved", 208 .start = 0x278, 209 .end = 0x27f, 210 .flags = IORESOURCE_IO | IORESOURCE_BUSY 211 } 212 }; 213 214 #define lp0 io_res[0] 215 #define lp1 io_res[1] 216 #define lp2 io_res[2] 217 218 static const char *proc_arch[] = { 219 "undefined/unknown", 220 "3", 221 "4", 222 "4T", 223 "5", 224 "5T", 225 "5TE", 226 "5TEJ", 227 "6TEJ", 228 "7", 229 "7M", 230 "?(12)", 231 "?(13)", 232 "?(14)", 233 "?(15)", 234 "?(16)", 235 "?(17)", 236 }; 237 238 #ifdef CONFIG_CPU_V7M 239 static int __get_cpu_architecture(void) 240 { 241 return CPU_ARCH_ARMv7M; 242 } 243 #else 244 static int __get_cpu_architecture(void) 245 { 246 int cpu_arch; 247 248 if ((read_cpuid_id() & 0x0008f000) == 0) { 249 cpu_arch = CPU_ARCH_UNKNOWN; 250 } else if ((read_cpuid_id() & 0x0008f000) == 0x00007000) { 251 cpu_arch = (read_cpuid_id() & (1 << 23)) ? CPU_ARCH_ARMv4T : CPU_ARCH_ARMv3; 252 } else if ((read_cpuid_id() & 0x00080000) == 0x00000000) { 253 cpu_arch = (read_cpuid_id() >> 16) & 7; 254 if (cpu_arch) 255 cpu_arch += CPU_ARCH_ARMv3; 256 } else if ((read_cpuid_id() & 0x000f0000) == 0x000f0000) { 257 /* Revised CPUID format. Read the Memory Model Feature 258 * Register 0 and check for VMSAv7 or PMSAv7 */ 259 unsigned int mmfr0 = read_cpuid_ext(CPUID_EXT_MMFR0); 260 if ((mmfr0 & 0x0000000f) >= 0x00000003 || 261 (mmfr0 & 0x000000f0) >= 0x00000030) 262 cpu_arch = CPU_ARCH_ARMv7; 263 else if ((mmfr0 & 0x0000000f) == 0x00000002 || 264 (mmfr0 & 0x000000f0) == 0x00000020) 265 cpu_arch = CPU_ARCH_ARMv6; 266 else 267 cpu_arch = CPU_ARCH_UNKNOWN; 268 } else 269 cpu_arch = CPU_ARCH_UNKNOWN; 270 271 return cpu_arch; 272 } 273 #endif 274 275 int __pure cpu_architecture(void) 276 { 277 BUG_ON(__cpu_architecture == CPU_ARCH_UNKNOWN); 278 279 return __cpu_architecture; 280 } 281 282 static int cpu_has_aliasing_icache(unsigned int arch) 283 { 284 int aliasing_icache; 285 unsigned int id_reg, num_sets, line_size; 286 287 /* PIPT caches never alias. */ 288 if (icache_is_pipt()) 289 return 0; 290 291 /* arch specifies the register format */ 292 switch (arch) { 293 case CPU_ARCH_ARMv7: 294 asm("mcr p15, 2, %0, c0, c0, 0 @ set CSSELR" 295 : /* No output operands */ 296 : "r" (1)); 297 isb(); 298 asm("mrc p15, 1, %0, c0, c0, 0 @ read CCSIDR" 299 : "=r" (id_reg)); 300 line_size = 4 << ((id_reg & 0x7) + 2); 301 num_sets = ((id_reg >> 13) & 0x7fff) + 1; 302 aliasing_icache = (line_size * num_sets) > PAGE_SIZE; 303 break; 304 case CPU_ARCH_ARMv6: 305 aliasing_icache = read_cpuid_cachetype() & (1 << 11); 306 break; 307 default: 308 /* I-cache aliases will be handled by D-cache aliasing code */ 309 aliasing_icache = 0; 310 } 311 312 return aliasing_icache; 313 } 314 315 static void __init cacheid_init(void) 316 { 317 unsigned int arch = cpu_architecture(); 318 319 if (arch == CPU_ARCH_ARMv7M) { 320 cacheid = 0; 321 } else if (arch >= CPU_ARCH_ARMv6) { 322 unsigned int cachetype = read_cpuid_cachetype(); 323 if ((cachetype & (7 << 29)) == 4 << 29) { 324 /* ARMv7 register format */ 325 arch = CPU_ARCH_ARMv7; 326 cacheid = CACHEID_VIPT_NONALIASING; 327 switch (cachetype & (3 << 14)) { 328 case (1 << 14): 329 cacheid |= CACHEID_ASID_TAGGED; 330 break; 331 case (3 << 14): 332 cacheid |= CACHEID_PIPT; 333 break; 334 } 335 } else { 336 arch = CPU_ARCH_ARMv6; 337 if (cachetype & (1 << 23)) 338 cacheid = CACHEID_VIPT_ALIASING; 339 else 340 cacheid = CACHEID_VIPT_NONALIASING; 341 } 342 if (cpu_has_aliasing_icache(arch)) 343 cacheid |= CACHEID_VIPT_I_ALIASING; 344 } else { 345 cacheid = CACHEID_VIVT; 346 } 347 348 pr_info("CPU: %s data cache, %s instruction cache\n", 349 cache_is_vivt() ? "VIVT" : 350 cache_is_vipt_aliasing() ? "VIPT aliasing" : 351 cache_is_vipt_nonaliasing() ? "PIPT / VIPT nonaliasing" : "unknown", 352 cache_is_vivt() ? "VIVT" : 353 icache_is_vivt_asid_tagged() ? "VIVT ASID tagged" : 354 icache_is_vipt_aliasing() ? "VIPT aliasing" : 355 icache_is_pipt() ? "PIPT" : 356 cache_is_vipt_nonaliasing() ? "VIPT nonaliasing" : "unknown"); 357 } 358 359 /* 360 * These functions re-use the assembly code in head.S, which 361 * already provide the required functionality. 362 */ 363 extern struct proc_info_list *lookup_processor_type(unsigned int); 364 365 void __init early_print(const char *str, ...) 366 { 367 extern void printascii(const char *); 368 char buf[256]; 369 va_list ap; 370 371 va_start(ap, str); 372 vsnprintf(buf, sizeof(buf), str, ap); 373 va_end(ap); 374 375 #ifdef CONFIG_DEBUG_LL 376 printascii(buf); 377 #endif 378 printk("%s", buf); 379 } 380 381 #ifdef CONFIG_ARM_PATCH_IDIV 382 383 static inline u32 __attribute_const__ sdiv_instruction(void) 384 { 385 if (IS_ENABLED(CONFIG_THUMB2_KERNEL)) { 386 /* "sdiv r0, r0, r1" */ 387 u32 insn = __opcode_thumb32_compose(0xfb90, 0xf0f1); 388 return __opcode_to_mem_thumb32(insn); 389 } 390 391 /* "sdiv r0, r0, r1" */ 392 return __opcode_to_mem_arm(0xe710f110); 393 } 394 395 static inline u32 __attribute_const__ udiv_instruction(void) 396 { 397 if (IS_ENABLED(CONFIG_THUMB2_KERNEL)) { 398 /* "udiv r0, r0, r1" */ 399 u32 insn = __opcode_thumb32_compose(0xfbb0, 0xf0f1); 400 return __opcode_to_mem_thumb32(insn); 401 } 402 403 /* "udiv r0, r0, r1" */ 404 return __opcode_to_mem_arm(0xe730f110); 405 } 406 407 static inline u32 __attribute_const__ bx_lr_instruction(void) 408 { 409 if (IS_ENABLED(CONFIG_THUMB2_KERNEL)) { 410 /* "bx lr; nop" */ 411 u32 insn = __opcode_thumb32_compose(0x4770, 0x46c0); 412 return __opcode_to_mem_thumb32(insn); 413 } 414 415 /* "bx lr" */ 416 return __opcode_to_mem_arm(0xe12fff1e); 417 } 418 419 static void __init patch_aeabi_idiv(void) 420 { 421 extern void __aeabi_uidiv(void); 422 extern void __aeabi_idiv(void); 423 uintptr_t fn_addr; 424 unsigned int mask; 425 426 mask = IS_ENABLED(CONFIG_THUMB2_KERNEL) ? HWCAP_IDIVT : HWCAP_IDIVA; 427 if (!(elf_hwcap & mask)) 428 return; 429 430 pr_info("CPU: div instructions available: patching division code\n"); 431 432 fn_addr = ((uintptr_t)&__aeabi_uidiv) & ~1; 433 ((u32 *)fn_addr)[0] = udiv_instruction(); 434 ((u32 *)fn_addr)[1] = bx_lr_instruction(); 435 flush_icache_range(fn_addr, fn_addr + 8); 436 437 fn_addr = ((uintptr_t)&__aeabi_idiv) & ~1; 438 ((u32 *)fn_addr)[0] = sdiv_instruction(); 439 ((u32 *)fn_addr)[1] = bx_lr_instruction(); 440 flush_icache_range(fn_addr, fn_addr + 8); 441 } 442 443 #else 444 static inline void patch_aeabi_idiv(void) { } 445 #endif 446 447 static void __init cpuid_init_hwcaps(void) 448 { 449 int block; 450 u32 isar5; 451 452 if (cpu_architecture() < CPU_ARCH_ARMv7) 453 return; 454 455 block = cpuid_feature_extract(CPUID_EXT_ISAR0, 24); 456 if (block >= 2) 457 elf_hwcap |= HWCAP_IDIVA; 458 if (block >= 1) 459 elf_hwcap |= HWCAP_IDIVT; 460 461 /* LPAE implies atomic ldrd/strd instructions */ 462 block = cpuid_feature_extract(CPUID_EXT_MMFR0, 0); 463 if (block >= 5) 464 elf_hwcap |= HWCAP_LPAE; 465 466 /* check for supported v8 Crypto instructions */ 467 isar5 = read_cpuid_ext(CPUID_EXT_ISAR5); 468 469 block = cpuid_feature_extract_field(isar5, 4); 470 if (block >= 2) 471 elf_hwcap2 |= HWCAP2_PMULL; 472 if (block >= 1) 473 elf_hwcap2 |= HWCAP2_AES; 474 475 block = cpuid_feature_extract_field(isar5, 8); 476 if (block >= 1) 477 elf_hwcap2 |= HWCAP2_SHA1; 478 479 block = cpuid_feature_extract_field(isar5, 12); 480 if (block >= 1) 481 elf_hwcap2 |= HWCAP2_SHA2; 482 483 block = cpuid_feature_extract_field(isar5, 16); 484 if (block >= 1) 485 elf_hwcap2 |= HWCAP2_CRC32; 486 } 487 488 static void __init elf_hwcap_fixup(void) 489 { 490 unsigned id = read_cpuid_id(); 491 492 /* 493 * HWCAP_TLS is available only on 1136 r1p0 and later, 494 * see also kuser_get_tls_init. 495 */ 496 if (read_cpuid_part() == ARM_CPU_PART_ARM1136 && 497 ((id >> 20) & 3) == 0) { 498 elf_hwcap &= ~HWCAP_TLS; 499 return; 500 } 501 502 /* Verify if CPUID scheme is implemented */ 503 if ((id & 0x000f0000) != 0x000f0000) 504 return; 505 506 /* 507 * If the CPU supports LDREX/STREX and LDREXB/STREXB, 508 * avoid advertising SWP; it may not be atomic with 509 * multiprocessing cores. 510 */ 511 if (cpuid_feature_extract(CPUID_EXT_ISAR3, 12) > 1 || 512 (cpuid_feature_extract(CPUID_EXT_ISAR3, 12) == 1 && 513 cpuid_feature_extract(CPUID_EXT_ISAR3, 20) >= 3)) 514 elf_hwcap &= ~HWCAP_SWP; 515 } 516 517 /* 518 * cpu_init - initialise one CPU. 519 * 520 * cpu_init sets up the per-CPU stacks. 521 */ 522 void notrace cpu_init(void) 523 { 524 #ifndef CONFIG_CPU_V7M 525 unsigned int cpu = smp_processor_id(); 526 struct stack *stk = &stacks[cpu]; 527 528 if (cpu >= NR_CPUS) { 529 pr_crit("CPU%u: bad primary CPU number\n", cpu); 530 BUG(); 531 } 532 533 /* 534 * This only works on resume and secondary cores. For booting on the 535 * boot cpu, smp_prepare_boot_cpu is called after percpu area setup. 536 */ 537 set_my_cpu_offset(per_cpu_offset(cpu)); 538 539 cpu_proc_init(); 540 541 /* 542 * Define the placement constraint for the inline asm directive below. 543 * In Thumb-2, msr with an immediate value is not allowed. 544 */ 545 #ifdef CONFIG_THUMB2_KERNEL 546 #define PLC "r" 547 #else 548 #define PLC "I" 549 #endif 550 551 /* 552 * setup stacks for re-entrant exception handlers 553 */ 554 __asm__ ( 555 "msr cpsr_c, %1\n\t" 556 "add r14, %0, %2\n\t" 557 "mov sp, r14\n\t" 558 "msr cpsr_c, %3\n\t" 559 "add r14, %0, %4\n\t" 560 "mov sp, r14\n\t" 561 "msr cpsr_c, %5\n\t" 562 "add r14, %0, %6\n\t" 563 "mov sp, r14\n\t" 564 "msr cpsr_c, %7\n\t" 565 "add r14, %0, %8\n\t" 566 "mov sp, r14\n\t" 567 "msr cpsr_c, %9" 568 : 569 : "r" (stk), 570 PLC (PSR_F_BIT | PSR_I_BIT | IRQ_MODE), 571 "I" (offsetof(struct stack, irq[0])), 572 PLC (PSR_F_BIT | PSR_I_BIT | ABT_MODE), 573 "I" (offsetof(struct stack, abt[0])), 574 PLC (PSR_F_BIT | PSR_I_BIT | UND_MODE), 575 "I" (offsetof(struct stack, und[0])), 576 PLC (PSR_F_BIT | PSR_I_BIT | FIQ_MODE), 577 "I" (offsetof(struct stack, fiq[0])), 578 PLC (PSR_F_BIT | PSR_I_BIT | SVC_MODE) 579 : "r14"); 580 #endif 581 } 582 583 u32 __cpu_logical_map[NR_CPUS] = { [0 ... NR_CPUS-1] = MPIDR_INVALID }; 584 585 void __init smp_setup_processor_id(void) 586 { 587 int i; 588 u32 mpidr = is_smp() ? read_cpuid_mpidr() & MPIDR_HWID_BITMASK : 0; 589 u32 cpu = MPIDR_AFFINITY_LEVEL(mpidr, 0); 590 591 cpu_logical_map(0) = cpu; 592 for (i = 1; i < nr_cpu_ids; ++i) 593 cpu_logical_map(i) = i == cpu ? 0 : i; 594 595 /* 596 * clear __my_cpu_offset on boot CPU to avoid hang caused by 597 * using percpu variable early, for example, lockdep will 598 * access percpu variable inside lock_release 599 */ 600 set_my_cpu_offset(0); 601 602 pr_info("Booting Linux on physical CPU 0x%x\n", mpidr); 603 } 604 605 struct mpidr_hash mpidr_hash; 606 #ifdef CONFIG_SMP 607 /** 608 * smp_build_mpidr_hash - Pre-compute shifts required at each affinity 609 * level in order to build a linear index from an 610 * MPIDR value. Resulting algorithm is a collision 611 * free hash carried out through shifting and ORing 612 */ 613 static void __init smp_build_mpidr_hash(void) 614 { 615 u32 i, affinity; 616 u32 fs[3], bits[3], ls, mask = 0; 617 /* 618 * Pre-scan the list of MPIDRS and filter out bits that do 619 * not contribute to affinity levels, ie they never toggle. 620 */ 621 for_each_possible_cpu(i) 622 mask |= (cpu_logical_map(i) ^ cpu_logical_map(0)); 623 pr_debug("mask of set bits 0x%x\n", mask); 624 /* 625 * Find and stash the last and first bit set at all affinity levels to 626 * check how many bits are required to represent them. 627 */ 628 for (i = 0; i < 3; i++) { 629 affinity = MPIDR_AFFINITY_LEVEL(mask, i); 630 /* 631 * Find the MSB bit and LSB bits position 632 * to determine how many bits are required 633 * to express the affinity level. 634 */ 635 ls = fls(affinity); 636 fs[i] = affinity ? ffs(affinity) - 1 : 0; 637 bits[i] = ls - fs[i]; 638 } 639 /* 640 * An index can be created from the MPIDR by isolating the 641 * significant bits at each affinity level and by shifting 642 * them in order to compress the 24 bits values space to a 643 * compressed set of values. This is equivalent to hashing 644 * the MPIDR through shifting and ORing. It is a collision free 645 * hash though not minimal since some levels might contain a number 646 * of CPUs that is not an exact power of 2 and their bit 647 * representation might contain holes, eg MPIDR[7:0] = {0x2, 0x80}. 648 */ 649 mpidr_hash.shift_aff[0] = fs[0]; 650 mpidr_hash.shift_aff[1] = MPIDR_LEVEL_BITS + fs[1] - bits[0]; 651 mpidr_hash.shift_aff[2] = 2*MPIDR_LEVEL_BITS + fs[2] - 652 (bits[1] + bits[0]); 653 mpidr_hash.mask = mask; 654 mpidr_hash.bits = bits[2] + bits[1] + bits[0]; 655 pr_debug("MPIDR hash: aff0[%u] aff1[%u] aff2[%u] mask[0x%x] bits[%u]\n", 656 mpidr_hash.shift_aff[0], 657 mpidr_hash.shift_aff[1], 658 mpidr_hash.shift_aff[2], 659 mpidr_hash.mask, 660 mpidr_hash.bits); 661 /* 662 * 4x is an arbitrary value used to warn on a hash table much bigger 663 * than expected on most systems. 664 */ 665 if (mpidr_hash_size() > 4 * num_possible_cpus()) 666 pr_warn("Large number of MPIDR hash buckets detected\n"); 667 sync_cache_w(&mpidr_hash); 668 } 669 #endif 670 671 static void __init setup_processor(void) 672 { 673 struct proc_info_list *list; 674 675 /* 676 * locate processor in the list of supported processor 677 * types. The linker builds this table for us from the 678 * entries in arch/arm/mm/proc-*.S 679 */ 680 list = lookup_processor_type(read_cpuid_id()); 681 if (!list) { 682 pr_err("CPU configuration botched (ID %08x), unable to continue.\n", 683 read_cpuid_id()); 684 while (1); 685 } 686 687 cpu_name = list->cpu_name; 688 __cpu_architecture = __get_cpu_architecture(); 689 690 #ifdef MULTI_CPU 691 processor = *list->proc; 692 #endif 693 #ifdef MULTI_TLB 694 cpu_tlb = *list->tlb; 695 #endif 696 #ifdef MULTI_USER 697 cpu_user = *list->user; 698 #endif 699 #ifdef MULTI_CACHE 700 cpu_cache = *list->cache; 701 #endif 702 703 pr_info("CPU: %s [%08x] revision %d (ARMv%s), cr=%08lx\n", 704 cpu_name, read_cpuid_id(), read_cpuid_id() & 15, 705 proc_arch[cpu_architecture()], get_cr()); 706 707 snprintf(init_utsname()->machine, __NEW_UTS_LEN + 1, "%s%c", 708 list->arch_name, ENDIANNESS); 709 snprintf(elf_platform, ELF_PLATFORM_SIZE, "%s%c", 710 list->elf_name, ENDIANNESS); 711 elf_hwcap = list->elf_hwcap; 712 713 cpuid_init_hwcaps(); 714 patch_aeabi_idiv(); 715 716 #ifndef CONFIG_ARM_THUMB 717 elf_hwcap &= ~(HWCAP_THUMB | HWCAP_IDIVT); 718 #endif 719 #ifdef CONFIG_MMU 720 init_default_cache_policy(list->__cpu_mm_mmu_flags); 721 #endif 722 erratum_a15_798181_init(); 723 724 elf_hwcap_fixup(); 725 726 cacheid_init(); 727 cpu_init(); 728 } 729 730 void __init dump_machine_table(void) 731 { 732 const struct machine_desc *p; 733 734 early_print("Available machine support:\n\nID (hex)\tNAME\n"); 735 for_each_machine_desc(p) 736 early_print("%08x\t%s\n", p->nr, p->name); 737 738 early_print("\nPlease check your kernel config and/or bootloader.\n"); 739 740 while (true) 741 /* can't use cpu_relax() here as it may require MMU setup */; 742 } 743 744 int __init arm_add_memory(u64 start, u64 size) 745 { 746 u64 aligned_start; 747 748 /* 749 * Ensure that start/size are aligned to a page boundary. 750 * Size is rounded down, start is rounded up. 751 */ 752 aligned_start = PAGE_ALIGN(start); 753 if (aligned_start > start + size) 754 size = 0; 755 else 756 size -= aligned_start - start; 757 758 #ifndef CONFIG_ARCH_PHYS_ADDR_T_64BIT 759 if (aligned_start > ULONG_MAX) { 760 pr_crit("Ignoring memory at 0x%08llx outside 32-bit physical address space\n", 761 (long long)start); 762 return -EINVAL; 763 } 764 765 if (aligned_start + size > ULONG_MAX) { 766 pr_crit("Truncating memory at 0x%08llx to fit in 32-bit physical address space\n", 767 (long long)start); 768 /* 769 * To ensure bank->start + bank->size is representable in 770 * 32 bits, we use ULONG_MAX as the upper limit rather than 4GB. 771 * This means we lose a page after masking. 772 */ 773 size = ULONG_MAX - aligned_start; 774 } 775 #endif 776 777 if (aligned_start < PHYS_OFFSET) { 778 if (aligned_start + size <= PHYS_OFFSET) { 779 pr_info("Ignoring memory below PHYS_OFFSET: 0x%08llx-0x%08llx\n", 780 aligned_start, aligned_start + size); 781 return -EINVAL; 782 } 783 784 pr_info("Ignoring memory below PHYS_OFFSET: 0x%08llx-0x%08llx\n", 785 aligned_start, (u64)PHYS_OFFSET); 786 787 size -= PHYS_OFFSET - aligned_start; 788 aligned_start = PHYS_OFFSET; 789 } 790 791 start = aligned_start; 792 size = size & ~(phys_addr_t)(PAGE_SIZE - 1); 793 794 /* 795 * Check whether this memory region has non-zero size or 796 * invalid node number. 797 */ 798 if (size == 0) 799 return -EINVAL; 800 801 memblock_add(start, size); 802 return 0; 803 } 804 805 /* 806 * Pick out the memory size. We look for mem=size@start, 807 * where start and size are "size[KkMm]" 808 */ 809 810 static int __init early_mem(char *p) 811 { 812 static int usermem __initdata = 0; 813 u64 size; 814 u64 start; 815 char *endp; 816 817 /* 818 * If the user specifies memory size, we 819 * blow away any automatically generated 820 * size. 821 */ 822 if (usermem == 0) { 823 usermem = 1; 824 memblock_remove(memblock_start_of_DRAM(), 825 memblock_end_of_DRAM() - memblock_start_of_DRAM()); 826 } 827 828 start = PHYS_OFFSET; 829 size = memparse(p, &endp); 830 if (*endp == '@') 831 start = memparse(endp + 1, NULL); 832 833 arm_add_memory(start, size); 834 835 return 0; 836 } 837 early_param("mem", early_mem); 838 839 static void __init request_standard_resources(const struct machine_desc *mdesc) 840 { 841 struct memblock_region *region; 842 struct resource *res; 843 844 kernel_code.start = virt_to_phys(_text); 845 kernel_code.end = virt_to_phys(_etext - 1); 846 kernel_data.start = virt_to_phys(_sdata); 847 kernel_data.end = virt_to_phys(_end - 1); 848 849 for_each_memblock(memory, region) { 850 res = memblock_virt_alloc(sizeof(*res), 0); 851 res->name = "System RAM"; 852 res->start = __pfn_to_phys(memblock_region_memory_base_pfn(region)); 853 res->end = __pfn_to_phys(memblock_region_memory_end_pfn(region)) - 1; 854 res->flags = IORESOURCE_MEM | IORESOURCE_BUSY; 855 856 request_resource(&iomem_resource, res); 857 858 if (kernel_code.start >= res->start && 859 kernel_code.end <= res->end) 860 request_resource(res, &kernel_code); 861 if (kernel_data.start >= res->start && 862 kernel_data.end <= res->end) 863 request_resource(res, &kernel_data); 864 } 865 866 if (mdesc->video_start) { 867 video_ram.start = mdesc->video_start; 868 video_ram.end = mdesc->video_end; 869 request_resource(&iomem_resource, &video_ram); 870 } 871 872 /* 873 * Some machines don't have the possibility of ever 874 * possessing lp0, lp1 or lp2 875 */ 876 if (mdesc->reserve_lp0) 877 request_resource(&ioport_resource, &lp0); 878 if (mdesc->reserve_lp1) 879 request_resource(&ioport_resource, &lp1); 880 if (mdesc->reserve_lp2) 881 request_resource(&ioport_resource, &lp2); 882 } 883 884 #if defined(CONFIG_VGA_CONSOLE) || defined(CONFIG_DUMMY_CONSOLE) 885 struct screen_info screen_info = { 886 .orig_video_lines = 30, 887 .orig_video_cols = 80, 888 .orig_video_mode = 0, 889 .orig_video_ega_bx = 0, 890 .orig_video_isVGA = 1, 891 .orig_video_points = 8 892 }; 893 #endif 894 895 static int __init customize_machine(void) 896 { 897 /* 898 * customizes platform devices, or adds new ones 899 * On DT based machines, we fall back to populating the 900 * machine from the device tree, if no callback is provided, 901 * otherwise we would always need an init_machine callback. 902 */ 903 of_iommu_init(); 904 if (machine_desc->init_machine) 905 machine_desc->init_machine(); 906 #ifdef CONFIG_OF 907 else 908 of_platform_populate(NULL, of_default_bus_match_table, 909 NULL, NULL); 910 #endif 911 return 0; 912 } 913 arch_initcall(customize_machine); 914 915 static int __init init_machine_late(void) 916 { 917 struct device_node *root; 918 int ret; 919 920 if (machine_desc->init_late) 921 machine_desc->init_late(); 922 923 root = of_find_node_by_path("/"); 924 if (root) { 925 ret = of_property_read_string(root, "serial-number", 926 &system_serial); 927 if (ret) 928 system_serial = NULL; 929 } 930 931 if (!system_serial) 932 system_serial = kasprintf(GFP_KERNEL, "%08x%08x", 933 system_serial_high, 934 system_serial_low); 935 936 return 0; 937 } 938 late_initcall(init_machine_late); 939 940 #ifdef CONFIG_KEXEC 941 static inline unsigned long long get_total_mem(void) 942 { 943 unsigned long total; 944 945 total = max_low_pfn - min_low_pfn; 946 return total << PAGE_SHIFT; 947 } 948 949 /** 950 * reserve_crashkernel() - reserves memory are for crash kernel 951 * 952 * This function reserves memory area given in "crashkernel=" kernel command 953 * line parameter. The memory reserved is used by a dump capture kernel when 954 * primary kernel is crashing. 955 */ 956 static void __init reserve_crashkernel(void) 957 { 958 unsigned long long crash_size, crash_base; 959 unsigned long long total_mem; 960 int ret; 961 962 total_mem = get_total_mem(); 963 ret = parse_crashkernel(boot_command_line, total_mem, 964 &crash_size, &crash_base); 965 if (ret) 966 return; 967 968 ret = memblock_reserve(crash_base, crash_size); 969 if (ret < 0) { 970 pr_warn("crashkernel reservation failed - memory is in use (0x%lx)\n", 971 (unsigned long)crash_base); 972 return; 973 } 974 975 pr_info("Reserving %ldMB of memory at %ldMB for crashkernel (System RAM: %ldMB)\n", 976 (unsigned long)(crash_size >> 20), 977 (unsigned long)(crash_base >> 20), 978 (unsigned long)(total_mem >> 20)); 979 980 crashk_res.start = crash_base; 981 crashk_res.end = crash_base + crash_size - 1; 982 insert_resource(&iomem_resource, &crashk_res); 983 } 984 #else 985 static inline void reserve_crashkernel(void) {} 986 #endif /* CONFIG_KEXEC */ 987 988 void __init hyp_mode_check(void) 989 { 990 #ifdef CONFIG_ARM_VIRT_EXT 991 sync_boot_mode(); 992 993 if (is_hyp_mode_available()) { 994 pr_info("CPU: All CPU(s) started in HYP mode.\n"); 995 pr_info("CPU: Virtualization extensions available.\n"); 996 } else if (is_hyp_mode_mismatched()) { 997 pr_warn("CPU: WARNING: CPU(s) started in wrong/inconsistent modes (primary CPU mode 0x%x)\n", 998 __boot_cpu_mode & MODE_MASK); 999 pr_warn("CPU: This may indicate a broken bootloader or firmware.\n"); 1000 } else 1001 pr_info("CPU: All CPU(s) started in SVC mode.\n"); 1002 #endif 1003 } 1004 1005 void __init setup_arch(char **cmdline_p) 1006 { 1007 const struct machine_desc *mdesc; 1008 1009 setup_processor(); 1010 mdesc = setup_machine_fdt(__atags_pointer); 1011 if (!mdesc) 1012 mdesc = setup_machine_tags(__atags_pointer, __machine_arch_type); 1013 machine_desc = mdesc; 1014 machine_name = mdesc->name; 1015 dump_stack_set_arch_desc("%s", mdesc->name); 1016 1017 if (mdesc->reboot_mode != REBOOT_HARD) 1018 reboot_mode = mdesc->reboot_mode; 1019 1020 init_mm.start_code = (unsigned long) _text; 1021 init_mm.end_code = (unsigned long) _etext; 1022 init_mm.end_data = (unsigned long) _edata; 1023 init_mm.brk = (unsigned long) _end; 1024 1025 /* populate cmd_line too for later use, preserving boot_command_line */ 1026 strlcpy(cmd_line, boot_command_line, COMMAND_LINE_SIZE); 1027 *cmdline_p = cmd_line; 1028 1029 early_fixmap_init(); 1030 early_ioremap_init(); 1031 1032 parse_early_param(); 1033 1034 #ifdef CONFIG_MMU 1035 early_paging_init(mdesc); 1036 #endif 1037 setup_dma_zone(mdesc); 1038 efi_init(); 1039 sanity_check_meminfo(); 1040 arm_memblock_init(mdesc); 1041 1042 early_ioremap_reset(); 1043 1044 paging_init(mdesc); 1045 request_standard_resources(mdesc); 1046 1047 if (mdesc->restart) 1048 arm_pm_restart = mdesc->restart; 1049 1050 unflatten_device_tree(); 1051 1052 arm_dt_init_cpu_maps(); 1053 psci_dt_init(); 1054 xen_early_init(); 1055 #ifdef CONFIG_SMP 1056 if (is_smp()) { 1057 if (!mdesc->smp_init || !mdesc->smp_init()) { 1058 if (psci_smp_available()) 1059 smp_set_ops(&psci_smp_ops); 1060 else if (mdesc->smp) 1061 smp_set_ops(mdesc->smp); 1062 } 1063 smp_init_cpus(); 1064 smp_build_mpidr_hash(); 1065 } 1066 #endif 1067 1068 if (!is_smp()) 1069 hyp_mode_check(); 1070 1071 reserve_crashkernel(); 1072 1073 #ifdef CONFIG_MULTI_IRQ_HANDLER 1074 handle_arch_irq = mdesc->handle_irq; 1075 #endif 1076 1077 #ifdef CONFIG_VT 1078 #if defined(CONFIG_VGA_CONSOLE) 1079 conswitchp = &vga_con; 1080 #elif defined(CONFIG_DUMMY_CONSOLE) 1081 conswitchp = &dummy_con; 1082 #endif 1083 #endif 1084 1085 if (mdesc->init_early) 1086 mdesc->init_early(); 1087 } 1088 1089 1090 static int __init topology_init(void) 1091 { 1092 int cpu; 1093 1094 for_each_possible_cpu(cpu) { 1095 struct cpuinfo_arm *cpuinfo = &per_cpu(cpu_data, cpu); 1096 cpuinfo->cpu.hotpluggable = platform_can_hotplug_cpu(cpu); 1097 register_cpu(&cpuinfo->cpu, cpu); 1098 } 1099 1100 return 0; 1101 } 1102 subsys_initcall(topology_init); 1103 1104 #ifdef CONFIG_HAVE_PROC_CPU 1105 static int __init proc_cpu_init(void) 1106 { 1107 struct proc_dir_entry *res; 1108 1109 res = proc_mkdir("cpu", NULL); 1110 if (!res) 1111 return -ENOMEM; 1112 return 0; 1113 } 1114 fs_initcall(proc_cpu_init); 1115 #endif 1116 1117 static const char *hwcap_str[] = { 1118 "swp", 1119 "half", 1120 "thumb", 1121 "26bit", 1122 "fastmult", 1123 "fpa", 1124 "vfp", 1125 "edsp", 1126 "java", 1127 "iwmmxt", 1128 "crunch", 1129 "thumbee", 1130 "neon", 1131 "vfpv3", 1132 "vfpv3d16", 1133 "tls", 1134 "vfpv4", 1135 "idiva", 1136 "idivt", 1137 "vfpd32", 1138 "lpae", 1139 "evtstrm", 1140 NULL 1141 }; 1142 1143 static const char *hwcap2_str[] = { 1144 "aes", 1145 "pmull", 1146 "sha1", 1147 "sha2", 1148 "crc32", 1149 NULL 1150 }; 1151 1152 static int c_show(struct seq_file *m, void *v) 1153 { 1154 int i, j; 1155 u32 cpuid; 1156 1157 for_each_online_cpu(i) { 1158 /* 1159 * glibc reads /proc/cpuinfo to determine the number of 1160 * online processors, looking for lines beginning with 1161 * "processor". Give glibc what it expects. 1162 */ 1163 seq_printf(m, "processor\t: %d\n", i); 1164 cpuid = is_smp() ? per_cpu(cpu_data, i).cpuid : read_cpuid_id(); 1165 seq_printf(m, "model name\t: %s rev %d (%s)\n", 1166 cpu_name, cpuid & 15, elf_platform); 1167 1168 #if defined(CONFIG_SMP) 1169 seq_printf(m, "BogoMIPS\t: %lu.%02lu\n", 1170 per_cpu(cpu_data, i).loops_per_jiffy / (500000UL/HZ), 1171 (per_cpu(cpu_data, i).loops_per_jiffy / (5000UL/HZ)) % 100); 1172 #else 1173 seq_printf(m, "BogoMIPS\t: %lu.%02lu\n", 1174 loops_per_jiffy / (500000/HZ), 1175 (loops_per_jiffy / (5000/HZ)) % 100); 1176 #endif 1177 /* dump out the processor features */ 1178 seq_puts(m, "Features\t: "); 1179 1180 for (j = 0; hwcap_str[j]; j++) 1181 if (elf_hwcap & (1 << j)) 1182 seq_printf(m, "%s ", hwcap_str[j]); 1183 1184 for (j = 0; hwcap2_str[j]; j++) 1185 if (elf_hwcap2 & (1 << j)) 1186 seq_printf(m, "%s ", hwcap2_str[j]); 1187 1188 seq_printf(m, "\nCPU implementer\t: 0x%02x\n", cpuid >> 24); 1189 seq_printf(m, "CPU architecture: %s\n", 1190 proc_arch[cpu_architecture()]); 1191 1192 if ((cpuid & 0x0008f000) == 0x00000000) { 1193 /* pre-ARM7 */ 1194 seq_printf(m, "CPU part\t: %07x\n", cpuid >> 4); 1195 } else { 1196 if ((cpuid & 0x0008f000) == 0x00007000) { 1197 /* ARM7 */ 1198 seq_printf(m, "CPU variant\t: 0x%02x\n", 1199 (cpuid >> 16) & 127); 1200 } else { 1201 /* post-ARM7 */ 1202 seq_printf(m, "CPU variant\t: 0x%x\n", 1203 (cpuid >> 20) & 15); 1204 } 1205 seq_printf(m, "CPU part\t: 0x%03x\n", 1206 (cpuid >> 4) & 0xfff); 1207 } 1208 seq_printf(m, "CPU revision\t: %d\n\n", cpuid & 15); 1209 } 1210 1211 seq_printf(m, "Hardware\t: %s\n", machine_name); 1212 seq_printf(m, "Revision\t: %04x\n", system_rev); 1213 seq_printf(m, "Serial\t\t: %s\n", system_serial); 1214 1215 return 0; 1216 } 1217 1218 static void *c_start(struct seq_file *m, loff_t *pos) 1219 { 1220 return *pos < 1 ? (void *)1 : NULL; 1221 } 1222 1223 static void *c_next(struct seq_file *m, void *v, loff_t *pos) 1224 { 1225 ++*pos; 1226 return NULL; 1227 } 1228 1229 static void c_stop(struct seq_file *m, void *v) 1230 { 1231 } 1232 1233 const struct seq_operations cpuinfo_op = { 1234 .start = c_start, 1235 .next = c_next, 1236 .stop = c_stop, 1237 .show = c_show 1238 }; 1239