projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
ARM: S3C64XX: Fix keypad setup to configure correct number of rows
[GitHub/mt8127/android_kernel_alcatel_ttab.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 extern struct machine_desc *lookup_machine_type(unsigned int);
312
313 static void __init feat_v6_fixup(void)
314 {
315 int id = read_cpuid_id();
316
317 if ((id & 0xff0f0000) != 0x41070000)
318 return;
319
320 /*
321 * HWCAP_TLS is available only on 1136 r1p0 and later,
322 * see also kuser_get_tls_init.
323 */
324 if ((((id >> 4) & 0xfff) == 0xb36) && (((id >> 20) & 3) == 0))
325 elf_hwcap &= ~HWCAP_TLS;
326 }
327
328 static void __init setup_processor(void)
329 {
330 struct proc_info_list *list;
331
332 /*
333 * locate processor in the list of supported processor
334 * types. The linker builds this table for us from the
335 * entries in arch/arm/mm/proc-*.S
336 */
337 list = lookup_processor_type(read_cpuid_id());
338 if (!list) {
339 printk("CPU configuration botched (ID %08x), unable "
340 "to continue.\n", read_cpuid_id());
341 while (1);
342 }
343
344 cpu_name = list->cpu_name;
345
346 #ifdef MULTI_CPU
347 processor = *list->proc;
348 #endif
349 #ifdef MULTI_TLB
350 cpu_tlb = *list->tlb;
351 #endif
352 #ifdef MULTI_USER
353 cpu_user = *list->user;
354 #endif
355 #ifdef MULTI_CACHE
356 cpu_cache = *list->cache;
357 #endif
358
359 printk("CPU: %s [%08x] revision %d (ARMv%s), cr=%08lx\n",
360 cpu_name, read_cpuid_id(), read_cpuid_id() & 15,
361 proc_arch[cpu_architecture()], cr_alignment);
362
363 sprintf(init_utsname()->machine, "%s%c", list->arch_name, ENDIANNESS);
364 sprintf(elf_platform, "%s%c", list->elf_name, ENDIANNESS);
365 elf_hwcap = list->elf_hwcap;
366 #ifndef CONFIG_ARM_THUMB
367 elf_hwcap &= ~HWCAP_THUMB;
368 #endif
369
370 feat_v6_fixup();
371
372 cacheid_init();
373 cpu_proc_init();
374 }
375
376 /*
377 * cpu_init - initialise one CPU.
378 *
379 * cpu_init sets up the per-CPU stacks.
380 */
381 void cpu_init(void)
382 {
383 unsigned int cpu = smp_processor_id();
384 struct stack *stk = &stacks[cpu];
385
386 if (cpu >= NR_CPUS) {
387 printk(KERN_CRIT "CPU%u: bad primary CPU number\n", cpu);
388 BUG();
389 }
390
391 /*
392 * Define the placement constraint for the inline asm directive below.
393 * In Thumb-2, msr with an immediate value is not allowed.
394 */
395 #ifdef CONFIG_THUMB2_KERNEL
396 #define PLC "r"
397 #else
398 #define PLC "I"
399 #endif
400
401 /*
402 * setup stacks for re-entrant exception handlers
403 */
404 __asm__ (
405 "msr cpsr_c, %1\n\t"
406 "add r14, %0, %2\n\t"
407 "mov sp, r14\n\t"
408 "msr cpsr_c, %3\n\t"
409 "add r14, %0, %4\n\t"
410 "mov sp, r14\n\t"
411 "msr cpsr_c, %5\n\t"
412 "add r14, %0, %6\n\t"
413 "mov sp, r14\n\t"
414 "msr cpsr_c, %7"
415 :
416 : "r" (stk),
417 PLC (PSR_F_BIT | PSR_I_BIT | IRQ_MODE),
418 "I" (offsetof(struct stack, irq[0])),
419 PLC (PSR_F_BIT | PSR_I_BIT | ABT_MODE),
420 "I" (offsetof(struct stack, abt[0])),
421 PLC (PSR_F_BIT | PSR_I_BIT | UND_MODE),
422 "I" (offsetof(struct stack, und[0])),
423 PLC (PSR_F_BIT | PSR_I_BIT | SVC_MODE)
424 : "r14");
425 }
426
427 static struct machine_desc * __init setup_machine(unsigned int nr)
428 {
429 struct machine_desc *list;
430
431 /*
432 * locate machine in the list of supported machines.
433 */
434 list = lookup_machine_type(nr);
435 if (!list) {
436 printk("Machine configuration botched (nr %d), unable "
437 "to continue.\n", nr);
438 while (1);
439 }
440
441 printk("Machine: %s\n", list->name);
442
443 return list;
444 }
445
446 static int __init arm_add_memory(unsigned long start, unsigned long size)
447 {
448 struct membank *bank = &meminfo.bank[meminfo.nr_banks];
449
450 if (meminfo.nr_banks >= NR_BANKS) {
451 printk(KERN_CRIT "NR_BANKS too low, "
452 "ignoring memory at %#lx\n", start);
453 return -EINVAL;
454 }
455
456 /*
457 * Ensure that start/size are aligned to a page boundary.
458 * Size is appropriately rounded down, start is rounded up.
459 */
460 size -= start & ~PAGE_MASK;
461 bank->start = PAGE_ALIGN(start);
462 bank->size = size & PAGE_MASK;
463
464 /*
465 * Check whether this memory region has non-zero size or
466 * invalid node number.
467 */
468 if (bank->size == 0)
469 return -EINVAL;
470
471 meminfo.nr_banks++;
472 return 0;
473 }
474
475 /*
476 * Pick out the memory size. We look for mem=size@start,
477 * where start and size are "size[KkMm]"
478 */
479 static int __init early_mem(char *p)
480 {
481 static int usermem __initdata = 0;
482 unsigned long size, start;
483 char *endp;
484
485 /*
486 * If the user specifies memory size, we
487 * blow away any automatically generated
488 * size.
489 */
490 if (usermem == 0) {
491 usermem = 1;
492 meminfo.nr_banks = 0;
493 }
494
495 start = PHYS_OFFSET;
496 size = memparse(p, &endp);
497 if (*endp == '@')
498 start = memparse(endp + 1, NULL);
499
500 arm_add_memory(start, size);
501
502 return 0;
503 }
504 early_param("mem", early_mem);
505
506 static void __init
507 setup_ramdisk(int doload, int prompt, int image_start, unsigned int rd_sz)
508 {
509 #ifdef CONFIG_BLK_DEV_RAM
510 extern int rd_size, rd_image_start, rd_prompt, rd_doload;
511
512 rd_image_start = image_start;
513 rd_prompt = prompt;
514 rd_doload = doload;
515
516 if (rd_sz)
517 rd_size = rd_sz;
518 #endif
519 }
520
521 static void __init request_standard_resources(struct machine_desc *mdesc)
522 {
523 struct memblock_region *region;
524 struct resource *res;
525
526 kernel_code.start = virt_to_phys(_text);
527 kernel_code.end = virt_to_phys(_etext - 1);
528 kernel_data.start = virt_to_phys(_sdata);
529 kernel_data.end = virt_to_phys(_end - 1);
530
531 for_each_memblock(memory, region) {
532 res = alloc_bootmem_low(sizeof(*res));
533 res->name = "System RAM";
534 res->start = __pfn_to_phys(memblock_region_memory_base_pfn(region));
535 res->end = __pfn_to_phys(memblock_region_memory_end_pfn(region)) - 1;
536 res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
537
538 request_resource(&iomem_resource, res);
539
540 if (kernel_code.start >= res->start &&
541 kernel_code.end <= res->end)
542 request_resource(res, &kernel_code);
543 if (kernel_data.start >= res->start &&
544 kernel_data.end <= res->end)
545 request_resource(res, &kernel_data);
546 }
547
548 if (mdesc->video_start) {
549 video_ram.start = mdesc->video_start;
550 video_ram.end = mdesc->video_end;
551 request_resource(&iomem_resource, &video_ram);
552 }
553
554 /*
555 * Some machines don't have the possibility of ever
556 * possessing lp0, lp1 or lp2
557 */
558 if (mdesc->reserve_lp0)
559 request_resource(&ioport_resource, &lp0);
560 if (mdesc->reserve_lp1)
561 request_resource(&ioport_resource, &lp1);
562 if (mdesc->reserve_lp2)
563 request_resource(&ioport_resource, &lp2);
564 }
565
566 /*
567 * Tag parsing.
568 *
569 * This is the new way of passing data to the kernel at boot time. Rather
570 * than passing a fixed inflexible structure to the kernel, we pass a list
571 * of variable-sized tags to the kernel. The first tag must be a ATAG_CORE
572 * tag for the list to be recognised (to distinguish the tagged list from
573 * a param_struct). The list is terminated with a zero-length tag (this tag
574 * is not parsed in any way).
575 */
576 static int __init parse_tag_core(const struct tag *tag)
577 {
578 if (tag->hdr.size > 2) {
579 if ((tag->u.core.flags & 1) == 0)
580 root_mountflags &= ~MS_RDONLY;
581 ROOT_DEV = old_decode_dev(tag->u.core.rootdev);
582 }
583 return 0;
584 }
585
586 __tagtable(ATAG_CORE, parse_tag_core);
587
588 static int __init parse_tag_mem32(const struct tag *tag)
589 {
590 return arm_add_memory(tag->u.mem.start, tag->u.mem.size);
591 }
592
593 __tagtable(ATAG_MEM, parse_tag_mem32);
594
595 #if defined(CONFIG_VGA_CONSOLE) || defined(CONFIG_DUMMY_CONSOLE)
596 struct screen_info screen_info = {
597 .orig_video_lines = 30,
598 .orig_video_cols = 80,
599 .orig_video_mode = 0,
600 .orig_video_ega_bx = 0,
601 .orig_video_isVGA = 1,
602 .orig_video_points = 8
603 };
604
605 static int __init parse_tag_videotext(const struct tag *tag)
606 {
607 screen_info.orig_x = tag->u.videotext.x;
608 screen_info.orig_y = tag->u.videotext.y;
609 screen_info.orig_video_page = tag->u.videotext.video_page;
610 screen_info.orig_video_mode = tag->u.videotext.video_mode;
611 screen_info.orig_video_cols = tag->u.videotext.video_cols;
612 screen_info.orig_video_ega_bx = tag->u.videotext.video_ega_bx;
613 screen_info.orig_video_lines = tag->u.videotext.video_lines;
614 screen_info.orig_video_isVGA = tag->u.videotext.video_isvga;
615 screen_info.orig_video_points = tag->u.videotext.video_points;
616 return 0;
617 }
618
619 __tagtable(ATAG_VIDEOTEXT, parse_tag_videotext);
620 #endif
621
622 static int __init parse_tag_ramdisk(const struct tag *tag)
623 {
624 setup_ramdisk((tag->u.ramdisk.flags & 1) == 0,
625 (tag->u.ramdisk.flags & 2) == 0,
626 tag->u.ramdisk.start, tag->u.ramdisk.size);
627 return 0;
628 }
629
630 __tagtable(ATAG_RAMDISK, parse_tag_ramdisk);
631
632 static int __init parse_tag_serialnr(const struct tag *tag)
633 {
634 system_serial_low = tag->u.serialnr.low;
635 system_serial_high = tag->u.serialnr.high;
636 return 0;
637 }
638
639 __tagtable(ATAG_SERIAL, parse_tag_serialnr);
640
641 static int __init parse_tag_revision(const struct tag *tag)
642 {
643 system_rev = tag->u.revision.rev;
644 return 0;
645 }
646
647 __tagtable(ATAG_REVISION, parse_tag_revision);
648
649 static int __init parse_tag_cmdline(const struct tag *tag)
650 {
651 #ifndef CONFIG_CMDLINE_FORCE
652 strlcpy(default_command_line, tag->u.cmdline.cmdline, COMMAND_LINE_SIZE);
653 #else
654 pr_warning("Ignoring tag cmdline (using the default kernel command line)\n");
655 #endif /* CONFIG_CMDLINE_FORCE */
656 return 0;
657 }
658
659 __tagtable(ATAG_CMDLINE, parse_tag_cmdline);
660
661 /*
662 * Scan the tag table for this tag, and call its parse function.
663 * The tag table is built by the linker from all the __tagtable
664 * declarations.
665 */
666 static int __init parse_tag(const struct tag *tag)
667 {
668 extern struct tagtable __tagtable_begin, __tagtable_end;
669 struct tagtable *t;
670
671 for (t = &__tagtable_begin; t < &__tagtable_end; t++)
672 if (tag->hdr.tag == t->tag) {
673 t->parse(tag);
674 break;
675 }
676
677 return t < &__tagtable_end;
678 }
679
680 /*
681 * Parse all tags in the list, checking both the global and architecture
682 * specific tag tables.
683 */
684 static void __init parse_tags(const struct tag *t)
685 {
686 for (; t->hdr.size; t = tag_next(t))
687 if (!parse_tag(t))
688 printk(KERN_WARNING
689 "Ignoring unrecognised tag 0x%08x\n",
690 t->hdr.tag);
691 }
692
693 /*
694 * This holds our defaults.
695 */
696 static struct init_tags {
697 struct tag_header hdr1;
698 struct tag_core core;
699 struct tag_header hdr2;
700 struct tag_mem32 mem;
701 struct tag_header hdr3;
702 } init_tags __initdata = {
703 { tag_size(tag_core), ATAG_CORE },
704 { 1, PAGE_SIZE, 0xff },
705 { tag_size(tag_mem32), ATAG_MEM },
706 { MEM_SIZE, PHYS_OFFSET },
707 { 0, ATAG_NONE }
708 };
709
710 static int __init customize_machine(void)
711 {
712 /* customizes platform devices, or adds new ones */
713 if (machine_desc->init_machine)
714 machine_desc->init_machine();
715 return 0;
716 }
717 arch_initcall(customize_machine);
718
719 #ifdef CONFIG_KEXEC
720 static inline unsigned long long get_total_mem(void)
721 {
722 unsigned long total;
723
724 total = max_low_pfn - min_low_pfn;
725 return total << PAGE_SHIFT;
726 }
727
728 /**
729 * reserve_crashkernel() - reserves memory are for crash kernel
730 *
731 * This function reserves memory area given in "crashkernel=" kernel command
732 * line parameter. The memory reserved is used by a dump capture kernel when
733 * primary kernel is crashing.
734 */
735 static void __init reserve_crashkernel(void)
736 {
737 unsigned long long crash_size, crash_base;
738 unsigned long long total_mem;
739 int ret;
740
741 total_mem = get_total_mem();
742 ret = parse_crashkernel(boot_command_line, total_mem,
743 &crash_size, &crash_base);
744 if (ret)
745 return;
746
747 ret = reserve_bootmem(crash_base, crash_size, BOOTMEM_EXCLUSIVE);
748 if (ret < 0) {
749 printk(KERN_WARNING "crashkernel reservation failed - "
750 "memory is in use (0x%lx)\n", (unsigned long)crash_base);
751 return;
752 }
753
754 printk(KERN_INFO "Reserving %ldMB of memory at %ldMB "
755 "for crashkernel (System RAM: %ldMB)\n",
756 (unsigned long)(crash_size >> 20),
757 (unsigned long)(crash_base >> 20),
758 (unsigned long)(total_mem >> 20));
759
760 crashk_res.start = crash_base;
761 crashk_res.end = crash_base + crash_size - 1;
762 insert_resource(&iomem_resource, &crashk_res);
763 }
764 #else
765 static inline void reserve_crashkernel(void) {}
766 #endif /* CONFIG_KEXEC */
767
768 /*
769 * Note: elfcorehdr_addr is not just limited to vmcore. It is also used by
770 * is_kdump_kernel() to determine if we are booting after a panic. Hence
771 * ifdef it under CONFIG_CRASH_DUMP and not CONFIG_PROC_VMCORE.
772 */
773
774 #ifdef CONFIG_CRASH_DUMP
775 /*
776 * elfcorehdr= specifies the location of elf core header stored by the crashed
777 * kernel. This option will be passed by kexec loader to the capture kernel.
778 */
779 static int __init setup_elfcorehdr(char *arg)
780 {
781 char *end;
782
783 if (!arg)
784 return -EINVAL;
785
786 elfcorehdr_addr = memparse(arg, &end);
787 return end > arg ? 0 : -EINVAL;
788 }
789 early_param("elfcorehdr", setup_elfcorehdr);
790 #endif /* CONFIG_CRASH_DUMP */
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 unwind_init();
806
807 setup_processor();
808 mdesc = setup_machine(machine_arch_type);
809 machine_desc = mdesc;
810 machine_name = mdesc->name;
811
812 if (mdesc->soft_reboot)
813 reboot_setup("s");
814
815 if (__atags_pointer)
816 tags = phys_to_virt(__atags_pointer);
817 else if (mdesc->boot_params)
818 tags = phys_to_virt(mdesc->boot_params);
819
820 #if defined(CONFIG_DEPRECATED_PARAM_STRUCT)
821 /*
822 * If we have the old style parameters, convert them to
823 * a tag list.
824 */
825 if (tags->hdr.tag != ATAG_CORE)
826 convert_to_tag_list(tags);
827 #endif
828 if (tags->hdr.tag != ATAG_CORE)
829 tags = (struct tag *)&init_tags;
830
831 if (mdesc->fixup)
832 mdesc->fixup(mdesc, tags, &from, &meminfo);
833
834 if (tags->hdr.tag == ATAG_CORE) {
835 if (meminfo.nr_banks != 0)
836 squash_mem_tags(tags);
837 save_atags(tags);
838 parse_tags(tags);
839 }
840
841 init_mm.start_code = (unsigned long) _text;
842 init_mm.end_code = (unsigned long) _etext;
843 init_mm.end_data = (unsigned long) _edata;
844 init_mm.brk = (unsigned long) _end;
845
846 /* parse_early_param needs a boot_command_line */
847 strlcpy(boot_command_line, from, COMMAND_LINE_SIZE);
848
849 /* populate cmd_line too for later use, preserving boot_command_line */
850 strlcpy(cmd_line, boot_command_line, COMMAND_LINE_SIZE);
851 *cmdline_p = cmd_line;
852
853 parse_early_param();
854
855 arm_memblock_init(&meminfo, mdesc);
856
857 paging_init(mdesc);
858 request_standard_resources(mdesc);
859
860 #ifdef CONFIG_SMP
861 if (is_smp())
862 smp_init_cpus();
863 #endif
864 reserve_crashkernel();
865
866 cpu_init();
867 tcm_init();
868
869 #ifdef CONFIG_MULTI_IRQ_HANDLER
870 handle_arch_irq = mdesc->handle_irq;
871 #endif
872
873 #ifdef CONFIG_VT
874 #if defined(CONFIG_VGA_CONSOLE)
875 conswitchp = &vga_con;
876 #elif defined(CONFIG_DUMMY_CONSOLE)
877 conswitchp = &dummy_con;
878 #endif
879 #endif
880 early_trap_init();
881
882 if (mdesc->init_early)
883 mdesc->init_early();
884 }
885
886
887 static int __init topology_init(void)
888 {
889 int cpu;
890
891 for_each_possible_cpu(cpu) {
892 struct cpuinfo_arm *cpuinfo = &per_cpu(cpu_data, cpu);
893 cpuinfo->cpu.hotpluggable = 1;
894 register_cpu(&cpuinfo->cpu, cpu);
895 }
896
897 return 0;
898 }
899 subsys_initcall(topology_init);
900
901 #ifdef CONFIG_HAVE_PROC_CPU
902 static int __init proc_cpu_init(void)
903 {
904 struct proc_dir_entry *res;
905
906 res = proc_mkdir("cpu", NULL);
907 if (!res)
908 return -ENOMEM;
909 return 0;
910 }
911 fs_initcall(proc_cpu_init);
912 #endif
913
914 static const char *hwcap_str[] = {
915 "swp",
916 "half",
917 "thumb",
918 "26bit",
919 "fastmult",
920 "fpa",
921 "vfp",
922 "edsp",
923 "java",
924 "iwmmxt",
925 "crunch",
926 "thumbee",
927 "neon",
928 "vfpv3",
929 "vfpv3d16",
930 NULL
931 };
932
933 static int c_show(struct seq_file *m, void *v)
934 {
935 int i;
936
937 seq_printf(m, "Processor\t: %s rev %d (%s)\n",
938 cpu_name, read_cpuid_id() & 15, elf_platform);
939
940 #if defined(CONFIG_SMP)
941 for_each_online_cpu(i) {
942 /*
943 * glibc reads /proc/cpuinfo to determine the number of
944 * online processors, looking for lines beginning with
945 * "processor". Give glibc what it expects.
946 */
947 seq_printf(m, "processor\t: %d\n", i);
948 seq_printf(m, "BogoMIPS\t: %lu.%02lu\n\n",
949 per_cpu(cpu_data, i).loops_per_jiffy / (500000UL/HZ),
950 (per_cpu(cpu_data, i).loops_per_jiffy / (5000UL/HZ)) % 100);
951 }
952 #else /* CONFIG_SMP */
953 seq_printf(m, "BogoMIPS\t: %lu.%02lu\n",
954 loops_per_jiffy / (500000/HZ),
955 (loops_per_jiffy / (5000/HZ)) % 100);
956 #endif
957
958 /* dump out the processor features */
959 seq_puts(m, "Features\t: ");
960
961 for (i = 0; hwcap_str[i]; i++)
962 if (elf_hwcap & (1 << i))
963 seq_printf(m, "%s ", hwcap_str[i]);
964
965 seq_printf(m, "\nCPU implementer\t: 0x%02x\n", read_cpuid_id() >> 24);
966 seq_printf(m, "CPU architecture: %s\n", proc_arch[cpu_architecture()]);
967
968 if ((read_cpuid_id() & 0x0008f000) == 0x00000000) {
969 /* pre-ARM7 */
970 seq_printf(m, "CPU part\t: %07x\n", read_cpuid_id() >> 4);
971 } else {
972 if ((read_cpuid_id() & 0x0008f000) == 0x00007000) {
973 /* ARM7 */
974 seq_printf(m, "CPU variant\t: 0x%02x\n",
975 (read_cpuid_id() >> 16) & 127);
976 } else {
977 /* post-ARM7 */
978 seq_printf(m, "CPU variant\t: 0x%x\n",
979 (read_cpuid_id() >> 20) & 15);
980 }
981 seq_printf(m, "CPU part\t: 0x%03x\n",
982 (read_cpuid_id() >> 4) & 0xfff);
983 }
984 seq_printf(m, "CPU revision\t: %d\n", read_cpuid_id() & 15);
985
986 seq_puts(m, "\n");
987
988 seq_printf(m, "Hardware\t: %s\n", machine_name);
989 seq_printf(m, "Revision\t: %04x\n", system_rev);
990 seq_printf(m, "Serial\t\t: %08x%08x\n",
991 system_serial_high, system_serial_low);
992
993 return 0;
994 }
995
996 static void *c_start(struct seq_file *m, loff_t *pos)
997 {
998 return *pos < 1 ? (void *)1 : NULL;
999 }
1000
1001 static void *c_next(struct seq_file *m, void *v, loff_t *pos)
1002 {
1003 ++*pos;
1004 return NULL;
1005 }
1006
1007 static void c_stop(struct seq_file *m, void *v)
1008 {
1009 }
1010
1011 const struct seq_operations cpuinfo_op = {
1012 .start = c_start,
1013 .next = c_next,
1014 .stop = c_stop,
1015 .show = c_show
1016 };
kernel source for telekom puls (alcatel/mediatek)