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