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