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