projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'fix' of git://git.kernel.org/pub/scm/linux/kernel/git/ycmiao/pxa-linux...
[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/root_dev.h>
23 #include <linux/cpu.h>
24 #include <linux/interrupt.h>
25 #include <linux/smp.h>
26 #include <linux/fs.h>
27
28 #include <asm/cpu.h>
29 #include <asm/cputype.h>
30 #include <asm/elf.h>
31 #include <asm/procinfo.h>
32 #include <asm/sections.h>
33 #include <asm/setup.h>
34 #include <asm/mach-types.h>
35 #include <asm/cacheflush.h>
36 #include <asm/cachetype.h>
37 #include <asm/tlbflush.h>
38
39 #include <asm/mach/arch.h>
40 #include <asm/mach/irq.h>
41 #include <asm/mach/time.h>
42 #include <asm/traps.h>
43 #include <asm/unwind.h>
44
45 #include "compat.h"
46 #include "atags.h"
47
48 #ifndef MEM_SIZE
49 #define MEM_SIZE (16*1024*1024)
50 #endif
51
52 #if defined(CONFIG_FPE_NWFPE) || defined(CONFIG_FPE_FASTFPE)
53 char fpe_type[8];
54
55 static int __init fpe_setup(char *line)
56 {
57 memcpy(fpe_type, line, 8);
58 return 1;
59 }
60
61 __setup("fpe=", fpe_setup);
62 #endif
63
64 extern void paging_init(struct machine_desc *desc);
65 extern void reboot_setup(char *str);
66
67 unsigned int processor_id;
68 EXPORT_SYMBOL(processor_id);
69 unsigned int __machine_arch_type;
70 EXPORT_SYMBOL(__machine_arch_type);
71 unsigned int cacheid;
72 EXPORT_SYMBOL(cacheid);
73
74 unsigned int __atags_pointer __initdata;
75
76 unsigned int system_rev;
77 EXPORT_SYMBOL(system_rev);
78
79 unsigned int system_serial_low;
80 EXPORT_SYMBOL(system_serial_low);
81
82 unsigned int system_serial_high;
83 EXPORT_SYMBOL(system_serial_high);
84
85 unsigned int elf_hwcap;
86 EXPORT_SYMBOL(elf_hwcap);
87
88
89 #ifdef MULTI_CPU
90 struct processor processor;
91 #endif
92 #ifdef MULTI_TLB
93 struct cpu_tlb_fns cpu_tlb;
94 #endif
95 #ifdef MULTI_USER
96 struct cpu_user_fns cpu_user;
97 #endif
98 #ifdef MULTI_CACHE
99 struct cpu_cache_fns cpu_cache;
100 #endif
101 #ifdef CONFIG_OUTER_CACHE
102 struct outer_cache_fns outer_cache;
103 #endif
104
105 struct stack {
106 u32 irq[3];
107 u32 abt[3];
108 u32 und[3];
109 } ____cacheline_aligned;
110
111 static struct stack stacks[NR_CPUS];
112
113 char elf_platform[ELF_PLATFORM_SIZE];
114 EXPORT_SYMBOL(elf_platform);
115
116 static const char *cpu_name;
117 static const char *machine_name;
118 static char __initdata command_line[COMMAND_LINE_SIZE];
119
120 static char default_command_line[COMMAND_LINE_SIZE] __initdata = CONFIG_CMDLINE;
121 static union { char c[4]; unsigned long l; } endian_test __initdata = { { 'l', '?', '?', 'b' } };
122 #define ENDIANNESS ((char)endian_test.l)
123
124 DEFINE_PER_CPU(struct cpuinfo_arm, cpu_data);
125
126 /*
127 * Standard memory resources
128 */
129 static struct resource mem_res[] = {
130 {
131 .name = "Video RAM",
132 .start = 0,
133 .end = 0,
134 .flags = IORESOURCE_MEM
135 },
136 {
137 .name = "Kernel text",
138 .start = 0,
139 .end = 0,
140 .flags = IORESOURCE_MEM
141 },
142 {
143 .name = "Kernel data",
144 .start = 0,
145 .end = 0,
146 .flags = IORESOURCE_MEM
147 }
148 };
149
150 #define video_ram mem_res[0]
151 #define kernel_code mem_res[1]
152 #define kernel_data mem_res[2]
153
154 static struct resource io_res[] = {
155 {
156 .name = "reserved",
157 .start = 0x3bc,
158 .end = 0x3be,
159 .flags = IORESOURCE_IO | IORESOURCE_BUSY
160 },
161 {
162 .name = "reserved",
163 .start = 0x378,
164 .end = 0x37f,
165 .flags = IORESOURCE_IO | IORESOURCE_BUSY
166 },
167 {
168 .name = "reserved",
169 .start = 0x278,
170 .end = 0x27f,
171 .flags = IORESOURCE_IO | IORESOURCE_BUSY
172 }
173 };
174
175 #define lp0 io_res[0]
176 #define lp1 io_res[1]
177 #define lp2 io_res[2]
178
179 static const char *proc_arch[] = {
180 "undefined/unknown",
181 "3",
182 "4",
183 "4T",
184 "5",
185 "5T",
186 "5TE",
187 "5TEJ",
188 "6TEJ",
189 "7",
190 "?(11)",
191 "?(12)",
192 "?(13)",
193 "?(14)",
194 "?(15)",
195 "?(16)",
196 "?(17)",
197 };
198
199 int cpu_architecture(void)
200 {
201 int cpu_arch;
202
203 if ((read_cpuid_id() & 0x0008f000) == 0) {
204 cpu_arch = CPU_ARCH_UNKNOWN;
205 } else if ((read_cpuid_id() & 0x0008f000) == 0x00007000) {
206 cpu_arch = (read_cpuid_id() & (1 << 23)) ? CPU_ARCH_ARMv4T : CPU_ARCH_ARMv3;
207 } else if ((read_cpuid_id() & 0x00080000) == 0x00000000) {
208 cpu_arch = (read_cpuid_id() >> 16) & 7;
209 if (cpu_arch)
210 cpu_arch += CPU_ARCH_ARMv3;
211 } else if ((read_cpuid_id() & 0x000f0000) == 0x000f0000) {
212 unsigned int mmfr0;
213
214 /* Revised CPUID format. Read the Memory Model Feature
215 * Register 0 and check for VMSAv7 or PMSAv7 */
216 asm("mrc p15, 0, %0, c0, c1, 4"
217 : "=r" (mmfr0));
218 if ((mmfr0 & 0x0000000f) == 0x00000003 ||
219 (mmfr0 & 0x000000f0) == 0x00000030)
220 cpu_arch = CPU_ARCH_ARMv7;
221 else if ((mmfr0 & 0x0000000f) == 0x00000002 ||
222 (mmfr0 & 0x000000f0) == 0x00000020)
223 cpu_arch = CPU_ARCH_ARMv6;
224 else
225 cpu_arch = CPU_ARCH_UNKNOWN;
226 } else
227 cpu_arch = CPU_ARCH_UNKNOWN;
228
229 return cpu_arch;
230 }
231
232 static void __init cacheid_init(void)
233 {
234 unsigned int cachetype = read_cpuid_cachetype();
235 unsigned int arch = cpu_architecture();
236
237 if (arch >= CPU_ARCH_ARMv7) {
238 cacheid = CACHEID_VIPT_NONALIASING;
239 if ((cachetype & (3 << 14)) == 1 << 14)
240 cacheid |= CACHEID_ASID_TAGGED;
241 } else if (arch >= CPU_ARCH_ARMv6) {
242 if (cachetype & (1 << 23))
243 cacheid = CACHEID_VIPT_ALIASING;
244 else
245 cacheid = CACHEID_VIPT_NONALIASING;
246 } else {
247 cacheid = CACHEID_VIVT;
248 }
249
250 printk("CPU: %s data cache, %s instruction cache\n",
251 cache_is_vivt() ? "VIVT" :
252 cache_is_vipt_aliasing() ? "VIPT aliasing" :
253 cache_is_vipt_nonaliasing() ? "VIPT nonaliasing" : "unknown",
254 cache_is_vivt() ? "VIVT" :
255 icache_is_vivt_asid_tagged() ? "VIVT ASID tagged" :
256 cache_is_vipt_aliasing() ? "VIPT aliasing" :
257 cache_is_vipt_nonaliasing() ? "VIPT nonaliasing" : "unknown");
258 }
259
260 /*
261 * These functions re-use the assembly code in head.S, which
262 * already provide the required functionality.
263 */
264 extern struct proc_info_list *lookup_processor_type(unsigned int);
265 extern struct machine_desc *lookup_machine_type(unsigned int);
266
267 static void __init setup_processor(void)
268 {
269 struct proc_info_list *list;
270
271 /*
272 * locate processor in the list of supported processor
273 * types. The linker builds this table for us from the
274 * entries in arch/arm/mm/proc-*.S
275 */
276 list = lookup_processor_type(read_cpuid_id());
277 if (!list) {
278 printk("CPU configuration botched (ID %08x), unable "
279 "to continue.\n", read_cpuid_id());
280 while (1);
281 }
282
283 cpu_name = list->cpu_name;
284
285 #ifdef MULTI_CPU
286 processor = *list->proc;
287 #endif
288 #ifdef MULTI_TLB
289 cpu_tlb = *list->tlb;
290 #endif
291 #ifdef MULTI_USER
292 cpu_user = *list->user;
293 #endif
294 #ifdef MULTI_CACHE
295 cpu_cache = *list->cache;
296 #endif
297
298 printk("CPU: %s [%08x] revision %d (ARMv%s), cr=%08lx\n",
299 cpu_name, read_cpuid_id(), read_cpuid_id() & 15,
300 proc_arch[cpu_architecture()], cr_alignment);
301
302 sprintf(init_utsname()->machine, "%s%c", list->arch_name, ENDIANNESS);
303 sprintf(elf_platform, "%s%c", list->elf_name, ENDIANNESS);
304 elf_hwcap = list->elf_hwcap;
305 #ifndef CONFIG_ARM_THUMB
306 elf_hwcap &= ~HWCAP_THUMB;
307 #endif
308
309 cacheid_init();
310 cpu_proc_init();
311 }
312
313 /*
314 * cpu_init - initialise one CPU.
315 *
316 * cpu_init sets up the per-CPU stacks.
317 */
318 void cpu_init(void)
319 {
320 unsigned int cpu = smp_processor_id();
321 struct stack *stk = &stacks[cpu];
322
323 if (cpu >= NR_CPUS) {
324 printk(KERN_CRIT "CPU%u: bad primary CPU number\n", cpu);
325 BUG();
326 }
327
328 /*
329 * setup stacks for re-entrant exception handlers
330 */
331 __asm__ (
332 "msr cpsr_c, %1\n\t"
333 "add sp, %0, %2\n\t"
334 "msr cpsr_c, %3\n\t"
335 "add sp, %0, %4\n\t"
336 "msr cpsr_c, %5\n\t"
337 "add sp, %0, %6\n\t"
338 "msr cpsr_c, %7"
339 :
340 : "r" (stk),
341 "I" (PSR_F_BIT | PSR_I_BIT | IRQ_MODE),
342 "I" (offsetof(struct stack, irq[0])),
343 "I" (PSR_F_BIT | PSR_I_BIT | ABT_MODE),
344 "I" (offsetof(struct stack, abt[0])),
345 "I" (PSR_F_BIT | PSR_I_BIT | UND_MODE),
346 "I" (offsetof(struct stack, und[0])),
347 "I" (PSR_F_BIT | PSR_I_BIT | SVC_MODE)
348 : "r14");
349 }
350
351 static struct machine_desc * __init setup_machine(unsigned int nr)
352 {
353 struct machine_desc *list;
354
355 /*
356 * locate machine in the list of supported machines.
357 */
358 list = lookup_machine_type(nr);
359 if (!list) {
360 printk("Machine configuration botched (nr %d), unable "
361 "to continue.\n", nr);
362 while (1);
363 }
364
365 printk("Machine: %s\n", list->name);
366
367 return list;
368 }
369
370 static int __init arm_add_memory(unsigned long start, unsigned long size)
371 {
372 struct membank *bank = &meminfo.bank[meminfo.nr_banks];
373
374 if (meminfo.nr_banks >= NR_BANKS) {
375 printk(KERN_CRIT "NR_BANKS too low, "
376 "ignoring memory at %#lx\n", start);
377 return -EINVAL;
378 }
379
380 /*
381 * Ensure that start/size are aligned to a page boundary.
382 * Size is appropriately rounded down, start is rounded up.
383 */
384 size -= start & ~PAGE_MASK;
385 bank->start = PAGE_ALIGN(start);
386 bank->size = size & PAGE_MASK;
387 bank->node = PHYS_TO_NID(start);
388
389 /*
390 * Check whether this memory region has non-zero size or
391 * invalid node number.
392 */
393 if (bank->size == 0 || bank->node >= MAX_NUMNODES)
394 return -EINVAL;
395
396 meminfo.nr_banks++;
397 return 0;
398 }
399
400 /*
401 * Pick out the memory size. We look for mem=size@start,
402 * where start and size are "size[KkMm]"
403 */
404 static void __init early_mem(char **p)
405 {
406 static int usermem __initdata = 0;
407 unsigned long size, start;
408
409 /*
410 * If the user specifies memory size, we
411 * blow away any automatically generated
412 * size.
413 */
414 if (usermem == 0) {
415 usermem = 1;
416 meminfo.nr_banks = 0;
417 }
418
419 start = PHYS_OFFSET;
420 size = memparse(*p, p);
421 if (**p == '@')
422 start = memparse(*p + 1, p);
423
424 arm_add_memory(start, size);
425 }
426 __early_param("mem=", early_mem);
427
428 /*
429 * Initial parsing of the command line.
430 */
431 static void __init parse_cmdline(char **cmdline_p, char *from)
432 {
433 char c = ' ', *to = command_line;
434 int len = 0;
435
436 for (;;) {
437 if (c == ' ') {
438 extern struct early_params __early_begin, __early_end;
439 struct early_params *p;
440
441 for (p = &__early_begin; p < &__early_end; p++) {
442 int arglen = strlen(p->arg);
443
444 if (memcmp(from, p->arg, arglen) == 0) {
445 if (to != command_line)
446 to -= 1;
447 from += arglen;
448 p->fn(&from);
449
450 while (*from != ' ' && *from != '\0')
451 from++;
452 break;
453 }
454 }
455 }
456 c = *from++;
457 if (!c)
458 break;
459 if (COMMAND_LINE_SIZE <= ++len)
460 break;
461 *to++ = c;
462 }
463 *to = '\0';
464 *cmdline_p = command_line;
465 }
466
467 static void __init
468 setup_ramdisk(int doload, int prompt, int image_start, unsigned int rd_sz)
469 {
470 #ifdef CONFIG_BLK_DEV_RAM
471 extern int rd_size, rd_image_start, rd_prompt, rd_doload;
472
473 rd_image_start = image_start;
474 rd_prompt = prompt;
475 rd_doload = doload;
476
477 if (rd_sz)
478 rd_size = rd_sz;
479 #endif
480 }
481
482 static void __init
483 request_standard_resources(struct meminfo *mi, struct machine_desc *mdesc)
484 {
485 struct resource *res;
486 int i;
487
488 kernel_code.start = virt_to_phys(_text);
489 kernel_code.end = virt_to_phys(_etext - 1);
490 kernel_data.start = virt_to_phys(_data);
491 kernel_data.end = virt_to_phys(_end - 1);
492
493 for (i = 0; i < mi->nr_banks; i++) {
494 if (mi->bank[i].size == 0)
495 continue;
496
497 res = alloc_bootmem_low(sizeof(*res));
498 res->name = "System RAM";
499 res->start = mi->bank[i].start;
500 res->end = mi->bank[i].start + mi->bank[i].size - 1;
501 res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
502
503 request_resource(&iomem_resource, res);
504
505 if (kernel_code.start >= res->start &&
506 kernel_code.end <= res->end)
507 request_resource(res, &kernel_code);
508 if (kernel_data.start >= res->start &&
509 kernel_data.end <= res->end)
510 request_resource(res, &kernel_data);
511 }
512
513 if (mdesc->video_start) {
514 video_ram.start = mdesc->video_start;
515 video_ram.end = mdesc->video_end;
516 request_resource(&iomem_resource, &video_ram);
517 }
518
519 /*
520 * Some machines don't have the possibility of ever
521 * possessing lp0, lp1 or lp2
522 */
523 if (mdesc->reserve_lp0)
524 request_resource(&ioport_resource, &lp0);
525 if (mdesc->reserve_lp1)
526 request_resource(&ioport_resource, &lp1);
527 if (mdesc->reserve_lp2)
528 request_resource(&ioport_resource, &lp2);
529 }
530
531 /*
532 * Tag parsing.
533 *
534 * This is the new way of passing data to the kernel at boot time. Rather
535 * than passing a fixed inflexible structure to the kernel, we pass a list
536 * of variable-sized tags to the kernel. The first tag must be a ATAG_CORE
537 * tag for the list to be recognised (to distinguish the tagged list from
538 * a param_struct). The list is terminated with a zero-length tag (this tag
539 * is not parsed in any way).
540 */
541 static int __init parse_tag_core(const struct tag *tag)
542 {
543 if (tag->hdr.size > 2) {
544 if ((tag->u.core.flags & 1) == 0)
545 root_mountflags &= ~MS_RDONLY;
546 ROOT_DEV = old_decode_dev(tag->u.core.rootdev);
547 }
548 return 0;
549 }
550
551 __tagtable(ATAG_CORE, parse_tag_core);
552
553 static int __init parse_tag_mem32(const struct tag *tag)
554 {
555 return arm_add_memory(tag->u.mem.start, tag->u.mem.size);
556 }
557
558 __tagtable(ATAG_MEM, parse_tag_mem32);
559
560 #if defined(CONFIG_VGA_CONSOLE) || defined(CONFIG_DUMMY_CONSOLE)
561 struct screen_info screen_info = {
562 .orig_video_lines = 30,
563 .orig_video_cols = 80,
564 .orig_video_mode = 0,
565 .orig_video_ega_bx = 0,
566 .orig_video_isVGA = 1,
567 .orig_video_points = 8
568 };
569
570 static int __init parse_tag_videotext(const struct tag *tag)
571 {
572 screen_info.orig_x = tag->u.videotext.x;
573 screen_info.orig_y = tag->u.videotext.y;
574 screen_info.orig_video_page = tag->u.videotext.video_page;
575 screen_info.orig_video_mode = tag->u.videotext.video_mode;
576 screen_info.orig_video_cols = tag->u.videotext.video_cols;
577 screen_info.orig_video_ega_bx = tag->u.videotext.video_ega_bx;
578 screen_info.orig_video_lines = tag->u.videotext.video_lines;
579 screen_info.orig_video_isVGA = tag->u.videotext.video_isvga;
580 screen_info.orig_video_points = tag->u.videotext.video_points;
581 return 0;
582 }
583
584 __tagtable(ATAG_VIDEOTEXT, parse_tag_videotext);
585 #endif
586
587 static int __init parse_tag_ramdisk(const struct tag *tag)
588 {
589 setup_ramdisk((tag->u.ramdisk.flags & 1) == 0,
590 (tag->u.ramdisk.flags & 2) == 0,
591 tag->u.ramdisk.start, tag->u.ramdisk.size);
592 return 0;
593 }
594
595 __tagtable(ATAG_RAMDISK, parse_tag_ramdisk);
596
597 static int __init parse_tag_serialnr(const struct tag *tag)
598 {
599 system_serial_low = tag->u.serialnr.low;
600 system_serial_high = tag->u.serialnr.high;
601 return 0;
602 }
603
604 __tagtable(ATAG_SERIAL, parse_tag_serialnr);
605
606 static int __init parse_tag_revision(const struct tag *tag)
607 {
608 system_rev = tag->u.revision.rev;
609 return 0;
610 }
611
612 __tagtable(ATAG_REVISION, parse_tag_revision);
613
614 static int __init parse_tag_cmdline(const struct tag *tag)
615 {
616 strlcpy(default_command_line, tag->u.cmdline.cmdline, COMMAND_LINE_SIZE);
617 return 0;
618 }
619
620 __tagtable(ATAG_CMDLINE, parse_tag_cmdline);
621
622 /*
623 * Scan the tag table for this tag, and call its parse function.
624 * The tag table is built by the linker from all the __tagtable
625 * declarations.
626 */
627 static int __init parse_tag(const struct tag *tag)
628 {
629 extern struct tagtable __tagtable_begin, __tagtable_end;
630 struct tagtable *t;
631
632 for (t = &__tagtable_begin; t < &__tagtable_end; t++)
633 if (tag->hdr.tag == t->tag) {
634 t->parse(tag);
635 break;
636 }
637
638 return t < &__tagtable_end;
639 }
640
641 /*
642 * Parse all tags in the list, checking both the global and architecture
643 * specific tag tables.
644 */
645 static void __init parse_tags(const struct tag *t)
646 {
647 for (; t->hdr.size; t = tag_next(t))
648 if (!parse_tag(t))
649 printk(KERN_WARNING
650 "Ignoring unrecognised tag 0x%08x\n",
651 t->hdr.tag);
652 }
653
654 /*
655 * This holds our defaults.
656 */
657 static struct init_tags {
658 struct tag_header hdr1;
659 struct tag_core core;
660 struct tag_header hdr2;
661 struct tag_mem32 mem;
662 struct tag_header hdr3;
663 } init_tags __initdata = {
664 { tag_size(tag_core), ATAG_CORE },
665 { 1, PAGE_SIZE, 0xff },
666 { tag_size(tag_mem32), ATAG_MEM },
667 { MEM_SIZE, PHYS_OFFSET },
668 { 0, ATAG_NONE }
669 };
670
671 static void (*init_machine)(void) __initdata;
672
673 static int __init customize_machine(void)
674 {
675 /* customizes platform devices, or adds new ones */
676 if (init_machine)
677 init_machine();
678 return 0;
679 }
680 arch_initcall(customize_machine);
681
682 void __init setup_arch(char **cmdline_p)
683 {
684 struct tag *tags = (struct tag *)&init_tags;
685 struct machine_desc *mdesc;
686 char *from = default_command_line;
687
688 unwind_init();
689
690 setup_processor();
691 mdesc = setup_machine(machine_arch_type);
692 machine_name = mdesc->name;
693
694 if (mdesc->soft_reboot)
695 reboot_setup("s");
696
697 if (__atags_pointer)
698 tags = phys_to_virt(__atags_pointer);
699 else if (mdesc->boot_params)
700 tags = phys_to_virt(mdesc->boot_params);
701
702 /*
703 * If we have the old style parameters, convert them to
704 * a tag list.
705 */
706 if (tags->hdr.tag != ATAG_CORE)
707 convert_to_tag_list(tags);
708 if (tags->hdr.tag != ATAG_CORE)
709 tags = (struct tag *)&init_tags;
710
711 if (mdesc->fixup)
712 mdesc->fixup(mdesc, tags, &from, &meminfo);
713
714 if (tags->hdr.tag == ATAG_CORE) {
715 if (meminfo.nr_banks != 0)
716 squash_mem_tags(tags);
717 save_atags(tags);
718 parse_tags(tags);
719 }
720
721 init_mm.start_code = (unsigned long) _text;
722 init_mm.end_code = (unsigned long) _etext;
723 init_mm.end_data = (unsigned long) _edata;
724 init_mm.brk = (unsigned long) _end;
725
726 memcpy(boot_command_line, from, COMMAND_LINE_SIZE);
727 boot_command_line[COMMAND_LINE_SIZE-1] = '\0';
728 parse_cmdline(cmdline_p, from);
729 paging_init(mdesc);
730 request_standard_resources(&meminfo, mdesc);
731
732 #ifdef CONFIG_SMP
733 smp_init_cpus();
734 #endif
735
736 cpu_init();
737
738 /*
739 * Set up various architecture-specific pointers
740 */
741 init_arch_irq = mdesc->init_irq;
742 system_timer = mdesc->timer;
743 init_machine = mdesc->init_machine;
744
745 #ifdef CONFIG_VT
746 #if defined(CONFIG_VGA_CONSOLE)
747 conswitchp = &vga_con;
748 #elif defined(CONFIG_DUMMY_CONSOLE)
749 conswitchp = &dummy_con;
750 #endif
751 #endif
752 early_trap_init();
753 }
754
755
756 static int __init topology_init(void)
757 {
758 int cpu;
759
760 for_each_possible_cpu(cpu) {
761 struct cpuinfo_arm *cpuinfo = &per_cpu(cpu_data, cpu);
762 cpuinfo->cpu.hotpluggable = 1;
763 register_cpu(&cpuinfo->cpu, cpu);
764 }
765
766 return 0;
767 }
768
769 subsys_initcall(topology_init);
770
771 static const char *hwcap_str[] = {
772 "swp",
773 "half",
774 "thumb",
775 "26bit",
776 "fastmult",
777 "fpa",
778 "vfp",
779 "edsp",
780 "java",
781 "iwmmxt",
782 "crunch",
783 "thumbee",
784 "neon",
785 "vfpv3",
786 "vfpv3d16",
787 NULL
788 };
789
790 static int c_show(struct seq_file *m, void *v)
791 {
792 int i;
793
794 seq_printf(m, "Processor\t: %s rev %d (%s)\n",
795 cpu_name, read_cpuid_id() & 15, elf_platform);
796
797 #if defined(CONFIG_SMP)
798 for_each_online_cpu(i) {
799 /*
800 * glibc reads /proc/cpuinfo to determine the number of
801 * online processors, looking for lines beginning with
802 * "processor". Give glibc what it expects.
803 */
804 seq_printf(m, "processor\t: %d\n", i);
805 seq_printf(m, "BogoMIPS\t: %lu.%02lu\n\n",
806 per_cpu(cpu_data, i).loops_per_jiffy / (500000UL/HZ),
807 (per_cpu(cpu_data, i).loops_per_jiffy / (5000UL/HZ)) % 100);
808 }
809 #else /* CONFIG_SMP */
810 seq_printf(m, "BogoMIPS\t: %lu.%02lu\n",
811 loops_per_jiffy / (500000/HZ),
812 (loops_per_jiffy / (5000/HZ)) % 100);
813 #endif
814
815 /* dump out the processor features */
816 seq_puts(m, "Features\t: ");
817
818 for (i = 0; hwcap_str[i]; i++)
819 if (elf_hwcap & (1 << i))
820 seq_printf(m, "%s ", hwcap_str[i]);
821
822 seq_printf(m, "\nCPU implementer\t: 0x%02x\n", read_cpuid_id() >> 24);
823 seq_printf(m, "CPU architecture: %s\n", proc_arch[cpu_architecture()]);
824
825 if ((read_cpuid_id() & 0x0008f000) == 0x00000000) {
826 /* pre-ARM7 */
827 seq_printf(m, "CPU part\t: %07x\n", read_cpuid_id() >> 4);
828 } else {
829 if ((read_cpuid_id() & 0x0008f000) == 0x00007000) {
830 /* ARM7 */
831 seq_printf(m, "CPU variant\t: 0x%02x\n",
832 (read_cpuid_id() >> 16) & 127);
833 } else {
834 /* post-ARM7 */
835 seq_printf(m, "CPU variant\t: 0x%x\n",
836 (read_cpuid_id() >> 20) & 15);
837 }
838 seq_printf(m, "CPU part\t: 0x%03x\n",
839 (read_cpuid_id() >> 4) & 0xfff);
840 }
841 seq_printf(m, "CPU revision\t: %d\n", read_cpuid_id() & 15);
842
843 seq_puts(m, "\n");
844
845 seq_printf(m, "Hardware\t: %s\n", machine_name);
846 seq_printf(m, "Revision\t: %04x\n", system_rev);
847 seq_printf(m, "Serial\t\t: %08x%08x\n",
848 system_serial_high, system_serial_low);
849
850 return 0;
851 }
852
853 static void *c_start(struct seq_file *m, loff_t *pos)
854 {
855 return *pos < 1 ? (void *)1 : NULL;
856 }
857
858 static void *c_next(struct seq_file *m, void *v, loff_t *pos)
859 {
860 ++*pos;
861 return NULL;
862 }
863
864 static void c_stop(struct seq_file *m, void *v)
865 {
866 }
867
868 const struct seq_operations cpuinfo_op = {
869 .start = c_start,
870 .next = c_next,
871 .stop = c_stop,
872 .show = c_show
873 };
Linux kernel - Deliverables
This page took 0.092867 seconds and 6 git commands to generate.