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 extern struct machine_desc *lookup_machine_type(unsigned int);
 312
 313 static void __init feat_v6_fixup(void)
 314 {
 315         int id = read_cpuid_id();
 316
 317         if ((id & 0xff0f0000) != 0x41070000)
 318                 return;
 319
 320         /*
 321          * HWCAP_TLS is available only on 1136 r1p0 and later,
 322          * see also kuser_get_tls_init.
 323          */
 324         if ((((id >> 4) & 0xfff) == 0xb36) && (((id >> 20) & 3) == 0))
 325                 elf_hwcap &= ~HWCAP_TLS;
 326 }
 327
 328 static void __init setup_processor(void)
 329 {
 330         struct proc_info_list *list;
 331
 332         /*
 333          * locate processor in the list of supported processor
 334          * types.  The linker builds this table for us from the
 335          * entries in arch/arm/mm/proc-*.S
 336          */
 337         list = lookup_processor_type(read_cpuid_id());
 338         if (!list) {
 339                 printk("CPU configuration botched (ID %08x), unable "
 340                        "to continue.\n", read_cpuid_id());
 341                 while (1);
 342         }
 343
 344         cpu_name = list->cpu_name;
 345
 346 #ifdef MULTI_CPU
 347         processor = *list->proc;
 348 #endif
 349 #ifdef MULTI_TLB
 350         cpu_tlb = *list->tlb;
 351 #endif
 352 #ifdef MULTI_USER
 353         cpu_user = *list->user;
 354 #endif
 355 #ifdef MULTI_CACHE
 356         cpu_cache = *list->cache;
 357 #endif
 358
 359         printk("CPU: %s [%08x] revision %d (ARMv%s), cr=%08lx\n",
 360                cpu_name, read_cpuid_id(), read_cpuid_id() & 15,
 361                proc_arch[cpu_architecture()], cr_alignment);
 362
 363         sprintf(init_utsname()->machine, "%s%c", list->arch_name, ENDIANNESS);
 364         sprintf(elf_platform, "%s%c", list->elf_name, ENDIANNESS);
 365         elf_hwcap = list->elf_hwcap;
 366 #ifndef CONFIG_ARM_THUMB
 367         elf_hwcap &= ~HWCAP_THUMB;
 368 #endif
 369
 370         feat_v6_fixup();
 371
 372         cacheid_init();
 373         cpu_proc_init();
 374 }
 375
 376 /*
 377  * cpu_init - initialise one CPU.
 378  *
 379  * cpu_init sets up the per-CPU stacks.
 380  */
 381 void cpu_init(void)
 382 {
 383         unsigned int cpu = smp_processor_id();
 384         struct stack *stk = &stacks[cpu];
 385
 386         if (cpu >= NR_CPUS) {
 387                 printk(KERN_CRIT "CPU%u: bad primary CPU number\n", cpu);
 388                 BUG();
 389         }
 390
 391         /*
 392          * Define the placement constraint for the inline asm directive below.
 393          * In Thumb-2, msr with an immediate value is not allowed.
 394          */
 395 #ifdef CONFIG_THUMB2_KERNEL
 396 #define PLC     "r"
 397 #else
 398 #define PLC     "I"
 399 #endif
 400
 401         /*
 402          * setup stacks for re-entrant exception handlers
 403          */
 404         __asm__ (
 405         "msr    cpsr_c, %1\n\t"
 406         "add    r14, %0, %2\n\t"
 407         "mov    sp, r14\n\t"
 408         "msr    cpsr_c, %3\n\t"
 409         "add    r14, %0, %4\n\t"
 410         "mov    sp, r14\n\t"
 411         "msr    cpsr_c, %5\n\t"
 412         "add    r14, %0, %6\n\t"
 413         "mov    sp, r14\n\t"
 414         "msr    cpsr_c, %7"
 415             :
 416             : "r" (stk),
 417               PLC (PSR_F_BIT | PSR_I_BIT | IRQ_MODE),
 418               "I" (offsetof(struct stack, irq[0])),
 419               PLC (PSR_F_BIT | PSR_I_BIT | ABT_MODE),
 420               "I" (offsetof(struct stack, abt[0])),
 421               PLC (PSR_F_BIT | PSR_I_BIT | UND_MODE),
 422               "I" (offsetof(struct stack, und[0])),
 423               PLC (PSR_F_BIT | PSR_I_BIT | SVC_MODE)
 424             : "r14");
 425 }
 426
 427 static struct machine_desc * __init setup_machine(unsigned int nr)
 428 {
 429         struct machine_desc *list;
 430
 431         /*
 432          * locate machine in the list of supported machines.
 433          */
 434         list = lookup_machine_type(nr);
 435         if (!list) {
 436                 printk("Machine configuration botched (nr %d), unable "
 437                        "to continue.\n", nr);
 438                 while (1);
 439         }
 440
 441         printk("Machine: %s\n", list->name);
 442
 443         return list;
 444 }
 445
 446 static int __init arm_add_memory(unsigned long start, unsigned long size)
 447 {
 448         struct membank *bank = &meminfo.bank[meminfo.nr_banks];
 449
 450         if (meminfo.nr_banks >= NR_BANKS) {
 451                 printk(KERN_CRIT "NR_BANKS too low, "
 452                         "ignoring memory at %#lx\n", start);
 453                 return -EINVAL;
 454         }
 455
 456         /*
 457          * Ensure that start/size are aligned to a page boundary.
 458          * Size is appropriately rounded down, start is rounded up.
 459          */
 460         size -= start & ~PAGE_MASK;
 461         bank->start = PAGE_ALIGN(start);
 462         bank->size  = size & PAGE_MASK;
 463
 464         /*
 465          * Check whether this memory region has non-zero size or
 466          * invalid node number.
 467          */
 468         if (bank->size == 0)
 469                 return -EINVAL;
 470
 471         meminfo.nr_banks++;
 472         return 0;
 473 }
 474
 475 /*
 476  * Pick out the memory size.  We look for mem=size@start,
 477  * where start and size are "size[KkMm]"
 478  */
 479 static int __init early_mem(char *p)
 480 {
 481         static int usermem __initdata = 0;
 482         unsigned long size, start;
 483         char *endp;
 484
 485         /*
 486          * If the user specifies memory size, we
 487          * blow away any automatically generated
 488          * size.
 489          */
 490         if (usermem == 0) {
 491                 usermem = 1;
 492                 meminfo.nr_banks = 0;
 493         }
 494
 495         start = PHYS_OFFSET;
 496         size  = memparse(p, &endp);
 497         if (*endp == '@')
 498                 start = memparse(endp + 1, NULL);
 499
 500         arm_add_memory(start, size);
 501
 502         return 0;
 503 }
 504 early_param("mem", early_mem);
 505
 506 static void __init
 507 setup_ramdisk(int doload, int prompt, int image_start, unsigned int rd_sz)
 508 {
 509 #ifdef CONFIG_BLK_DEV_RAM
 510         extern int rd_size, rd_image_start, rd_prompt, rd_doload;
 511
 512         rd_image_start = image_start;
 513         rd_prompt = prompt;
 514         rd_doload = doload;
 515
 516         if (rd_sz)
 517                 rd_size = rd_sz;
 518 #endif
 519 }
 520
 521 static void __init request_standard_resources(struct machine_desc *mdesc)
 522 {
 523         struct memblock_region *region;
 524         struct resource *res;
 525
 526         kernel_code.start   = virt_to_phys(_text);
 527         kernel_code.end     = virt_to_phys(_etext - 1);
 528         kernel_data.start   = virt_to_phys(_sdata);
 529         kernel_data.end     = virt_to_phys(_end - 1);
 530
 531         for_each_memblock(memory, region) {
 532                 res = alloc_bootmem_low(sizeof(*res));
 533                 res->name  = "System RAM";
 534                 res->start = __pfn_to_phys(memblock_region_memory_base_pfn(region));
 535                 res->end = __pfn_to_phys(memblock_region_memory_end_pfn(region)) - 1;
 536                 res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
 537
 538                 request_resource(&iomem_resource, res);
 539
 540                 if (kernel_code.start >= res->start &&
 541                     kernel_code.end <= res->end)
 542                         request_resource(res, &kernel_code);
 543                 if (kernel_data.start >= res->start &&
 544                     kernel_data.end <= res->end)
 545                         request_resource(res, &kernel_data);
 546         }
 547
 548         if (mdesc->video_start) {
 549                 video_ram.start = mdesc->video_start;
 550                 video_ram.end   = mdesc->video_end;
 551                 request_resource(&iomem_resource, &video_ram);
 552         }
 553
 554         /*
 555          * Some machines don't have the possibility of ever
 556          * possessing lp0, lp1 or lp2
 557          */
 558         if (mdesc->reserve_lp0)
 559                 request_resource(&ioport_resource, &lp0);
 560         if (mdesc->reserve_lp1)
 561                 request_resource(&ioport_resource, &lp1);
 562         if (mdesc->reserve_lp2)
 563                 request_resource(&ioport_resource, &lp2);
 564 }
 565
 566 /*
 567  *  Tag parsing.
 568  *
 569  * This is the new way of passing data to the kernel at boot time.  Rather
 570  * than passing a fixed inflexible structure to the kernel, we pass a list
 571  * of variable-sized tags to the kernel.  The first tag must be a ATAG_CORE
 572  * tag for the list to be recognised (to distinguish the tagged list from
 573  * a param_struct).  The list is terminated with a zero-length tag (this tag
 574  * is not parsed in any way).
 575  */
 576 static int __init parse_tag_core(const struct tag *tag)
 577 {
 578         if (tag->hdr.size > 2) {
 579                 if ((tag->u.core.flags & 1) == 0)
 580                         root_mountflags &= ~MS_RDONLY;
 581                 ROOT_DEV = old_decode_dev(tag->u.core.rootdev);
 582         }
 583         return 0;
 584 }
 585
 586 __tagtable(ATAG_CORE, parse_tag_core);
 587
 588 static int __init parse_tag_mem32(const struct tag *tag)
 589 {
 590         return arm_add_memory(tag->u.mem.start, tag->u.mem.size);
 591 }
 592
 593 __tagtable(ATAG_MEM, parse_tag_mem32);
 594
 595 #if defined(CONFIG_VGA_CONSOLE) || defined(CONFIG_DUMMY_CONSOLE)
 596 struct screen_info screen_info = {
 597  .orig_video_lines      = 30,
 598  .orig_video_cols       = 80,
 599  .orig_video_mode       = 0,
 600  .orig_video_ega_bx     = 0,
 601  .orig_video_isVGA      = 1,
 602  .orig_video_points     = 8
 603 };
 604
 605 static int __init parse_tag_videotext(const struct tag *tag)
 606 {
 607         screen_info.orig_x            = tag->u.videotext.x;
 608         screen_info.orig_y            = tag->u.videotext.y;
 609         screen_info.orig_video_page   = tag->u.videotext.video_page;
 610         screen_info.orig_video_mode   = tag->u.videotext.video_mode;
 611         screen_info.orig_video_cols   = tag->u.videotext.video_cols;
 612         screen_info.orig_video_ega_bx = tag->u.videotext.video_ega_bx;
 613         screen_info.orig_video_lines  = tag->u.videotext.video_lines;
 614         screen_info.orig_video_isVGA  = tag->u.videotext.video_isvga;
 615         screen_info.orig_video_points = tag->u.videotext.video_points;
 616         return 0;
 617 }
 618
 619 __tagtable(ATAG_VIDEOTEXT, parse_tag_videotext);
 620 #endif
 621
 622 static int __init parse_tag_ramdisk(const struct tag *tag)
 623 {
 624         setup_ramdisk((tag->u.ramdisk.flags & 1) == 0,
 625                       (tag->u.ramdisk.flags & 2) == 0,
 626                       tag->u.ramdisk.start, tag->u.ramdisk.size);
 627         return 0;
 628 }
 629
 630 __tagtable(ATAG_RAMDISK, parse_tag_ramdisk);
 631
 632 static int __init parse_tag_serialnr(const struct tag *tag)
 633 {
 634         system_serial_low = tag->u.serialnr.low;
 635         system_serial_high = tag->u.serialnr.high;
 636         return 0;
 637 }
 638
 639 __tagtable(ATAG_SERIAL, parse_tag_serialnr);
 640
 641 static int __init parse_tag_revision(const struct tag *tag)
 642 {
 643         system_rev = tag->u.revision.rev;
 644         return 0;
 645 }
 646
 647 __tagtable(ATAG_REVISION, parse_tag_revision);
 648
 649 static int __init parse_tag_cmdline(const struct tag *tag)
 650 {
 651 #ifndef CONFIG_CMDLINE_FORCE
 652         strlcpy(default_command_line, tag->u.cmdline.cmdline, COMMAND_LINE_SIZE);
 653 #else
 654         pr_warning("Ignoring tag cmdline (using the default kernel command line)\n");
 655 #endif /* CONFIG_CMDLINE_FORCE */
 656         return 0;
 657 }
 658
 659 __tagtable(ATAG_CMDLINE, parse_tag_cmdline);
 660
 661 /*
 662  * Scan the tag table for this tag, and call its parse function.
 663  * The tag table is built by the linker from all the __tagtable
 664  * declarations.
 665  */
 666 static int __init parse_tag(const struct tag *tag)
 667 {
 668         extern struct tagtable __tagtable_begin, __tagtable_end;
 669         struct tagtable *t;
 670
 671         for (t = &__tagtable_begin; t < &__tagtable_end; t++)
 672                 if (tag->hdr.tag == t->tag) {
 673                         t->parse(tag);
 674                         break;
 675                 }
 676
 677         return t < &__tagtable_end;
 678 }
 679
 680 /*
 681  * Parse all tags in the list, checking both the global and architecture
 682  * specific tag tables.
 683  */
 684 static void __init parse_tags(const struct tag *t)
 685 {
 686         for (; t->hdr.size; t = tag_next(t))
 687                 if (!parse_tag(t))
 688                         printk(KERN_WARNING
 689                                 "Ignoring unrecognised tag 0x%08x\n",
 690                                 t->hdr.tag);
 691 }
 692
 693 /*
 694  * This holds our defaults.
 695  */
 696 static struct init_tags {
 697         struct tag_header hdr1;
 698         struct tag_core   core;
 699         struct tag_header hdr2;
 700         struct tag_mem32  mem;
 701         struct tag_header hdr3;
 702 } init_tags __initdata = {
 703         { tag_size(tag_core), ATAG_CORE },
 704         { 1, PAGE_SIZE, 0xff },
 705         { tag_size(tag_mem32), ATAG_MEM },
 706         { MEM_SIZE, PHYS_OFFSET },
 707         { 0, ATAG_NONE }
 708 };
 709
 710 static int __init customize_machine(void)
 711 {
 712         /* customizes platform devices, or adds new ones */
 713         if (machine_desc->init_machine)
 714                 machine_desc->init_machine();
 715         return 0;
 716 }
 717 arch_initcall(customize_machine);
 718
 719 #ifdef CONFIG_KEXEC
 720 static inline unsigned long long get_total_mem(void)
 721 {
 722         unsigned long total;
 723
 724         total = max_low_pfn - min_low_pfn;
 725         return total << PAGE_SHIFT;
 726 }
 727
 728 /**
 729  * reserve_crashkernel() - reserves memory are for crash kernel
 730  *
 731  * This function reserves memory area given in "crashkernel=" kernel command
 732  * line parameter. The memory reserved is used by a dump capture kernel when
 733  * primary kernel is crashing.
 734  */
 735 static void __init reserve_crashkernel(void)
 736 {
 737         unsigned long long crash_size, crash_base;
 738         unsigned long long total_mem;
 739         int ret;
 740
 741         total_mem = get_total_mem();
 742         ret = parse_crashkernel(boot_command_line, total_mem,
 743                                 &crash_size, &crash_base);
 744         if (ret)
 745                 return;
 746
 747         ret = reserve_bootmem(crash_base, crash_size, BOOTMEM_EXCLUSIVE);
 748         if (ret < 0) {
 749                 printk(KERN_WARNING "crashkernel reservation failed - "
 750                        "memory is in use (0x%lx)\n", (unsigned long)crash_base);
 751                 return;
 752         }
 753
 754         printk(KERN_INFO "Reserving %ldMB of memory at %ldMB "
 755                "for crashkernel (System RAM: %ldMB)\n",
 756                (unsigned long)(crash_size >> 20),
 757                (unsigned long)(crash_base >> 20),
 758                (unsigned long)(total_mem >> 20));
 759
 760         crashk_res.start = crash_base;
 761         crashk_res.end = crash_base + crash_size - 1;
 762         insert_resource(&iomem_resource, &crashk_res);
 763 }
 764 #else
 765 static inline void reserve_crashkernel(void) {}
 766 #endif /* CONFIG_KEXEC */
 767
 768 /*
 769  * Note: elfcorehdr_addr is not just limited to vmcore. It is also used by
 770  * is_kdump_kernel() to determine if we are booting after a panic. Hence
 771  * ifdef it under CONFIG_CRASH_DUMP and not CONFIG_PROC_VMCORE.
 772  */
 773
 774 #ifdef CONFIG_CRASH_DUMP
 775 /*
 776  * elfcorehdr= specifies the location of elf core header stored by the crashed
 777  * kernel. This option will be passed by kexec loader to the capture kernel.
 778  */
 779 static int __init setup_elfcorehdr(char *arg)
 780 {
 781         char *end;
 782
 783         if (!arg)
 784                 return -EINVAL;
 785
 786         elfcorehdr_addr = memparse(arg, &end);
 787         return end > arg ? 0 : -EINVAL;
 788 }
 789 early_param("elfcorehdr", setup_elfcorehdr);
 790 #endif /* CONFIG_CRASH_DUMP */
 791
 792 static void __init squash_mem_tags(struct tag *tag)
 793 {
 794         for (; tag->hdr.size; tag = tag_next(tag))
 795                 if (tag->hdr.tag == ATAG_MEM)
 796                         tag->hdr.tag = ATAG_NONE;
 797 }
 798
 799 void __init setup_arch(char **cmdline_p)
 800 {
 801         struct tag *tags = (struct tag *)&init_tags;
 802         struct machine_desc *mdesc;
 803         char *from = default_command_line;
 804
 805         unwind_init();
 806
 807         setup_processor();
 808         mdesc = setup_machine(machine_arch_type);
 809         machine_desc = mdesc;
 810         machine_name = mdesc->name;
 811
 812         if (mdesc->soft_reboot)
 813                 reboot_setup("s");
 814
 815         if (__atags_pointer)
 816                 tags = phys_to_virt(__atags_pointer);
 817         else if (mdesc->boot_params)
 818                 tags = phys_to_virt(mdesc->boot_params);
 819
 820 #if defined(CONFIG_DEPRECATED_PARAM_STRUCT)
 821         /*
 822          * If we have the old style parameters, convert them to
 823          * a tag list.
 824          */
 825         if (tags->hdr.tag != ATAG_CORE)
 826                 convert_to_tag_list(tags);
 827 #endif
 828         if (tags->hdr.tag != ATAG_CORE)
 829                 tags = (struct tag *)&init_tags;
 830
 831         if (mdesc->fixup)
 832                 mdesc->fixup(mdesc, tags, &from, &meminfo);
 833
 834         if (tags->hdr.tag == ATAG_CORE) {
 835                 if (meminfo.nr_banks != 0)
 836                         squash_mem_tags(tags);
 837                 save_atags(tags);
 838                 parse_tags(tags);
 839         }
 840
 841         init_mm.start_code = (unsigned long) _text;
 842         init_mm.end_code   = (unsigned long) _etext;
 843         init_mm.end_data   = (unsigned long) _edata;
 844         init_mm.brk        = (unsigned long) _end;
 845
 846         /* parse_early_param needs a boot_command_line */
 847         strlcpy(boot_command_line, from, COMMAND_LINE_SIZE);
 848
 849         /* populate cmd_line too for later use, preserving boot_command_line */
 850         strlcpy(cmd_line, boot_command_line, COMMAND_LINE_SIZE);
 851         *cmdline_p = cmd_line;
 852
 853         parse_early_param();
 854
 855         arm_memblock_init(&meminfo, mdesc);
 856
 857         paging_init(mdesc);
 858         request_standard_resources(mdesc);
 859
 860 #ifdef CONFIG_SMP
 861         if (is_smp())
 862                 smp_init_cpus();
 863 #endif
 864         reserve_crashkernel();
 865
 866         cpu_init();
 867         tcm_init();
 868
 869 #ifdef CONFIG_MULTI_IRQ_HANDLER
 870         handle_arch_irq = mdesc->handle_irq;
 871 #endif
 872
 873 #ifdef CONFIG_VT
 874 #if defined(CONFIG_VGA_CONSOLE)
 875         conswitchp = &vga_con;
 876 #elif defined(CONFIG_DUMMY_CONSOLE)
 877         conswitchp = &dummy_con;
 878 #endif
 879 #endif
 880         early_trap_init();
 881
 882         if (mdesc->init_early)
 883                 mdesc->init_early();
 884 }
 885
 886
 887 static int __init topology_init(void)
 888 {
 889         int cpu;
 890
 891         for_each_possible_cpu(cpu) {
 892                 struct cpuinfo_arm *cpuinfo = &per_cpu(cpu_data, cpu);
 893                 cpuinfo->cpu.hotpluggable = 1;
 894                 register_cpu(&cpuinfo->cpu, cpu);
 895         }
 896
 897         return 0;
 898 }
 899 subsys_initcall(topology_init);
 900
 901 #ifdef CONFIG_HAVE_PROC_CPU
 902 static int __init proc_cpu_init(void)
 903 {
 904         struct proc_dir_entry *res;
 905
 906         res = proc_mkdir("cpu", NULL);
 907         if (!res)
 908                 return -ENOMEM;
 909         return 0;
 910 }
 911 fs_initcall(proc_cpu_init);
 912 #endif
 913
 914 static const char *hwcap_str[] = {
 915         "swp",
 916         "half",
 917         "thumb",
 918         "26bit",
 919         "fastmult",
 920         "fpa",
 921         "vfp",
 922         "edsp",
 923         "java",
 924         "iwmmxt",
 925         "crunch",
 926         "thumbee",
 927         "neon",
 928         "vfpv3",
 929         "vfpv3d16",
 930         NULL
 931 };
 932
 933 static int c_show(struct seq_file *m, void *v)
 934 {
 935         int i;
 936
 937         seq_printf(m, "Processor\t: %s rev %d (%s)\n",
 938                    cpu_name, read_cpuid_id() & 15, elf_platform);
 939
 940 #if defined(CONFIG_SMP)
 941         for_each_online_cpu(i) {
 942                 /*
 943                  * glibc reads /proc/cpuinfo to determine the number of
 944                  * online processors, looking for lines beginning with
 945                  * "processor".  Give glibc what it expects.
 946                  */
 947                 seq_printf(m, "processor\t: %d\n", i);
 948                 seq_printf(m, "BogoMIPS\t: %lu.%02lu\n\n",
 949                            per_cpu(cpu_data, i).loops_per_jiffy / (500000UL/HZ),
 950                            (per_cpu(cpu_data, i).loops_per_jiffy / (5000UL/HZ)) % 100);
 951         }
 952 #else /* CONFIG_SMP */
 953         seq_printf(m, "BogoMIPS\t: %lu.%02lu\n",
 954                    loops_per_jiffy / (500000/HZ),
 955                    (loops_per_jiffy / (5000/HZ)) % 100);
 956 #endif
 957
 958         /* dump out the processor features */
 959         seq_puts(m, "Features\t: ");
 960
 961         for (i = 0; hwcap_str[i]; i++)
 962                 if (elf_hwcap & (1 << i))
 963                         seq_printf(m, "%s ", hwcap_str[i]);
 964
 965         seq_printf(m, "\nCPU implementer\t: 0x%02x\n", read_cpuid_id() >> 24);
 966         seq_printf(m, "CPU architecture: %s\n", proc_arch[cpu_architecture()]);
 967
 968         if ((read_cpuid_id() & 0x0008f000) == 0x00000000) {
 969                 /* pre-ARM7 */
 970                 seq_printf(m, "CPU part\t: %07x\n", read_cpuid_id() >> 4);
 971         } else {
 972                 if ((read_cpuid_id() & 0x0008f000) == 0x00007000) {
 973                         /* ARM7 */
 974                         seq_printf(m, "CPU variant\t: 0x%02x\n",
 975                                    (read_cpuid_id() >> 16) & 127);
 976                 } else {
 977                         /* post-ARM7 */
 978                         seq_printf(m, "CPU variant\t: 0x%x\n",
 979                                    (read_cpuid_id() >> 20) & 15);
 980                 }
 981                 seq_printf(m, "CPU part\t: 0x%03x\n",
 982                            (read_cpuid_id() >> 4) & 0xfff);
 983         }
 984         seq_printf(m, "CPU revision\t: %d\n", read_cpuid_id() & 15);
 985
 986         seq_puts(m, "\n");
 987
 988         seq_printf(m, "Hardware\t: %s\n", machine_name);
 989         seq_printf(m, "Revision\t: %04x\n", system_rev);
 990         seq_printf(m, "Serial\t\t: %08x%08x\n",
 991                    system_serial_high, system_serial_low);
 992
 993         return 0;
 994 }
 995
 996 static void *c_start(struct seq_file *m, loff_t *pos)
 997 {
 998         return *pos < 1 ? (void *)1 : NULL;
 999 }
1000
1001 static void *c_next(struct seq_file *m, void *v, loff_t *pos)
1002 {
1003         ++*pos;
1004         return NULL;
1005 }
1006
1007 static void c_stop(struct seq_file *m, void *v)
1008 {
1009 }
1010
1011 const struct seq_operations cpuinfo_op = {
1012         .start  = c_start,
1013         .next   = c_next,
1014         .stop   = c_stop,
1015         .show   = c_show
1016 };