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