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