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