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