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