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