1 /* 2 * Based on arch/arm/kernel/setup.c 3 * 4 * Copyright (C) 1995-2001 Russell King 5 * Copyright (C) 2012 ARM Ltd. 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program. If not, see <http://www.gnu.org/licenses/>. 18 */ 19 20 #include <linux/acpi.h> 21 #include <linux/export.h> 22 #include <linux/kernel.h> 23 #include <linux/stddef.h> 24 #include <linux/ioport.h> 25 #include <linux/delay.h> 26 #include <linux/utsname.h> 27 #include <linux/initrd.h> 28 #include <linux/console.h> 29 #include <linux/cache.h> 30 #include <linux/bootmem.h> 31 #include <linux/seq_file.h> 32 #include <linux/screen_info.h> 33 #include <linux/init.h> 34 #include <linux/kexec.h> 35 #include <linux/crash_dump.h> 36 #include <linux/root_dev.h> 37 #include <linux/cpu.h> 38 #include <linux/interrupt.h> 39 #include <linux/smp.h> 40 #include <linux/fs.h> 41 #include <linux/proc_fs.h> 42 #include <linux/memblock.h> 43 #include <linux/of_iommu.h> 44 #include <linux/of_fdt.h> 45 #include <linux/of_platform.h> 46 #include <linux/efi.h> 47 #include <linux/personality.h> 48 #include <linux/psci.h> 49 50 #include <asm/acpi.h> 51 #include <asm/fixmap.h> 52 #include <asm/cpu.h> 53 #include <asm/cputype.h> 54 #include <asm/elf.h> 55 #include <asm/cpufeature.h> 56 #include <asm/cpu_ops.h> 57 #include <asm/sections.h> 58 #include <asm/setup.h> 59 #include <asm/smp_plat.h> 60 #include <asm/cacheflush.h> 61 #include <asm/tlbflush.h> 62 #include <asm/traps.h> 63 #include <asm/memblock.h> 64 #include <asm/efi.h> 65 #include <asm/xen/hypervisor.h> 66 67 unsigned long elf_hwcap __read_mostly; 68 EXPORT_SYMBOL_GPL(elf_hwcap); 69 70 #ifdef CONFIG_COMPAT 71 #define COMPAT_ELF_HWCAP_DEFAULT \ 72 (COMPAT_HWCAP_HALF|COMPAT_HWCAP_THUMB|\ 73 COMPAT_HWCAP_FAST_MULT|COMPAT_HWCAP_EDSP|\ 74 COMPAT_HWCAP_TLS|COMPAT_HWCAP_VFP|\ 75 COMPAT_HWCAP_VFPv3|COMPAT_HWCAP_VFPv4|\ 76 COMPAT_HWCAP_NEON|COMPAT_HWCAP_IDIV|\ 77 COMPAT_HWCAP_LPAE) 78 unsigned int compat_elf_hwcap __read_mostly = COMPAT_ELF_HWCAP_DEFAULT; 79 unsigned int compat_elf_hwcap2 __read_mostly; 80 #endif 81 82 DECLARE_BITMAP(cpu_hwcaps, ARM64_NCAPS); 83 84 phys_addr_t __fdt_pointer __initdata; 85 86 /* 87 * Standard memory resources 88 */ 89 static struct resource mem_res[] = { 90 { 91 .name = "Kernel code", 92 .start = 0, 93 .end = 0, 94 .flags = IORESOURCE_MEM 95 }, 96 { 97 .name = "Kernel data", 98 .start = 0, 99 .end = 0, 100 .flags = IORESOURCE_MEM 101 } 102 }; 103 104 #define kernel_code mem_res[0] 105 #define kernel_data mem_res[1] 106 107 /* 108 * The recorded values of x0 .. x3 upon kernel entry. 109 */ 110 u64 __cacheline_aligned boot_args[4]; 111 112 void __init smp_setup_processor_id(void) 113 { 114 u64 mpidr = read_cpuid_mpidr() & MPIDR_HWID_BITMASK; 115 cpu_logical_map(0) = mpidr; 116 117 /* 118 * clear __my_cpu_offset on boot CPU to avoid hang caused by 119 * using percpu variable early, for example, lockdep will 120 * access percpu variable inside lock_release 121 */ 122 set_my_cpu_offset(0); 123 pr_info("Booting Linux on physical CPU 0x%lx\n", (unsigned long)mpidr); 124 } 125 126 bool arch_match_cpu_phys_id(int cpu, u64 phys_id) 127 { 128 return phys_id == cpu_logical_map(cpu); 129 } 130 131 struct mpidr_hash mpidr_hash; 132 /** 133 * smp_build_mpidr_hash - Pre-compute shifts required at each affinity 134 * level in order to build a linear index from an 135 * MPIDR value. Resulting algorithm is a collision 136 * free hash carried out through shifting and ORing 137 */ 138 static void __init smp_build_mpidr_hash(void) 139 { 140 u32 i, affinity, fs[4], bits[4], ls; 141 u64 mask = 0; 142 /* 143 * Pre-scan the list of MPIDRS and filter out bits that do 144 * not contribute to affinity levels, ie they never toggle. 145 */ 146 for_each_possible_cpu(i) 147 mask |= (cpu_logical_map(i) ^ cpu_logical_map(0)); 148 pr_debug("mask of set bits %#llx\n", mask); 149 /* 150 * Find and stash the last and first bit set at all affinity levels to 151 * check how many bits are required to represent them. 152 */ 153 for (i = 0; i < 4; i++) { 154 affinity = MPIDR_AFFINITY_LEVEL(mask, i); 155 /* 156 * Find the MSB bit and LSB bits position 157 * to determine how many bits are required 158 * to express the affinity level. 159 */ 160 ls = fls(affinity); 161 fs[i] = affinity ? ffs(affinity) - 1 : 0; 162 bits[i] = ls - fs[i]; 163 } 164 /* 165 * An index can be created from the MPIDR_EL1 by isolating the 166 * significant bits at each affinity level and by shifting 167 * them in order to compress the 32 bits values space to a 168 * compressed set of values. This is equivalent to hashing 169 * the MPIDR_EL1 through shifting and ORing. It is a collision free 170 * hash though not minimal since some levels might contain a number 171 * of CPUs that is not an exact power of 2 and their bit 172 * representation might contain holes, eg MPIDR_EL1[7:0] = {0x2, 0x80}. 173 */ 174 mpidr_hash.shift_aff[0] = MPIDR_LEVEL_SHIFT(0) + fs[0]; 175 mpidr_hash.shift_aff[1] = MPIDR_LEVEL_SHIFT(1) + fs[1] - bits[0]; 176 mpidr_hash.shift_aff[2] = MPIDR_LEVEL_SHIFT(2) + fs[2] - 177 (bits[1] + bits[0]); 178 mpidr_hash.shift_aff[3] = MPIDR_LEVEL_SHIFT(3) + 179 fs[3] - (bits[2] + bits[1] + bits[0]); 180 mpidr_hash.mask = mask; 181 mpidr_hash.bits = bits[3] + bits[2] + bits[1] + bits[0]; 182 pr_debug("MPIDR hash: aff0[%u] aff1[%u] aff2[%u] aff3[%u] mask[%#llx] bits[%u]\n", 183 mpidr_hash.shift_aff[0], 184 mpidr_hash.shift_aff[1], 185 mpidr_hash.shift_aff[2], 186 mpidr_hash.shift_aff[3], 187 mpidr_hash.mask, 188 mpidr_hash.bits); 189 /* 190 * 4x is an arbitrary value used to warn on a hash table much bigger 191 * than expected on most systems. 192 */ 193 if (mpidr_hash_size() > 4 * num_possible_cpus()) 194 pr_warn("Large number of MPIDR hash buckets detected\n"); 195 __flush_dcache_area(&mpidr_hash, sizeof(struct mpidr_hash)); 196 } 197 198 static void __init setup_processor(void) 199 { 200 u64 features; 201 s64 block; 202 u32 cwg; 203 int cls; 204 205 printk("CPU: AArch64 Processor [%08x] revision %d\n", 206 read_cpuid_id(), read_cpuid_id() & 15); 207 208 sprintf(init_utsname()->machine, ELF_PLATFORM); 209 elf_hwcap = 0; 210 211 cpuinfo_store_boot_cpu(); 212 213 /* 214 * Check for sane CTR_EL0.CWG value. 215 */ 216 cwg = cache_type_cwg(); 217 cls = cache_line_size(); 218 if (!cwg) 219 pr_warn("No Cache Writeback Granule information, assuming cache line size %d\n", 220 cls); 221 if (L1_CACHE_BYTES < cls) 222 pr_warn("L1_CACHE_BYTES smaller than the Cache Writeback Granule (%d < %d)\n", 223 L1_CACHE_BYTES, cls); 224 225 /* 226 * ID_AA64ISAR0_EL1 contains 4-bit wide signed feature blocks. 227 * The blocks we test below represent incremental functionality 228 * for non-negative values. Negative values are reserved. 229 */ 230 features = read_cpuid(ID_AA64ISAR0_EL1); 231 block = cpuid_feature_extract_field(features, 4); 232 if (block > 0) { 233 switch (block) { 234 default: 235 case 2: 236 elf_hwcap |= HWCAP_PMULL; 237 case 1: 238 elf_hwcap |= HWCAP_AES; 239 case 0: 240 break; 241 } 242 } 243 244 if (cpuid_feature_extract_field(features, 8) > 0) 245 elf_hwcap |= HWCAP_SHA1; 246 247 if (cpuid_feature_extract_field(features, 12) > 0) 248 elf_hwcap |= HWCAP_SHA2; 249 250 if (cpuid_feature_extract_field(features, 16) > 0) 251 elf_hwcap |= HWCAP_CRC32; 252 253 block = cpuid_feature_extract_field(features, 20); 254 if (block > 0) { 255 switch (block) { 256 default: 257 case 2: 258 elf_hwcap |= HWCAP_ATOMICS; 259 case 1: 260 /* RESERVED */ 261 case 0: 262 break; 263 } 264 } 265 266 #ifdef CONFIG_COMPAT 267 /* 268 * ID_ISAR5_EL1 carries similar information as above, but pertaining to 269 * the AArch32 32-bit execution state. 270 */ 271 features = read_cpuid(ID_ISAR5_EL1); 272 block = cpuid_feature_extract_field(features, 4); 273 if (block > 0) { 274 switch (block) { 275 default: 276 case 2: 277 compat_elf_hwcap2 |= COMPAT_HWCAP2_PMULL; 278 case 1: 279 compat_elf_hwcap2 |= COMPAT_HWCAP2_AES; 280 case 0: 281 break; 282 } 283 } 284 285 if (cpuid_feature_extract_field(features, 8) > 0) 286 compat_elf_hwcap2 |= COMPAT_HWCAP2_SHA1; 287 288 if (cpuid_feature_extract_field(features, 12) > 0) 289 compat_elf_hwcap2 |= COMPAT_HWCAP2_SHA2; 290 291 if (cpuid_feature_extract_field(features, 16) > 0) 292 compat_elf_hwcap2 |= COMPAT_HWCAP2_CRC32; 293 #endif 294 } 295 296 static void __init setup_machine_fdt(phys_addr_t dt_phys) 297 { 298 void *dt_virt = fixmap_remap_fdt(dt_phys); 299 300 if (!dt_virt || !early_init_dt_scan(dt_virt)) { 301 pr_crit("\n" 302 "Error: invalid device tree blob at physical address %pa (virtual address 0x%p)\n" 303 "The dtb must be 8-byte aligned and must not exceed 2 MB in size\n" 304 "\nPlease check your bootloader.", 305 &dt_phys, dt_virt); 306 307 while (true) 308 cpu_relax(); 309 } 310 311 dump_stack_set_arch_desc("%s (DT)", of_flat_dt_get_machine_name()); 312 } 313 314 static void __init request_standard_resources(void) 315 { 316 struct memblock_region *region; 317 struct resource *res; 318 319 kernel_code.start = virt_to_phys(_text); 320 kernel_code.end = virt_to_phys(_etext - 1); 321 kernel_data.start = virt_to_phys(_sdata); 322 kernel_data.end = virt_to_phys(_end - 1); 323 324 for_each_memblock(memory, region) { 325 res = alloc_bootmem_low(sizeof(*res)); 326 res->name = "System RAM"; 327 res->start = __pfn_to_phys(memblock_region_memory_base_pfn(region)); 328 res->end = __pfn_to_phys(memblock_region_memory_end_pfn(region)) - 1; 329 res->flags = IORESOURCE_MEM | IORESOURCE_BUSY; 330 331 request_resource(&iomem_resource, res); 332 333 if (kernel_code.start >= res->start && 334 kernel_code.end <= res->end) 335 request_resource(res, &kernel_code); 336 if (kernel_data.start >= res->start && 337 kernel_data.end <= res->end) 338 request_resource(res, &kernel_data); 339 } 340 } 341 342 #ifdef CONFIG_BLK_DEV_INITRD 343 /* 344 * Relocate initrd if it is not completely within the linear mapping. 345 * This would be the case if mem= cuts out all or part of it. 346 */ 347 static void __init relocate_initrd(void) 348 { 349 phys_addr_t orig_start = __virt_to_phys(initrd_start); 350 phys_addr_t orig_end = __virt_to_phys(initrd_end); 351 phys_addr_t ram_end = memblock_end_of_DRAM(); 352 phys_addr_t new_start; 353 unsigned long size, to_free = 0; 354 void *dest; 355 356 if (orig_end <= ram_end) 357 return; 358 359 /* 360 * Any of the original initrd which overlaps the linear map should 361 * be freed after relocating. 362 */ 363 if (orig_start < ram_end) 364 to_free = ram_end - orig_start; 365 366 size = orig_end - orig_start; 367 if (!size) 368 return; 369 370 /* initrd needs to be relocated completely inside linear mapping */ 371 new_start = memblock_find_in_range(0, PFN_PHYS(max_pfn), 372 size, PAGE_SIZE); 373 if (!new_start) 374 panic("Cannot relocate initrd of size %ld\n", size); 375 memblock_reserve(new_start, size); 376 377 initrd_start = __phys_to_virt(new_start); 378 initrd_end = initrd_start + size; 379 380 pr_info("Moving initrd from [%llx-%llx] to [%llx-%llx]\n", 381 orig_start, orig_start + size - 1, 382 new_start, new_start + size - 1); 383 384 dest = (void *)initrd_start; 385 386 if (to_free) { 387 memcpy(dest, (void *)__phys_to_virt(orig_start), to_free); 388 dest += to_free; 389 } 390 391 copy_from_early_mem(dest, orig_start + to_free, size - to_free); 392 393 if (to_free) { 394 pr_info("Freeing original RAMDISK from [%llx-%llx]\n", 395 orig_start, orig_start + to_free - 1); 396 memblock_free(orig_start, to_free); 397 } 398 } 399 #else 400 static inline void __init relocate_initrd(void) 401 { 402 } 403 #endif 404 405 u64 __cpu_logical_map[NR_CPUS] = { [0 ... NR_CPUS-1] = INVALID_HWID }; 406 407 void __init setup_arch(char **cmdline_p) 408 { 409 setup_processor(); 410 411 init_mm.start_code = (unsigned long) _text; 412 init_mm.end_code = (unsigned long) _etext; 413 init_mm.end_data = (unsigned long) _edata; 414 init_mm.brk = (unsigned long) _end; 415 416 *cmdline_p = boot_command_line; 417 418 early_fixmap_init(); 419 early_ioremap_init(); 420 421 setup_machine_fdt(__fdt_pointer); 422 423 parse_early_param(); 424 425 /* 426 * Unmask asynchronous aborts after bringing up possible earlycon. 427 * (Report possible System Errors once we can report this occurred) 428 */ 429 local_async_enable(); 430 431 efi_init(); 432 arm64_memblock_init(); 433 434 /* Parse the ACPI tables for possible boot-time configuration */ 435 acpi_boot_table_init(); 436 437 paging_init(); 438 relocate_initrd(); 439 request_standard_resources(); 440 441 early_ioremap_reset(); 442 443 if (acpi_disabled) { 444 unflatten_device_tree(); 445 psci_dt_init(); 446 } else { 447 psci_acpi_init(); 448 } 449 xen_early_init(); 450 451 cpu_read_bootcpu_ops(); 452 smp_init_cpus(); 453 smp_build_mpidr_hash(); 454 455 #ifdef CONFIG_VT 456 #if defined(CONFIG_VGA_CONSOLE) 457 conswitchp = &vga_con; 458 #elif defined(CONFIG_DUMMY_CONSOLE) 459 conswitchp = &dummy_con; 460 #endif 461 #endif 462 if (boot_args[1] || boot_args[2] || boot_args[3]) { 463 pr_err("WARNING: x1-x3 nonzero in violation of boot protocol:\n" 464 "\tx1: %016llx\n\tx2: %016llx\n\tx3: %016llx\n" 465 "This indicates a broken bootloader or old kernel\n", 466 boot_args[1], boot_args[2], boot_args[3]); 467 } 468 } 469 470 static int __init arm64_device_init(void) 471 { 472 if (of_have_populated_dt()) { 473 of_iommu_init(); 474 of_platform_populate(NULL, of_default_bus_match_table, 475 NULL, NULL); 476 } else if (acpi_disabled) { 477 pr_crit("Device tree not populated\n"); 478 } 479 return 0; 480 } 481 arch_initcall_sync(arm64_device_init); 482 483 static int __init topology_init(void) 484 { 485 int i; 486 487 for_each_possible_cpu(i) { 488 struct cpu *cpu = &per_cpu(cpu_data.cpu, i); 489 cpu->hotpluggable = 1; 490 register_cpu(cpu, i); 491 } 492 493 return 0; 494 } 495 subsys_initcall(topology_init); 496 497 static const char *hwcap_str[] = { 498 "fp", 499 "asimd", 500 "evtstrm", 501 "aes", 502 "pmull", 503 "sha1", 504 "sha2", 505 "crc32", 506 "atomics", 507 NULL 508 }; 509 510 #ifdef CONFIG_COMPAT 511 static const char *compat_hwcap_str[] = { 512 "swp", 513 "half", 514 "thumb", 515 "26bit", 516 "fastmult", 517 "fpa", 518 "vfp", 519 "edsp", 520 "java", 521 "iwmmxt", 522 "crunch", 523 "thumbee", 524 "neon", 525 "vfpv3", 526 "vfpv3d16", 527 "tls", 528 "vfpv4", 529 "idiva", 530 "idivt", 531 "vfpd32", 532 "lpae", 533 "evtstrm" 534 }; 535 536 static const char *compat_hwcap2_str[] = { 537 "aes", 538 "pmull", 539 "sha1", 540 "sha2", 541 "crc32", 542 NULL 543 }; 544 #endif /* CONFIG_COMPAT */ 545 546 static int c_show(struct seq_file *m, void *v) 547 { 548 int i, j; 549 550 for_each_online_cpu(i) { 551 struct cpuinfo_arm64 *cpuinfo = &per_cpu(cpu_data, i); 552 u32 midr = cpuinfo->reg_midr; 553 554 /* 555 * glibc reads /proc/cpuinfo to determine the number of 556 * online processors, looking for lines beginning with 557 * "processor". Give glibc what it expects. 558 */ 559 seq_printf(m, "processor\t: %d\n", i); 560 561 /* 562 * Dump out the common processor features in a single line. 563 * Userspace should read the hwcaps with getauxval(AT_HWCAP) 564 * rather than attempting to parse this, but there's a body of 565 * software which does already (at least for 32-bit). 566 */ 567 seq_puts(m, "Features\t:"); 568 if (personality(current->personality) == PER_LINUX32) { 569 #ifdef CONFIG_COMPAT 570 for (j = 0; compat_hwcap_str[j]; j++) 571 if (compat_elf_hwcap & (1 << j)) 572 seq_printf(m, " %s", compat_hwcap_str[j]); 573 574 for (j = 0; compat_hwcap2_str[j]; j++) 575 if (compat_elf_hwcap2 & (1 << j)) 576 seq_printf(m, " %s", compat_hwcap2_str[j]); 577 #endif /* CONFIG_COMPAT */ 578 } else { 579 for (j = 0; hwcap_str[j]; j++) 580 if (elf_hwcap & (1 << j)) 581 seq_printf(m, " %s", hwcap_str[j]); 582 } 583 seq_puts(m, "\n"); 584 585 seq_printf(m, "CPU implementer\t: 0x%02x\n", 586 MIDR_IMPLEMENTOR(midr)); 587 seq_printf(m, "CPU architecture: 8\n"); 588 seq_printf(m, "CPU variant\t: 0x%x\n", MIDR_VARIANT(midr)); 589 seq_printf(m, "CPU part\t: 0x%03x\n", MIDR_PARTNUM(midr)); 590 seq_printf(m, "CPU revision\t: %d\n\n", MIDR_REVISION(midr)); 591 } 592 593 return 0; 594 } 595 596 static void *c_start(struct seq_file *m, loff_t *pos) 597 { 598 return *pos < 1 ? (void *)1 : NULL; 599 } 600 601 static void *c_next(struct seq_file *m, void *v, loff_t *pos) 602 { 603 ++*pos; 604 return NULL; 605 } 606 607 static void c_stop(struct seq_file *m, void *v) 608 { 609 } 610 611 const struct seq_operations cpuinfo_op = { 612 .start = c_start, 613 .next = c_next, 614 .stop = c_stop, 615 .show = c_show 616 }; 617