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