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