arch/arm64/kernel/setup.c

   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/kasan.h>
  58 #include <asm/sections.h>
  59 #include <asm/setup.h>
  60 #include <asm/smp_plat.h>
  61 #include <asm/cacheflush.h>
  62 #include <asm/tlbflush.h>
  63 #include <asm/traps.h>
  64 #include <asm/memblock.h>
  65 #include <asm/efi.h>
  66 #include <asm/xen/hypervisor.h>
  67
  68 phys_addr_t __fdt_pointer __initdata;
  69
  70 /*
  71  * Standard memory resources
  72  */
  73 static struct resource mem_res[] = {
  74         {
  75                 .name = "Kernel code",
  76                 .start = 0,
  77                 .end = 0,
  78                 .flags = IORESOURCE_MEM
  79         },
  80         {
  81                 .name = "Kernel data",
  82                 .start = 0,
  83                 .end = 0,
  84                 .flags = IORESOURCE_MEM
  85         }
  86 };
  87
  88 #define kernel_code mem_res[0]
  89 #define kernel_data mem_res[1]
  90
  91 /*
  92  * The recorded values of x0 .. x3 upon kernel entry.
  93  */
  94 u64 __cacheline_aligned boot_args[4];
  95
  96 void __init smp_setup_processor_id(void)
  97 {
  98         u64 mpidr = read_cpuid_mpidr() & MPIDR_HWID_BITMASK;
  99         cpu_logical_map(0) = mpidr;
 100
 101         /*
 102          * clear __my_cpu_offset on boot CPU to avoid hang caused by
 103          * using percpu variable early, for example, lockdep will
 104          * access percpu variable inside lock_release
 105          */
 106         set_my_cpu_offset(0);
 107         pr_info("Booting Linux on physical CPU 0x%lx\n", (unsigned long)mpidr);
 108 }
 109
 110 bool arch_match_cpu_phys_id(int cpu, u64 phys_id)
 111 {
 112         return phys_id == cpu_logical_map(cpu);
 113 }
 114
 115 struct mpidr_hash mpidr_hash;
 116 /**
 117  * smp_build_mpidr_hash - Pre-compute shifts required at each affinity
 118  *                        level in order to build a linear index from an
 119  *                        MPIDR value. Resulting algorithm is a collision
 120  *                        free hash carried out through shifting and ORing
 121  */
 122 static void __init smp_build_mpidr_hash(void)
 123 {
 124         u32 i, affinity, fs[4], bits[4], ls;
 125         u64 mask = 0;
 126         /*
 127          * Pre-scan the list of MPIDRS and filter out bits that do
 128          * not contribute to affinity levels, ie they never toggle.
 129          */
 130         for_each_possible_cpu(i)
 131                 mask |= (cpu_logical_map(i) ^ cpu_logical_map(0));
 132         pr_debug("mask of set bits %#llx\n", mask);
 133         /*
 134          * Find and stash the last and first bit set at all affinity levels to
 135          * check how many bits are required to represent them.
 136          */
 137         for (i = 0; i < 4; i++) {
 138                 affinity = MPIDR_AFFINITY_LEVEL(mask, i);
 139                 /*
 140                  * Find the MSB bit and LSB bits position
 141                  * to determine how many bits are required
 142                  * to express the affinity level.
 143                  */
 144                 ls = fls(affinity);
 145                 fs[i] = affinity ? ffs(affinity) - 1 : 0;
 146                 bits[i] = ls - fs[i];
 147         }
 148         /*
 149          * An index can be created from the MPIDR_EL1 by isolating the
 150          * significant bits at each affinity level and by shifting
 151          * them in order to compress the 32 bits values space to a
 152          * compressed set of values. This is equivalent to hashing
 153          * the MPIDR_EL1 through shifting and ORing. It is a collision free
 154          * hash though not minimal since some levels might contain a number
 155          * of CPUs that is not an exact power of 2 and their bit
 156          * representation might contain holes, eg MPIDR_EL1[7:0] = {0x2, 0x80}.
 157          */
 158         mpidr_hash.shift_aff[0] = MPIDR_LEVEL_SHIFT(0) + fs[0];
 159         mpidr_hash.shift_aff[1] = MPIDR_LEVEL_SHIFT(1) + fs[1] - bits[0];
 160         mpidr_hash.shift_aff[2] = MPIDR_LEVEL_SHIFT(2) + fs[2] -
 161                                                 (bits[1] + bits[0]);
 162         mpidr_hash.shift_aff[3] = MPIDR_LEVEL_SHIFT(3) +
 163                                   fs[3] - (bits[2] + bits[1] + bits[0]);
 164         mpidr_hash.mask = mask;
 165         mpidr_hash.bits = bits[3] + bits[2] + bits[1] + bits[0];
 166         pr_debug("MPIDR hash: aff0[%u] aff1[%u] aff2[%u] aff3[%u] mask[%#llx] bits[%u]\n",
 167                 mpidr_hash.shift_aff[0],
 168                 mpidr_hash.shift_aff[1],
 169                 mpidr_hash.shift_aff[2],
 170                 mpidr_hash.shift_aff[3],
 171                 mpidr_hash.mask,
 172                 mpidr_hash.bits);
 173         /*
 174          * 4x is an arbitrary value used to warn on a hash table much bigger
 175          * than expected on most systems.
 176          */
 177         if (mpidr_hash_size() > 4 * num_possible_cpus())
 178                 pr_warn("Large number of MPIDR hash buckets detected\n");
 179         __flush_dcache_area(&mpidr_hash, sizeof(struct mpidr_hash));
 180 }
 181
 182 static void __init setup_machine_fdt(phys_addr_t dt_phys)
 183 {
 184         void *dt_virt = fixmap_remap_fdt(dt_phys);
 185
 186         if (!dt_virt || !early_init_dt_scan(dt_virt)) {
 187                 pr_crit("\n"
 188                         "Error: invalid device tree blob at physical address %pa (virtual address 0x%p)\n"
 189                         "The dtb must be 8-byte aligned and must not exceed 2 MB in size\n"
 190                         "\nPlease check your bootloader.",
 191                         &dt_phys, dt_virt);
 192
 193                 while (true)
 194                         cpu_relax();
 195         }
 196
 197         dump_stack_set_arch_desc("%s (DT)", of_flat_dt_get_machine_name());
 198 }
 199
 200 static void __init request_standard_resources(void)
 201 {
 202         struct memblock_region *region;
 203         struct resource *res;
 204
 205         kernel_code.start   = virt_to_phys(_text);
 206         kernel_code.end     = virt_to_phys(_etext - 1);
 207         kernel_data.start   = virt_to_phys(_sdata);
 208         kernel_data.end     = virt_to_phys(_end - 1);
 209
 210         for_each_memblock(memory, region) {
 211                 res = alloc_bootmem_low(sizeof(*res));
 212                 res->name  = "System RAM";
 213                 res->start = __pfn_to_phys(memblock_region_memory_base_pfn(region));
 214                 res->end = __pfn_to_phys(memblock_region_memory_end_pfn(region)) - 1;
 215                 res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
 216
 217                 request_resource(&iomem_resource, res);
 218
 219                 if (kernel_code.start >= res->start &&
 220                     kernel_code.end <= res->end)
 221                         request_resource(res, &kernel_code);
 222                 if (kernel_data.start >= res->start &&
 223                     kernel_data.end <= res->end)
 224                         request_resource(res, &kernel_data);
 225         }
 226 }
 227
 228 #ifdef CONFIG_BLK_DEV_INITRD
 229 /*
 230  * Relocate initrd if it is not completely within the linear mapping.
 231  * This would be the case if mem= cuts out all or part of it.
 232  */
 233 static void __init relocate_initrd(void)
 234 {
 235         phys_addr_t orig_start = __virt_to_phys(initrd_start);
 236         phys_addr_t orig_end = __virt_to_phys(initrd_end);
 237         phys_addr_t ram_end = memblock_end_of_DRAM();
 238         phys_addr_t new_start;
 239         unsigned long size, to_free = 0;
 240         void *dest;
 241
 242         if (orig_end <= ram_end)
 243                 return;
 244
 245         /*
 246          * Any of the original initrd which overlaps the linear map should
 247          * be freed after relocating.
 248          */
 249         if (orig_start < ram_end)
 250                 to_free = ram_end - orig_start;
 251
 252         size = orig_end - orig_start;
 253
 254         /* initrd needs to be relocated completely inside linear mapping */
 255         new_start = memblock_find_in_range(0, PFN_PHYS(max_pfn),
 256                                            size, PAGE_SIZE);
 257         if (!new_start)
 258                 panic("Cannot relocate initrd of size %ld\n", size);
 259         memblock_reserve(new_start, size);
 260
 261         initrd_start = __phys_to_virt(new_start);
 262         initrd_end   = initrd_start + size;
 263
 264         pr_info("Moving initrd from [%llx-%llx] to [%llx-%llx]\n",
 265                 orig_start, orig_start + size - 1,
 266                 new_start, new_start + size - 1);
 267
 268         dest = (void *)initrd_start;
 269
 270         if (to_free) {
 271                 memcpy(dest, (void *)__phys_to_virt(orig_start), to_free);
 272                 dest += to_free;
 273         }
 274
 275         copy_from_early_mem(dest, orig_start + to_free, size - to_free);
 276
 277         if (to_free) {
 278                 pr_info("Freeing original RAMDISK from [%llx-%llx]\n",
 279                         orig_start, orig_start + to_free - 1);
 280                 memblock_free(orig_start, to_free);
 281         }
 282 }
 283 #else
 284 static inline void __init relocate_initrd(void)
 285 {
 286 }
 287 #endif
 288
 289 u64 __cpu_logical_map[NR_CPUS] = { [0 ... NR_CPUS-1] = INVALID_HWID };
 290
 291 void __init setup_arch(char **cmdline_p)
 292 {
 293         pr_info("Boot CPU: AArch64 Processor [%08x]\n", read_cpuid_id());
 294
 295         sprintf(init_utsname()->machine, ELF_PLATFORM);
 296         init_mm.start_code = (unsigned long) _text;
 297         init_mm.end_code   = (unsigned long) _etext;
 298         init_mm.end_data   = (unsigned long) _edata;
 299         init_mm.brk        = (unsigned long) _end;
 300
 301         *cmdline_p = boot_command_line;
 302
 303         early_fixmap_init();
 304         early_ioremap_init();
 305
 306         setup_machine_fdt(__fdt_pointer);
 307
 308         parse_early_param();
 309
 310         /*
 311          *  Unmask asynchronous aborts after bringing up possible earlycon.
 312          * (Report possible System Errors once we can report this occurred)
 313          */
 314         local_async_enable();
 315
 316         efi_init();
 317         arm64_memblock_init();
 318
 319         /* Parse the ACPI tables for possible boot-time configuration */
 320         acpi_boot_table_init();
 321
 322         paging_init();
 323         relocate_initrd();
 324
 325         kasan_init();
 326
 327         request_standard_resources();
 328
 329         early_ioremap_reset();
 330
 331         if (acpi_disabled) {
 332                 unflatten_device_tree();
 333                 psci_dt_init();
 334         } else {
 335                 psci_acpi_init();
 336         }
 337         xen_early_init();
 338
 339         cpu_read_bootcpu_ops();
 340         smp_init_cpus();
 341         smp_build_mpidr_hash();
 342
 343 #ifdef CONFIG_VT
 344 #if defined(CONFIG_VGA_CONSOLE)
 345         conswitchp = &vga_con;
 346 #elif defined(CONFIG_DUMMY_CONSOLE)
 347         conswitchp = &dummy_con;
 348 #endif
 349 #endif
 350         if (boot_args[1] || boot_args[2] || boot_args[3]) {
 351                 pr_err("WARNING: x1-x3 nonzero in violation of boot protocol:\n"
 352                         "\tx1: %016llx\n\tx2: %016llx\n\tx3: %016llx\n"
 353                         "This indicates a broken bootloader or old kernel\n",
 354                         boot_args[1], boot_args[2], boot_args[3]);
 355         }
 356 }
 357
 358 static int __init arm64_device_init(void)
 359 {
 360         if (of_have_populated_dt()) {
 361                 of_iommu_init();
 362                 of_platform_populate(NULL, of_default_bus_match_table,
 363                                      NULL, NULL);
 364         } else if (acpi_disabled) {
 365                 pr_crit("Device tree not populated\n");
 366         }
 367         return 0;
 368 }
 369 arch_initcall_sync(arm64_device_init);
 370
 371 static int __init topology_init(void)
 372 {
 373         int i;
 374
 375         for_each_possible_cpu(i) {
 376                 struct cpu *cpu = &per_cpu(cpu_data.cpu, i);
 377                 cpu->hotpluggable = 1;
 378                 register_cpu(cpu, i);
 379         }
 380
 381         return 0;
 382 }
 383 subsys_initcall(topology_init);
 384
 385 static const char *hwcap_str[] = {
 386         "fp",
 387         "asimd",
 388         "evtstrm",
 389         "aes",
 390         "pmull",
 391         "sha1",
 392         "sha2",
 393         "crc32",
 394         "atomics",
 395         NULL
 396 };
 397
 398 #ifdef CONFIG_COMPAT
 399 static const char *compat_hwcap_str[] = {
 400         "swp",
 401         "half",
 402         "thumb",
 403         "26bit",
 404         "fastmult",
 405         "fpa",
 406         "vfp",
 407         "edsp",
 408         "java",
 409         "iwmmxt",
 410         "crunch",
 411         "thumbee",
 412         "neon",
 413         "vfpv3",
 414         "vfpv3d16",
 415         "tls",
 416         "vfpv4",
 417         "idiva",
 418         "idivt",
 419         "vfpd32",
 420         "lpae",
 421         "evtstrm"
 422 };
 423
 424 static const char *compat_hwcap2_str[] = {
 425         "aes",
 426         "pmull",
 427         "sha1",
 428         "sha2",
 429         "crc32",
 430         NULL
 431 };
 432 #endif /* CONFIG_COMPAT */
 433
 434 static int c_show(struct seq_file *m, void *v)
 435 {
 436         int i, j;
 437
 438         for_each_online_cpu(i) {
 439                 struct cpuinfo_arm64 *cpuinfo = &per_cpu(cpu_data, i);
 440                 u32 midr = cpuinfo->reg_midr;
 441
 442                 /*
 443                  * glibc reads /proc/cpuinfo to determine the number of
 444                  * online processors, looking for lines beginning with
 445                  * "processor".  Give glibc what it expects.
 446                  */
 447                 seq_printf(m, "processor\t: %d\n", i);
 448
 449                 /*
 450                  * Dump out the common processor features in a single line.
 451                  * Userspace should read the hwcaps with getauxval(AT_HWCAP)
 452                  * rather than attempting to parse this, but there's a body of
 453                  * software which does already (at least for 32-bit).
 454                  */
 455                 seq_puts(m, "Features\t:");
 456                 if (personality(current->personality) == PER_LINUX32) {
 457 #ifdef CONFIG_COMPAT
 458                         for (j = 0; compat_hwcap_str[j]; j++)
 459                                 if (compat_elf_hwcap & (1 << j))
 460                                         seq_printf(m, " %s", compat_hwcap_str[j]);
 461
 462                         for (j = 0; compat_hwcap2_str[j]; j++)
 463                                 if (compat_elf_hwcap2 & (1 << j))
 464                                         seq_printf(m, " %s", compat_hwcap2_str[j]);
 465 #endif /* CONFIG_COMPAT */
 466                 } else {
 467                         for (j = 0; hwcap_str[j]; j++)
 468                                 if (elf_hwcap & (1 << j))
 469                                         seq_printf(m, " %s", hwcap_str[j]);
 470                 }
 471                 seq_puts(m, "\n");
 472
 473                 seq_printf(m, "CPU implementer\t: 0x%02x\n",
 474                            MIDR_IMPLEMENTOR(midr));
 475                 seq_printf(m, "CPU architecture: 8\n");
 476                 seq_printf(m, "CPU variant\t: 0x%x\n", MIDR_VARIANT(midr));
 477                 seq_printf(m, "CPU part\t: 0x%03x\n", MIDR_PARTNUM(midr));
 478                 seq_printf(m, "CPU revision\t: %d\n\n", MIDR_REVISION(midr));
 479         }
 480
 481         return 0;
 482 }
 483
 484 static void *c_start(struct seq_file *m, loff_t *pos)
 485 {
 486         return *pos < 1 ? (void *)1 : NULL;
 487 }
 488
 489 static void *c_next(struct seq_file *m, void *v, loff_t *pos)
 490 {
 491         ++*pos;
 492         return NULL;
 493 }
 494
 495 static void c_stop(struct seq_file *m, void *v)
 496 {
 497 }
 498
 499 const struct seq_operations cpuinfo_op = {
 500         .start  = c_start,
 501         .next   = c_next,
 502         .stop   = c_stop,
 503         .show   = c_show
 504 };