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