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