]> nv-tegra.nvidia Code Review - linux-2.6.git/blob - arch/x86_64/kernel/setup.c
Merge branch 'x86-64'
[linux-2.6.git] / arch / x86_64 / kernel / setup.c
1 /*
2  *  linux/arch/x86-64/kernel/setup.c
3  *
4  *  Copyright (C) 1995  Linus Torvalds
5  *
6  *  Nov 2001 Dave Jones <davej@suse.de>
7  *  Forked from i386 setup code.
8  */
9
10 /*
11  * This file handles the architecture-dependent parts of initialization
12  */
13
14 #include <linux/errno.h>
15 #include <linux/sched.h>
16 #include <linux/kernel.h>
17 #include <linux/mm.h>
18 #include <linux/stddef.h>
19 #include <linux/unistd.h>
20 #include <linux/ptrace.h>
21 #include <linux/slab.h>
22 #include <linux/user.h>
23 #include <linux/a.out.h>
24 #include <linux/tty.h>
25 #include <linux/ioport.h>
26 #include <linux/delay.h>
27 #include <linux/config.h>
28 #include <linux/init.h>
29 #include <linux/initrd.h>
30 #include <linux/highmem.h>
31 #include <linux/bootmem.h>
32 #include <linux/module.h>
33 #include <asm/processor.h>
34 #include <linux/console.h>
35 #include <linux/seq_file.h>
36 #include <linux/crash_dump.h>
37 #include <linux/root_dev.h>
38 #include <linux/pci.h>
39 #include <linux/acpi.h>
40 #include <linux/kallsyms.h>
41 #include <linux/edd.h>
42 #include <linux/mmzone.h>
43 #include <linux/kexec.h>
44 #include <linux/cpufreq.h>
45 #include <linux/dmi.h>
46 #include <linux/dma-mapping.h>
47 #include <linux/ctype.h>
48
49 #include <asm/mtrr.h>
50 #include <asm/uaccess.h>
51 #include <asm/system.h>
52 #include <asm/io.h>
53 #include <asm/smp.h>
54 #include <asm/msr.h>
55 #include <asm/desc.h>
56 #include <video/edid.h>
57 #include <asm/e820.h>
58 #include <asm/dma.h>
59 #include <asm/mpspec.h>
60 #include <asm/mmu_context.h>
61 #include <asm/bootsetup.h>
62 #include <asm/proto.h>
63 #include <asm/setup.h>
64 #include <asm/mach_apic.h>
65 #include <asm/numa.h>
66 #include <asm/sections.h>
67 #include <asm/dmi.h>
68
69 /*
70  * Machine setup..
71  */
72
73 struct cpuinfo_x86 boot_cpu_data __read_mostly;
74 EXPORT_SYMBOL(boot_cpu_data);
75
76 unsigned long mmu_cr4_features;
77
78 int acpi_disabled;
79 EXPORT_SYMBOL(acpi_disabled);
80 #ifdef  CONFIG_ACPI
81 extern int __initdata acpi_ht;
82 extern acpi_interrupt_flags     acpi_sci_flags;
83 int __initdata acpi_force = 0;
84 #endif
85
86 int acpi_numa __initdata;
87
88 /* Boot loader ID as an integer, for the benefit of proc_dointvec */
89 int bootloader_type;
90
91 unsigned long saved_video_mode;
92
93 /* 
94  * Early DMI memory
95  */
96 int dmi_alloc_index;
97 char dmi_alloc_data[DMI_MAX_DATA];
98
99 /*
100  * Setup options
101  */
102 struct screen_info screen_info;
103 EXPORT_SYMBOL(screen_info);
104 struct sys_desc_table_struct {
105         unsigned short length;
106         unsigned char table[0];
107 };
108
109 struct edid_info edid_info;
110 EXPORT_SYMBOL_GPL(edid_info);
111 struct e820map e820;
112
113 extern int root_mountflags;
114
115 char command_line[COMMAND_LINE_SIZE];
116
117 struct resource standard_io_resources[] = {
118         { .name = "dma1", .start = 0x00, .end = 0x1f,
119                 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
120         { .name = "pic1", .start = 0x20, .end = 0x21,
121                 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
122         { .name = "timer0", .start = 0x40, .end = 0x43,
123                 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
124         { .name = "timer1", .start = 0x50, .end = 0x53,
125                 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
126         { .name = "keyboard", .start = 0x60, .end = 0x6f,
127                 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
128         { .name = "dma page reg", .start = 0x80, .end = 0x8f,
129                 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
130         { .name = "pic2", .start = 0xa0, .end = 0xa1,
131                 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
132         { .name = "dma2", .start = 0xc0, .end = 0xdf,
133                 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
134         { .name = "fpu", .start = 0xf0, .end = 0xff,
135                 .flags = IORESOURCE_BUSY | IORESOURCE_IO }
136 };
137
138 #define STANDARD_IO_RESOURCES \
139         (sizeof standard_io_resources / sizeof standard_io_resources[0])
140
141 #define IORESOURCE_RAM (IORESOURCE_BUSY | IORESOURCE_MEM)
142
143 struct resource data_resource = {
144         .name = "Kernel data",
145         .start = 0,
146         .end = 0,
147         .flags = IORESOURCE_RAM,
148 };
149 struct resource code_resource = {
150         .name = "Kernel code",
151         .start = 0,
152         .end = 0,
153         .flags = IORESOURCE_RAM,
154 };
155
156 #define IORESOURCE_ROM (IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM)
157
158 static struct resource system_rom_resource = {
159         .name = "System ROM",
160         .start = 0xf0000,
161         .end = 0xfffff,
162         .flags = IORESOURCE_ROM,
163 };
164
165 static struct resource extension_rom_resource = {
166         .name = "Extension ROM",
167         .start = 0xe0000,
168         .end = 0xeffff,
169         .flags = IORESOURCE_ROM,
170 };
171
172 static struct resource adapter_rom_resources[] = {
173         { .name = "Adapter ROM", .start = 0xc8000, .end = 0,
174                 .flags = IORESOURCE_ROM },
175         { .name = "Adapter ROM", .start = 0, .end = 0,
176                 .flags = IORESOURCE_ROM },
177         { .name = "Adapter ROM", .start = 0, .end = 0,
178                 .flags = IORESOURCE_ROM },
179         { .name = "Adapter ROM", .start = 0, .end = 0,
180                 .flags = IORESOURCE_ROM },
181         { .name = "Adapter ROM", .start = 0, .end = 0,
182                 .flags = IORESOURCE_ROM },
183         { .name = "Adapter ROM", .start = 0, .end = 0,
184                 .flags = IORESOURCE_ROM }
185 };
186
187 #define ADAPTER_ROM_RESOURCES \
188         (sizeof adapter_rom_resources / sizeof adapter_rom_resources[0])
189
190 static struct resource video_rom_resource = {
191         .name = "Video ROM",
192         .start = 0xc0000,
193         .end = 0xc7fff,
194         .flags = IORESOURCE_ROM,
195 };
196
197 static struct resource video_ram_resource = {
198         .name = "Video RAM area",
199         .start = 0xa0000,
200         .end = 0xbffff,
201         .flags = IORESOURCE_RAM,
202 };
203
204 #define romsignature(x) (*(unsigned short *)(x) == 0xaa55)
205
206 static int __init romchecksum(unsigned char *rom, unsigned long length)
207 {
208         unsigned char *p, sum = 0;
209
210         for (p = rom; p < rom + length; p++)
211                 sum += *p;
212         return sum == 0;
213 }
214
215 static void __init probe_roms(void)
216 {
217         unsigned long start, length, upper;
218         unsigned char *rom;
219         int           i;
220
221         /* video rom */
222         upper = adapter_rom_resources[0].start;
223         for (start = video_rom_resource.start; start < upper; start += 2048) {
224                 rom = isa_bus_to_virt(start);
225                 if (!romsignature(rom))
226                         continue;
227
228                 video_rom_resource.start = start;
229
230                 /* 0 < length <= 0x7f * 512, historically */
231                 length = rom[2] * 512;
232
233                 /* if checksum okay, trust length byte */
234                 if (length && romchecksum(rom, length))
235                         video_rom_resource.end = start + length - 1;
236
237                 request_resource(&iomem_resource, &video_rom_resource);
238                 break;
239                         }
240
241         start = (video_rom_resource.end + 1 + 2047) & ~2047UL;
242         if (start < upper)
243                 start = upper;
244
245         /* system rom */
246         request_resource(&iomem_resource, &system_rom_resource);
247         upper = system_rom_resource.start;
248
249         /* check for extension rom (ignore length byte!) */
250         rom = isa_bus_to_virt(extension_rom_resource.start);
251         if (romsignature(rom)) {
252                 length = extension_rom_resource.end - extension_rom_resource.start + 1;
253                 if (romchecksum(rom, length)) {
254                         request_resource(&iomem_resource, &extension_rom_resource);
255                         upper = extension_rom_resource.start;
256                 }
257         }
258
259         /* check for adapter roms on 2k boundaries */
260         for (i = 0; i < ADAPTER_ROM_RESOURCES && start < upper; start += 2048) {
261                 rom = isa_bus_to_virt(start);
262                 if (!romsignature(rom))
263                         continue;
264
265                 /* 0 < length <= 0x7f * 512, historically */
266                 length = rom[2] * 512;
267
268                 /* but accept any length that fits if checksum okay */
269                 if (!length || start + length > upper || !romchecksum(rom, length))
270                         continue;
271
272                 adapter_rom_resources[i].start = start;
273                 adapter_rom_resources[i].end = start + length - 1;
274                 request_resource(&iomem_resource, &adapter_rom_resources[i]);
275
276                 start = adapter_rom_resources[i++].end & ~2047UL;
277         }
278 }
279
280 /* Check for full argument with no trailing characters */
281 static int fullarg(char *p, char *arg)
282 {
283         int l = strlen(arg);
284         return !memcmp(p, arg, l) && (p[l] == 0 || isspace(p[l]));
285 }
286
287 static __init void parse_cmdline_early (char ** cmdline_p)
288 {
289         char c = ' ', *to = command_line, *from = COMMAND_LINE;
290         int len = 0;
291         int userdef = 0;
292
293         for (;;) {
294                 if (c != ' ') 
295                         goto next_char; 
296
297 #ifdef  CONFIG_SMP
298                 /*
299                  * If the BIOS enumerates physical processors before logical,
300                  * maxcpus=N at enumeration-time can be used to disable HT.
301                  */
302                 else if (!memcmp(from, "maxcpus=", 8)) {
303                         extern unsigned int maxcpus;
304
305                         maxcpus = simple_strtoul(from + 8, NULL, 0);
306                 }
307 #endif
308 #ifdef CONFIG_ACPI
309                 /* "acpi=off" disables both ACPI table parsing and interpreter init */
310                 if (fullarg(from,"acpi=off"))
311                         disable_acpi();
312
313                 if (fullarg(from, "acpi=force")) { 
314                         /* add later when we do DMI horrors: */
315                         acpi_force = 1;
316                         acpi_disabled = 0;
317                 }
318
319                 /* acpi=ht just means: do ACPI MADT parsing 
320                    at bootup, but don't enable the full ACPI interpreter */
321                 if (fullarg(from, "acpi=ht")) { 
322                         if (!acpi_force)
323                                 disable_acpi();
324                         acpi_ht = 1; 
325                 }
326                 else if (fullarg(from, "pci=noacpi")) 
327                         acpi_disable_pci();
328                 else if (fullarg(from, "acpi=noirq"))
329                         acpi_noirq_set();
330
331                 else if (fullarg(from, "acpi_sci=edge"))
332                         acpi_sci_flags.trigger =  1;
333                 else if (fullarg(from, "acpi_sci=level"))
334                         acpi_sci_flags.trigger = 3;
335                 else if (fullarg(from, "acpi_sci=high"))
336                         acpi_sci_flags.polarity = 1;
337                 else if (fullarg(from, "acpi_sci=low"))
338                         acpi_sci_flags.polarity = 3;
339
340                 /* acpi=strict disables out-of-spec workarounds */
341                 else if (fullarg(from, "acpi=strict")) {
342                         acpi_strict = 1;
343                 }
344 #ifdef CONFIG_X86_IO_APIC
345                 else if (fullarg(from, "acpi_skip_timer_override"))
346                         acpi_skip_timer_override = 1;
347 #endif
348 #endif
349
350                 if (fullarg(from, "disable_timer_pin_1"))
351                         disable_timer_pin_1 = 1;
352                 if (fullarg(from, "enable_timer_pin_1"))
353                         disable_timer_pin_1 = -1;
354
355                 if (fullarg(from, "nolapic") || fullarg(from, "disableapic")) {
356                         clear_bit(X86_FEATURE_APIC, boot_cpu_data.x86_capability);
357                         disable_apic = 1;
358                 }
359
360                 if (fullarg(from, "noapic"))
361                         skip_ioapic_setup = 1;
362
363                 if (fullarg(from,"apic")) {
364                         skip_ioapic_setup = 0;
365                         ioapic_force = 1;
366                 }
367                         
368                 if (!memcmp(from, "mem=", 4))
369                         parse_memopt(from+4, &from); 
370
371                 if (!memcmp(from, "memmap=", 7)) {
372                         /* exactmap option is for used defined memory */
373                         if (!memcmp(from+7, "exactmap", 8)) {
374 #ifdef CONFIG_CRASH_DUMP
375                                 /* If we are doing a crash dump, we
376                                  * still need to know the real mem
377                                  * size before original memory map is
378                                  * reset.
379                                  */
380                                 saved_max_pfn = e820_end_of_ram();
381 #endif
382                                 from += 8+7;
383                                 end_pfn_map = 0;
384                                 e820.nr_map = 0;
385                                 userdef = 1;
386                         }
387                         else {
388                                 parse_memmapopt(from+7, &from);
389                                 userdef = 1;
390                         }
391                 }
392
393 #ifdef CONFIG_NUMA
394                 if (!memcmp(from, "numa=", 5))
395                         numa_setup(from+5); 
396 #endif
397
398                 if (!memcmp(from,"iommu=",6)) { 
399                         iommu_setup(from+6); 
400                 }
401
402                 if (fullarg(from,"oops=panic"))
403                         panic_on_oops = 1;
404
405                 if (!memcmp(from, "noexec=", 7))
406                         nonx_setup(from + 7);
407
408 #ifdef CONFIG_KEXEC
409                 /* crashkernel=size@addr specifies the location to reserve for
410                  * a crash kernel.  By reserving this memory we guarantee
411                  * that linux never set's it up as a DMA target.
412                  * Useful for holding code to do something appropriate
413                  * after a kernel panic.
414                  */
415                 else if (!memcmp(from, "crashkernel=", 12)) {
416                         unsigned long size, base;
417                         size = memparse(from+12, &from);
418                         if (*from == '@') {
419                                 base = memparse(from+1, &from);
420                                 /* FIXME: Do I want a sanity check
421                                  * to validate the memory range?
422                                  */
423                                 crashk_res.start = base;
424                                 crashk_res.end   = base + size - 1;
425                         }
426                 }
427 #endif
428
429 #ifdef CONFIG_PROC_VMCORE
430                 /* elfcorehdr= specifies the location of elf core header
431                  * stored by the crashed kernel. This option will be passed
432                  * by kexec loader to the capture kernel.
433                  */
434                 else if(!memcmp(from, "elfcorehdr=", 11))
435                         elfcorehdr_addr = memparse(from+11, &from);
436 #endif
437
438 #ifdef CONFIG_HOTPLUG_CPU
439                 else if (!memcmp(from, "additional_cpus=", 16))
440                         setup_additional_cpus(from+16);
441 #endif
442
443         next_char:
444                 c = *(from++);
445                 if (!c)
446                         break;
447                 if (COMMAND_LINE_SIZE <= ++len)
448                         break;
449                 *(to++) = c;
450         }
451         if (userdef) {
452                 printk(KERN_INFO "user-defined physical RAM map:\n");
453                 e820_print_map("user");
454         }
455         *to = '\0';
456         *cmdline_p = command_line;
457 }
458
459 #ifndef CONFIG_NUMA
460 static void __init
461 contig_initmem_init(unsigned long start_pfn, unsigned long end_pfn)
462 {
463         unsigned long bootmap_size, bootmap;
464
465         bootmap_size = bootmem_bootmap_pages(end_pfn)<<PAGE_SHIFT;
466         bootmap = find_e820_area(0, end_pfn<<PAGE_SHIFT, bootmap_size);
467         if (bootmap == -1L)
468                 panic("Cannot find bootmem map of size %ld\n",bootmap_size);
469         bootmap_size = init_bootmem(bootmap >> PAGE_SHIFT, end_pfn);
470         e820_bootmem_free(NODE_DATA(0), 0, end_pfn << PAGE_SHIFT);
471         reserve_bootmem(bootmap, bootmap_size);
472
473 #endif
474
475 #if defined(CONFIG_EDD) || defined(CONFIG_EDD_MODULE)
476 struct edd edd;
477 #ifdef CONFIG_EDD_MODULE
478 EXPORT_SYMBOL(edd);
479 #endif
480 /**
481  * copy_edd() - Copy the BIOS EDD information
482  *              from boot_params into a safe place.
483  *
484  */
485 static inline void copy_edd(void)
486 {
487      memcpy(edd.mbr_signature, EDD_MBR_SIGNATURE, sizeof(edd.mbr_signature));
488      memcpy(edd.edd_info, EDD_BUF, sizeof(edd.edd_info));
489      edd.mbr_signature_nr = EDD_MBR_SIG_NR;
490      edd.edd_info_nr = EDD_NR;
491 }
492 #else
493 static inline void copy_edd(void)
494 {
495 }
496 #endif
497
498 #define EBDA_ADDR_POINTER 0x40E
499
500 unsigned __initdata ebda_addr;
501 unsigned __initdata ebda_size;
502
503 static void discover_ebda(void)
504 {
505         /*
506          * there is a real-mode segmented pointer pointing to the 
507          * 4K EBDA area at 0x40E
508          */
509         ebda_addr = *(unsigned short *)EBDA_ADDR_POINTER;
510         ebda_addr <<= 4;
511
512         ebda_size = *(unsigned short *)(unsigned long)ebda_addr;
513
514         /* Round EBDA up to pages */
515         if (ebda_size == 0)
516                 ebda_size = 1;
517         ebda_size <<= 10;
518         ebda_size = round_up(ebda_size + (ebda_addr & ~PAGE_MASK), PAGE_SIZE);
519         if (ebda_size > 64*1024)
520                 ebda_size = 64*1024;
521 }
522
523 void __init setup_arch(char **cmdline_p)
524 {
525         unsigned long kernel_end;
526
527         ROOT_DEV = old_decode_dev(ORIG_ROOT_DEV);
528         screen_info = SCREEN_INFO;
529         edid_info = EDID_INFO;
530         saved_video_mode = SAVED_VIDEO_MODE;
531         bootloader_type = LOADER_TYPE;
532
533 #ifdef CONFIG_BLK_DEV_RAM
534         rd_image_start = RAMDISK_FLAGS & RAMDISK_IMAGE_START_MASK;
535         rd_prompt = ((RAMDISK_FLAGS & RAMDISK_PROMPT_FLAG) != 0);
536         rd_doload = ((RAMDISK_FLAGS & RAMDISK_LOAD_FLAG) != 0);
537 #endif
538         setup_memory_region();
539         copy_edd();
540
541         if (!MOUNT_ROOT_RDONLY)
542                 root_mountflags &= ~MS_RDONLY;
543         init_mm.start_code = (unsigned long) &_text;
544         init_mm.end_code = (unsigned long) &_etext;
545         init_mm.end_data = (unsigned long) &_edata;
546         init_mm.brk = (unsigned long) &_end;
547
548         code_resource.start = virt_to_phys(&_text);
549         code_resource.end = virt_to_phys(&_etext)-1;
550         data_resource.start = virt_to_phys(&_etext);
551         data_resource.end = virt_to_phys(&_edata)-1;
552
553         parse_cmdline_early(cmdline_p);
554
555         early_identify_cpu(&boot_cpu_data);
556
557         /*
558          * partially used pages are not usable - thus
559          * we are rounding upwards:
560          */
561         end_pfn = e820_end_of_ram();
562         num_physpages = end_pfn;                /* for pfn_valid */
563
564         check_efer();
565
566         discover_ebda();
567
568         init_memory_mapping(0, (end_pfn_map << PAGE_SHIFT));
569
570         dmi_scan_machine();
571
572         zap_low_mappings(0);
573
574 #ifdef CONFIG_ACPI
575         /*
576          * Initialize the ACPI boot-time table parser (gets the RSDP and SDT).
577          * Call this early for SRAT node setup.
578          */
579         acpi_boot_table_init();
580 #endif
581
582 #ifdef CONFIG_ACPI_NUMA
583         /*
584          * Parse SRAT to discover nodes.
585          */
586         acpi_numa_init();
587 #endif
588
589 #ifdef CONFIG_NUMA
590         numa_initmem_init(0, end_pfn); 
591 #else
592         contig_initmem_init(0, end_pfn);
593 #endif
594
595         /* Reserve direct mapping */
596         reserve_bootmem_generic(table_start << PAGE_SHIFT, 
597                                 (table_end - table_start) << PAGE_SHIFT);
598
599         /* reserve kernel */
600         kernel_end = round_up(__pa_symbol(&_end),PAGE_SIZE);
601         reserve_bootmem_generic(HIGH_MEMORY, kernel_end - HIGH_MEMORY);
602
603         /*
604          * reserve physical page 0 - it's a special BIOS page on many boxes,
605          * enabling clean reboots, SMP operation, laptop functions.
606          */
607         reserve_bootmem_generic(0, PAGE_SIZE);
608
609         /* reserve ebda region */
610         if (ebda_addr)
611                 reserve_bootmem_generic(ebda_addr, ebda_size);
612
613 #ifdef CONFIG_SMP
614         /*
615          * But first pinch a few for the stack/trampoline stuff
616          * FIXME: Don't need the extra page at 4K, but need to fix
617          * trampoline before removing it. (see the GDT stuff)
618          */
619         reserve_bootmem_generic(PAGE_SIZE, PAGE_SIZE);
620
621         /* Reserve SMP trampoline */
622         reserve_bootmem_generic(SMP_TRAMPOLINE_BASE, PAGE_SIZE);
623 #endif
624
625 #ifdef CONFIG_ACPI_SLEEP
626        /*
627         * Reserve low memory region for sleep support.
628         */
629        acpi_reserve_bootmem();
630 #endif
631 #ifdef CONFIG_X86_LOCAL_APIC
632         /*
633          * Find and reserve possible boot-time SMP configuration:
634          */
635         find_smp_config();
636 #endif
637 #ifdef CONFIG_BLK_DEV_INITRD
638         if (LOADER_TYPE && INITRD_START) {
639                 if (INITRD_START + INITRD_SIZE <= (end_pfn << PAGE_SHIFT)) {
640                         reserve_bootmem_generic(INITRD_START, INITRD_SIZE);
641                         initrd_start =
642                                 INITRD_START ? INITRD_START + PAGE_OFFSET : 0;
643                         initrd_end = initrd_start+INITRD_SIZE;
644                 }
645                 else {
646                         printk(KERN_ERR "initrd extends beyond end of memory "
647                             "(0x%08lx > 0x%08lx)\ndisabling initrd\n",
648                             (unsigned long)(INITRD_START + INITRD_SIZE),
649                             (unsigned long)(end_pfn << PAGE_SHIFT));
650                         initrd_start = 0;
651                 }
652         }
653 #endif
654 #ifdef CONFIG_KEXEC
655         if (crashk_res.start != crashk_res.end) {
656                 reserve_bootmem_generic(crashk_res.start,
657                         crashk_res.end - crashk_res.start + 1);
658         }
659 #endif
660
661         paging_init();
662
663         check_ioapic();
664
665         /*
666          * set this early, so we dont allocate cpu0
667          * if MADT list doesnt list BSP first
668          * mpparse.c/MP_processor_info() allocates logical cpu numbers.
669          */
670         cpu_set(0, cpu_present_map);
671 #ifdef CONFIG_ACPI
672         /*
673          * Read APIC and some other early information from ACPI tables.
674          */
675         acpi_boot_init();
676 #endif
677
678         init_cpu_to_node();
679
680 #ifdef CONFIG_X86_LOCAL_APIC
681         /*
682          * get boot-time SMP configuration:
683          */
684         if (smp_found_config)
685                 get_smp_config();
686         init_apic_mappings();
687 #endif
688
689         /*
690          * Request address space for all standard RAM and ROM resources
691          * and also for regions reported as reserved by the e820.
692          */
693         probe_roms();
694         e820_reserve_resources(); 
695
696         request_resource(&iomem_resource, &video_ram_resource);
697
698         {
699         unsigned i;
700         /* request I/O space for devices used on all i[345]86 PCs */
701         for (i = 0; i < STANDARD_IO_RESOURCES; i++)
702                 request_resource(&ioport_resource, &standard_io_resources[i]);
703         }
704
705         e820_setup_gap();
706
707 #ifdef CONFIG_VT
708 #if defined(CONFIG_VGA_CONSOLE)
709         conswitchp = &vga_con;
710 #elif defined(CONFIG_DUMMY_CONSOLE)
711         conswitchp = &dummy_con;
712 #endif
713 #endif
714 }
715
716 static int __cpuinit get_model_name(struct cpuinfo_x86 *c)
717 {
718         unsigned int *v;
719
720         if (c->extended_cpuid_level < 0x80000004)
721                 return 0;
722
723         v = (unsigned int *) c->x86_model_id;
724         cpuid(0x80000002, &v[0], &v[1], &v[2], &v[3]);
725         cpuid(0x80000003, &v[4], &v[5], &v[6], &v[7]);
726         cpuid(0x80000004, &v[8], &v[9], &v[10], &v[11]);
727         c->x86_model_id[48] = 0;
728         return 1;
729 }
730
731
732 static void __cpuinit display_cacheinfo(struct cpuinfo_x86 *c)
733 {
734         unsigned int n, dummy, eax, ebx, ecx, edx;
735
736         n = c->extended_cpuid_level;
737
738         if (n >= 0x80000005) {
739                 cpuid(0x80000005, &dummy, &ebx, &ecx, &edx);
740                 printk(KERN_INFO "CPU: L1 I Cache: %dK (%d bytes/line), D cache %dK (%d bytes/line)\n",
741                         edx>>24, edx&0xFF, ecx>>24, ecx&0xFF);
742                 c->x86_cache_size=(ecx>>24)+(edx>>24);
743                 /* On K8 L1 TLB is inclusive, so don't count it */
744                 c->x86_tlbsize = 0;
745         }
746
747         if (n >= 0x80000006) {
748                 cpuid(0x80000006, &dummy, &ebx, &ecx, &edx);
749                 ecx = cpuid_ecx(0x80000006);
750                 c->x86_cache_size = ecx >> 16;
751                 c->x86_tlbsize += ((ebx >> 16) & 0xfff) + (ebx & 0xfff);
752
753                 printk(KERN_INFO "CPU: L2 Cache: %dK (%d bytes/line)\n",
754                 c->x86_cache_size, ecx & 0xFF);
755         }
756
757         if (n >= 0x80000007)
758                 cpuid(0x80000007, &dummy, &dummy, &dummy, &c->x86_power); 
759         if (n >= 0x80000008) {
760                 cpuid(0x80000008, &eax, &dummy, &dummy, &dummy); 
761                 c->x86_virt_bits = (eax >> 8) & 0xff;
762                 c->x86_phys_bits = eax & 0xff;
763         }
764 }
765
766 #ifdef CONFIG_NUMA
767 static int nearby_node(int apicid)
768 {
769         int i;
770         for (i = apicid - 1; i >= 0; i--) {
771                 int node = apicid_to_node[i];
772                 if (node != NUMA_NO_NODE && node_online(node))
773                         return node;
774         }
775         for (i = apicid + 1; i < MAX_LOCAL_APIC; i++) {
776                 int node = apicid_to_node[i];
777                 if (node != NUMA_NO_NODE && node_online(node))
778                         return node;
779         }
780         return first_node(node_online_map); /* Shouldn't happen */
781 }
782 #endif
783
784 /*
785  * On a AMD dual core setup the lower bits of the APIC id distingush the cores.
786  * Assumes number of cores is a power of two.
787  */
788 static void __init amd_detect_cmp(struct cpuinfo_x86 *c)
789 {
790 #ifdef CONFIG_SMP
791         unsigned bits;
792 #ifdef CONFIG_NUMA
793         int cpu = smp_processor_id();
794         int node = 0;
795         unsigned apicid = hard_smp_processor_id();
796 #endif
797         unsigned ecx = cpuid_ecx(0x80000008);
798
799         c->x86_max_cores = (ecx & 0xff) + 1;
800
801         /* CPU telling us the core id bits shift? */
802         bits = (ecx >> 12) & 0xF;
803
804         /* Otherwise recompute */
805         if (bits == 0) {
806                 while ((1 << bits) < c->x86_max_cores)
807                         bits++;
808         }
809
810         /* Low order bits define the core id (index of core in socket) */
811         c->cpu_core_id = c->phys_proc_id & ((1 << bits)-1);
812         /* Convert the APIC ID into the socket ID */
813         c->phys_proc_id = phys_pkg_id(bits);
814
815 #ifdef CONFIG_NUMA
816         node = c->phys_proc_id;
817         if (apicid_to_node[apicid] != NUMA_NO_NODE)
818                 node = apicid_to_node[apicid];
819         if (!node_online(node)) {
820                 /* Two possibilities here:
821                    - The CPU is missing memory and no node was created.
822                    In that case try picking one from a nearby CPU
823                    - The APIC IDs differ from the HyperTransport node IDs
824                    which the K8 northbridge parsing fills in.
825                    Assume they are all increased by a constant offset,
826                    but in the same order as the HT nodeids.
827                    If that doesn't result in a usable node fall back to the
828                    path for the previous case.  */
829                 int ht_nodeid = apicid - (cpu_data[0].phys_proc_id << bits);
830                 if (ht_nodeid >= 0 &&
831                     apicid_to_node[ht_nodeid] != NUMA_NO_NODE)
832                         node = apicid_to_node[ht_nodeid];
833                 /* Pick a nearby node */
834                 if (!node_online(node))
835                         node = nearby_node(apicid);
836         }
837         numa_set_node(cpu, node);
838
839         printk(KERN_INFO "CPU %d/%x -> Node %d\n", cpu, apicid, node);
840 #endif
841 #endif
842 }
843
844 static void __init init_amd(struct cpuinfo_x86 *c)
845 {
846         unsigned level;
847
848 #ifdef CONFIG_SMP
849         unsigned long value;
850
851         /*
852          * Disable TLB flush filter by setting HWCR.FFDIS on K8
853          * bit 6 of msr C001_0015
854          *
855          * Errata 63 for SH-B3 steppings
856          * Errata 122 for all steppings (F+ have it disabled by default)
857          */
858         if (c->x86 == 15) {
859                 rdmsrl(MSR_K8_HWCR, value);
860                 value |= 1 << 6;
861                 wrmsrl(MSR_K8_HWCR, value);
862         }
863 #endif
864
865         /* Bit 31 in normal CPUID used for nonstandard 3DNow ID;
866            3DNow is IDd by bit 31 in extended CPUID (1*32+31) anyway */
867         clear_bit(0*32+31, &c->x86_capability);
868         
869         /* On C+ stepping K8 rep microcode works well for copy/memset */
870         level = cpuid_eax(1);
871         if (c->x86 == 15 && ((level >= 0x0f48 && level < 0x0f50) || level >= 0x0f58))
872                 set_bit(X86_FEATURE_REP_GOOD, &c->x86_capability);
873
874         /* Enable workaround for FXSAVE leak */
875         if (c->x86 >= 6)
876                 set_bit(X86_FEATURE_FXSAVE_LEAK, &c->x86_capability);
877
878         level = get_model_name(c);
879         if (!level) {
880                 switch (c->x86) { 
881                 case 15:
882                         /* Should distinguish Models here, but this is only
883                            a fallback anyways. */
884                         strcpy(c->x86_model_id, "Hammer");
885                         break; 
886                 } 
887         } 
888         display_cacheinfo(c);
889
890         /* c->x86_power is 8000_0007 edx. Bit 8 is constant TSC */
891         if (c->x86_power & (1<<8))
892                 set_bit(X86_FEATURE_CONSTANT_TSC, &c->x86_capability);
893
894         /* Multi core CPU? */
895         if (c->extended_cpuid_level >= 0x80000008)
896                 amd_detect_cmp(c);
897
898         /* Fix cpuid4 emulation for more */
899         num_cache_leaves = 3;
900 }
901
902 static void __cpuinit detect_ht(struct cpuinfo_x86 *c)
903 {
904 #ifdef CONFIG_SMP
905         u32     eax, ebx, ecx, edx;
906         int     index_msb, core_bits;
907
908         cpuid(1, &eax, &ebx, &ecx, &edx);
909
910
911         if (!cpu_has(c, X86_FEATURE_HT))
912                 return;
913         if (cpu_has(c, X86_FEATURE_CMP_LEGACY))
914                 goto out;
915
916         smp_num_siblings = (ebx & 0xff0000) >> 16;
917
918         if (smp_num_siblings == 1) {
919                 printk(KERN_INFO  "CPU: Hyper-Threading is disabled\n");
920         } else if (smp_num_siblings > 1 ) {
921
922                 if (smp_num_siblings > NR_CPUS) {
923                         printk(KERN_WARNING "CPU: Unsupported number of the siblings %d", smp_num_siblings);
924                         smp_num_siblings = 1;
925                         return;
926                 }
927
928                 index_msb = get_count_order(smp_num_siblings);
929                 c->phys_proc_id = phys_pkg_id(index_msb);
930
931                 smp_num_siblings = smp_num_siblings / c->x86_max_cores;
932
933                 index_msb = get_count_order(smp_num_siblings) ;
934
935                 core_bits = get_count_order(c->x86_max_cores);
936
937                 c->cpu_core_id = phys_pkg_id(index_msb) &
938                                                ((1 << core_bits) - 1);
939         }
940 out:
941         if ((c->x86_max_cores * smp_num_siblings) > 1) {
942                 printk(KERN_INFO  "CPU: Physical Processor ID: %d\n", c->phys_proc_id);
943                 printk(KERN_INFO  "CPU: Processor Core ID: %d\n", c->cpu_core_id);
944         }
945
946 #endif
947 }
948
949 /*
950  * find out the number of processor cores on the die
951  */
952 static int __cpuinit intel_num_cpu_cores(struct cpuinfo_x86 *c)
953 {
954         unsigned int eax, t;
955
956         if (c->cpuid_level < 4)
957                 return 1;
958
959         cpuid_count(4, 0, &eax, &t, &t, &t);
960
961         if (eax & 0x1f)
962                 return ((eax >> 26) + 1);
963         else
964                 return 1;
965 }
966
967 static void srat_detect_node(void)
968 {
969 #ifdef CONFIG_NUMA
970         unsigned node;
971         int cpu = smp_processor_id();
972         int apicid = hard_smp_processor_id();
973
974         /* Don't do the funky fallback heuristics the AMD version employs
975            for now. */
976         node = apicid_to_node[apicid];
977         if (node == NUMA_NO_NODE)
978                 node = first_node(node_online_map);
979         numa_set_node(cpu, node);
980
981         if (acpi_numa > 0)
982                 printk(KERN_INFO "CPU %d/%x -> Node %d\n", cpu, apicid, node);
983 #endif
984 }
985
986 static void __cpuinit init_intel(struct cpuinfo_x86 *c)
987 {
988         /* Cache sizes */
989         unsigned n;
990
991         init_intel_cacheinfo(c);
992         if (c->cpuid_level > 9 ) {
993                 unsigned eax = cpuid_eax(10);
994                 /* Check for version and the number of counters */
995                 if ((eax & 0xff) && (((eax>>8) & 0xff) > 1))
996                         set_bit(X86_FEATURE_ARCH_PERFMON, &c->x86_capability);
997         }
998
999         n = c->extended_cpuid_level;
1000         if (n >= 0x80000008) {
1001                 unsigned eax = cpuid_eax(0x80000008);
1002                 c->x86_virt_bits = (eax >> 8) & 0xff;
1003                 c->x86_phys_bits = eax & 0xff;
1004                 /* CPUID workaround for Intel 0F34 CPU */
1005                 if (c->x86_vendor == X86_VENDOR_INTEL &&
1006                     c->x86 == 0xF && c->x86_model == 0x3 &&
1007                     c->x86_mask == 0x4)
1008                         c->x86_phys_bits = 36;
1009         }
1010
1011         if (c->x86 == 15)
1012                 c->x86_cache_alignment = c->x86_clflush_size * 2;
1013         if ((c->x86 == 0xf && c->x86_model >= 0x03) ||
1014             (c->x86 == 0x6 && c->x86_model >= 0x0e))
1015                 set_bit(X86_FEATURE_CONSTANT_TSC, &c->x86_capability);
1016         set_bit(X86_FEATURE_SYNC_RDTSC, &c->x86_capability);
1017         c->x86_max_cores = intel_num_cpu_cores(c);
1018
1019         srat_detect_node();
1020 }
1021
1022 static void __cpuinit get_cpu_vendor(struct cpuinfo_x86 *c)
1023 {
1024         char *v = c->x86_vendor_id;
1025
1026         if (!strcmp(v, "AuthenticAMD"))
1027                 c->x86_vendor = X86_VENDOR_AMD;
1028         else if (!strcmp(v, "GenuineIntel"))
1029                 c->x86_vendor = X86_VENDOR_INTEL;
1030         else
1031                 c->x86_vendor = X86_VENDOR_UNKNOWN;
1032 }
1033
1034 struct cpu_model_info {
1035         int vendor;
1036         int family;
1037         char *model_names[16];
1038 };
1039
1040 /* Do some early cpuid on the boot CPU to get some parameter that are
1041    needed before check_bugs. Everything advanced is in identify_cpu
1042    below. */
1043 void __cpuinit early_identify_cpu(struct cpuinfo_x86 *c)
1044 {
1045         u32 tfms;
1046
1047         c->loops_per_jiffy = loops_per_jiffy;
1048         c->x86_cache_size = -1;
1049         c->x86_vendor = X86_VENDOR_UNKNOWN;
1050         c->x86_model = c->x86_mask = 0; /* So far unknown... */
1051         c->x86_vendor_id[0] = '\0'; /* Unset */
1052         c->x86_model_id[0] = '\0';  /* Unset */
1053         c->x86_clflush_size = 64;
1054         c->x86_cache_alignment = c->x86_clflush_size;
1055         c->x86_max_cores = 1;
1056         c->extended_cpuid_level = 0;
1057         memset(&c->x86_capability, 0, sizeof c->x86_capability);
1058
1059         /* Get vendor name */
1060         cpuid(0x00000000, (unsigned int *)&c->cpuid_level,
1061               (unsigned int *)&c->x86_vendor_id[0],
1062               (unsigned int *)&c->x86_vendor_id[8],
1063               (unsigned int *)&c->x86_vendor_id[4]);
1064                 
1065         get_cpu_vendor(c);
1066
1067         /* Initialize the standard set of capabilities */
1068         /* Note that the vendor-specific code below might override */
1069
1070         /* Intel-defined flags: level 0x00000001 */
1071         if (c->cpuid_level >= 0x00000001) {
1072                 __u32 misc;
1073                 cpuid(0x00000001, &tfms, &misc, &c->x86_capability[4],
1074                       &c->x86_capability[0]);
1075                 c->x86 = (tfms >> 8) & 0xf;
1076                 c->x86_model = (tfms >> 4) & 0xf;
1077                 c->x86_mask = tfms & 0xf;
1078                 if (c->x86 == 0xf)
1079                         c->x86 += (tfms >> 20) & 0xff;
1080                 if (c->x86 >= 0x6)
1081                         c->x86_model += ((tfms >> 16) & 0xF) << 4;
1082                 if (c->x86_capability[0] & (1<<19)) 
1083                         c->x86_clflush_size = ((misc >> 8) & 0xff) * 8;
1084         } else {
1085                 /* Have CPUID level 0 only - unheard of */
1086                 c->x86 = 4;
1087         }
1088
1089 #ifdef CONFIG_SMP
1090         c->phys_proc_id = (cpuid_ebx(1) >> 24) & 0xff;
1091 #endif
1092 }
1093
1094 /*
1095  * This does the hard work of actually picking apart the CPU stuff...
1096  */
1097 void __cpuinit identify_cpu(struct cpuinfo_x86 *c)
1098 {
1099         int i;
1100         u32 xlvl;
1101
1102         early_identify_cpu(c);
1103
1104         /* AMD-defined flags: level 0x80000001 */
1105         xlvl = cpuid_eax(0x80000000);
1106         c->extended_cpuid_level = xlvl;
1107         if ((xlvl & 0xffff0000) == 0x80000000) {
1108                 if (xlvl >= 0x80000001) {
1109                         c->x86_capability[1] = cpuid_edx(0x80000001);
1110                         c->x86_capability[6] = cpuid_ecx(0x80000001);
1111                 }
1112                 if (xlvl >= 0x80000004)
1113                         get_model_name(c); /* Default name */
1114         }
1115
1116         /* Transmeta-defined flags: level 0x80860001 */
1117         xlvl = cpuid_eax(0x80860000);
1118         if ((xlvl & 0xffff0000) == 0x80860000) {
1119                 /* Don't set x86_cpuid_level here for now to not confuse. */
1120                 if (xlvl >= 0x80860001)
1121                         c->x86_capability[2] = cpuid_edx(0x80860001);
1122         }
1123
1124         c->apicid = phys_pkg_id(0);
1125
1126         /*
1127          * Vendor-specific initialization.  In this section we
1128          * canonicalize the feature flags, meaning if there are
1129          * features a certain CPU supports which CPUID doesn't
1130          * tell us, CPUID claiming incorrect flags, or other bugs,
1131          * we handle them here.
1132          *
1133          * At the end of this section, c->x86_capability better
1134          * indicate the features this CPU genuinely supports!
1135          */
1136         switch (c->x86_vendor) {
1137         case X86_VENDOR_AMD:
1138                 init_amd(c);
1139                 break;
1140
1141         case X86_VENDOR_INTEL:
1142                 init_intel(c);
1143                 break;
1144
1145         case X86_VENDOR_UNKNOWN:
1146         default:
1147                 display_cacheinfo(c);
1148                 break;
1149         }
1150
1151         select_idle_routine(c);
1152         detect_ht(c); 
1153
1154         /*
1155          * On SMP, boot_cpu_data holds the common feature set between
1156          * all CPUs; so make sure that we indicate which features are
1157          * common between the CPUs.  The first time this routine gets
1158          * executed, c == &boot_cpu_data.
1159          */
1160         if (c != &boot_cpu_data) {
1161                 /* AND the already accumulated flags with these */
1162                 for (i = 0 ; i < NCAPINTS ; i++)
1163                         boot_cpu_data.x86_capability[i] &= c->x86_capability[i];
1164         }
1165
1166 #ifdef CONFIG_X86_MCE
1167         mcheck_init(c);
1168 #endif
1169         if (c == &boot_cpu_data)
1170                 mtrr_bp_init();
1171         else
1172                 mtrr_ap_init();
1173 #ifdef CONFIG_NUMA
1174         numa_add_cpu(smp_processor_id());
1175 #endif
1176 }
1177  
1178
1179 void __cpuinit print_cpu_info(struct cpuinfo_x86 *c)
1180 {
1181         if (c->x86_model_id[0])
1182                 printk("%s", c->x86_model_id);
1183
1184         if (c->x86_mask || c->cpuid_level >= 0) 
1185                 printk(" stepping %02x\n", c->x86_mask);
1186         else
1187                 printk("\n");
1188 }
1189
1190 /*
1191  *      Get CPU information for use by the procfs.
1192  */
1193
1194 static int show_cpuinfo(struct seq_file *m, void *v)
1195 {
1196         struct cpuinfo_x86 *c = v;
1197
1198         /* 
1199          * These flag bits must match the definitions in <asm/cpufeature.h>.
1200          * NULL means this bit is undefined or reserved; either way it doesn't
1201          * have meaning as far as Linux is concerned.  Note that it's important
1202          * to realize there is a difference between this table and CPUID -- if
1203          * applications want to get the raw CPUID data, they should access
1204          * /dev/cpu/<cpu_nr>/cpuid instead.
1205          */
1206         static char *x86_cap_flags[] = {
1207                 /* Intel-defined */
1208                 "fpu", "vme", "de", "pse", "tsc", "msr", "pae", "mce",
1209                 "cx8", "apic", NULL, "sep", "mtrr", "pge", "mca", "cmov",
1210                 "pat", "pse36", "pn", "clflush", NULL, "dts", "acpi", "mmx",
1211                 "fxsr", "sse", "sse2", "ss", "ht", "tm", "ia64", NULL,
1212
1213                 /* AMD-defined */
1214                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1215                 NULL, NULL, NULL, "syscall", NULL, NULL, NULL, NULL,
1216                 NULL, NULL, NULL, NULL, "nx", NULL, "mmxext", NULL,
1217                 NULL, "fxsr_opt", NULL, "rdtscp", NULL, "lm", "3dnowext", "3dnow",
1218
1219                 /* Transmeta-defined */
1220                 "recovery", "longrun", NULL, "lrti", NULL, NULL, NULL, NULL,
1221                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1222                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1223                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1224
1225                 /* Other (Linux-defined) */
1226                 "cxmmx", NULL, "cyrix_arr", "centaur_mcr", NULL,
1227                 "constant_tsc", NULL, NULL,
1228                 "up", NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1229                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1230                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1231
1232                 /* Intel-defined (#2) */
1233                 "pni", NULL, NULL, "monitor", "ds_cpl", "vmx", "smx", "est",
1234                 "tm2", NULL, "cid", NULL, NULL, "cx16", "xtpr", NULL,
1235                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1236                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1237
1238                 /* VIA/Cyrix/Centaur-defined */
1239                 NULL, NULL, "rng", "rng_en", NULL, NULL, "ace", "ace_en",
1240                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1241                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1242                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1243
1244                 /* AMD-defined (#2) */
1245                 "lahf_lm", "cmp_legacy", "svm", NULL, "cr8_legacy", NULL, NULL, NULL,
1246                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1247                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1248                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1249         };
1250         static char *x86_power_flags[] = { 
1251                 "ts",   /* temperature sensor */
1252                 "fid",  /* frequency id control */
1253                 "vid",  /* voltage id control */
1254                 "ttp",  /* thermal trip */
1255                 "tm",
1256                 "stc",
1257                 NULL,
1258                 /* nothing */   /* constant_tsc - moved to flags */
1259         };
1260
1261
1262 #ifdef CONFIG_SMP
1263         if (!cpu_online(c-cpu_data))
1264                 return 0;
1265 #endif
1266
1267         seq_printf(m,"processor\t: %u\n"
1268                      "vendor_id\t: %s\n"
1269                      "cpu family\t: %d\n"
1270                      "model\t\t: %d\n"
1271                      "model name\t: %s\n",
1272                      (unsigned)(c-cpu_data),
1273                      c->x86_vendor_id[0] ? c->x86_vendor_id : "unknown",
1274                      c->x86,
1275                      (int)c->x86_model,
1276                      c->x86_model_id[0] ? c->x86_model_id : "unknown");
1277         
1278         if (c->x86_mask || c->cpuid_level >= 0)
1279                 seq_printf(m, "stepping\t: %d\n", c->x86_mask);
1280         else
1281                 seq_printf(m, "stepping\t: unknown\n");
1282         
1283         if (cpu_has(c,X86_FEATURE_TSC)) {
1284                 unsigned int freq = cpufreq_quick_get((unsigned)(c-cpu_data));
1285                 if (!freq)
1286                         freq = cpu_khz;
1287                 seq_printf(m, "cpu MHz\t\t: %u.%03u\n",
1288                              freq / 1000, (freq % 1000));
1289         }
1290
1291         /* Cache size */
1292         if (c->x86_cache_size >= 0) 
1293                 seq_printf(m, "cache size\t: %d KB\n", c->x86_cache_size);
1294         
1295 #ifdef CONFIG_SMP
1296         if (smp_num_siblings * c->x86_max_cores > 1) {
1297                 int cpu = c - cpu_data;
1298                 seq_printf(m, "physical id\t: %d\n", c->phys_proc_id);
1299                 seq_printf(m, "siblings\t: %d\n", cpus_weight(cpu_core_map[cpu]));
1300                 seq_printf(m, "core id\t\t: %d\n", c->cpu_core_id);
1301                 seq_printf(m, "cpu cores\t: %d\n", c->booted_cores);
1302         }
1303 #endif  
1304
1305         seq_printf(m,
1306                 "fpu\t\t: yes\n"
1307                 "fpu_exception\t: yes\n"
1308                 "cpuid level\t: %d\n"
1309                 "wp\t\t: yes\n"
1310                 "flags\t\t:",
1311                    c->cpuid_level);
1312
1313         { 
1314                 int i; 
1315                 for ( i = 0 ; i < 32*NCAPINTS ; i++ )
1316                         if (cpu_has(c, i) && x86_cap_flags[i] != NULL)
1317                                 seq_printf(m, " %s", x86_cap_flags[i]);
1318         }
1319                 
1320         seq_printf(m, "\nbogomips\t: %lu.%02lu\n",
1321                    c->loops_per_jiffy/(500000/HZ),
1322                    (c->loops_per_jiffy/(5000/HZ)) % 100);
1323
1324         if (c->x86_tlbsize > 0) 
1325                 seq_printf(m, "TLB size\t: %d 4K pages\n", c->x86_tlbsize);
1326         seq_printf(m, "clflush size\t: %d\n", c->x86_clflush_size);
1327         seq_printf(m, "cache_alignment\t: %d\n", c->x86_cache_alignment);
1328
1329         seq_printf(m, "address sizes\t: %u bits physical, %u bits virtual\n", 
1330                    c->x86_phys_bits, c->x86_virt_bits);
1331
1332         seq_printf(m, "power management:");
1333         {
1334                 unsigned i;
1335                 for (i = 0; i < 32; i++) 
1336                         if (c->x86_power & (1 << i)) {
1337                                 if (i < ARRAY_SIZE(x86_power_flags) &&
1338                                         x86_power_flags[i])
1339                                         seq_printf(m, "%s%s",
1340                                                 x86_power_flags[i][0]?" ":"",
1341                                                 x86_power_flags[i]);
1342                                 else
1343                                         seq_printf(m, " [%d]", i);
1344                         }
1345         }
1346
1347         seq_printf(m, "\n\n");
1348
1349         return 0;
1350 }
1351
1352 static void *c_start(struct seq_file *m, loff_t *pos)
1353 {
1354         return *pos < NR_CPUS ? cpu_data + *pos : NULL;
1355 }
1356
1357 static void *c_next(struct seq_file *m, void *v, loff_t *pos)
1358 {
1359         ++*pos;
1360         return c_start(m, pos);
1361 }
1362
1363 static void c_stop(struct seq_file *m, void *v)
1364 {
1365 }
1366
1367 struct seq_operations cpuinfo_op = {
1368         .start =c_start,
1369         .next = c_next,
1370         .stop = c_stop,
1371         .show = show_cpuinfo,
1372 };
1373
1374 #if defined(CONFIG_INPUT_PCSPKR) || defined(CONFIG_INPUT_PCSPKR_MODULE)
1375 #include <linux/platform_device.h>
1376 static __init int add_pcspkr(void)
1377 {
1378         struct platform_device *pd;
1379         int ret;
1380
1381         pd = platform_device_alloc("pcspkr", -1);
1382         if (!pd)
1383                 return -ENOMEM;
1384
1385         ret = platform_device_add(pd);
1386         if (ret)
1387                 platform_device_put(pd);
1388
1389         return ret;
1390 }
1391 device_initcall(add_pcspkr);
1392 #endif