arch/arm/kernel/setup.c

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