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