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