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