Merge git://git.kernel.org/pub/scm/linux/kernel/git/paulus/powerpc-merge
[linux-2.6] / 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 };