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