projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] cpusets+hotplug+preepmt broken
[deliverable/linux.git] / arch / x86_64 / kernel / setup.c
CommitLineData
1da177e4
LT		 1/*
2 * linux/arch/x86-64/kernel/setup.c
3 *
4 * Copyright (C) 1995 Linus Torvalds
5 *
6 * Nov 2001 Dave Jones <davej@suse.de>
7 * Forked from i386 setup code.
8 *
9 * $Id$
10 */
11
12/*
13 * This file handles the architecture-dependent parts of initialization
14 */
15
16#include <linux/errno.h>
17#include <linux/sched.h>
18#include <linux/kernel.h>
19#include <linux/mm.h>
20#include <linux/stddef.h>
21#include <linux/unistd.h>
22#include <linux/ptrace.h>
23#include <linux/slab.h>
24#include <linux/user.h>
25#include <linux/a.out.h>
26#include <linux/tty.h>
27#include <linux/ioport.h>
28#include <linux/delay.h>
29#include <linux/config.h>
30#include <linux/init.h>
31#include <linux/initrd.h>
32#include <linux/highmem.h>
33#include <linux/bootmem.h>
34#include <linux/module.h>
35#include <asm/processor.h>
36#include <linux/console.h>
37#include <linux/seq_file.h>
38#include <linux/root_dev.h>
39#include <linux/pci.h>
40#include <linux/acpi.h>
41#include <linux/kallsyms.h>
42#include <linux/edd.h>
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/bootsetup.h>
56#include <asm/proto.h>
57#include <asm/setup.h>
58#include <asm/mach_apic.h>
59#include <asm/numa.h>
60
61/*
62 * Machine setup..
63 */
64
65struct cpuinfo_x86 boot_cpu_data;
66
67unsigned long mmu_cr4_features;
68
69int acpi_disabled;
70EXPORT_SYMBOL(acpi_disabled);
71#ifdef CONFIG_ACPI_BOOT
72extern int __initdata acpi_ht;
73extern acpi_interrupt_flags acpi_sci_flags;
74int __initdata acpi_force = 0;
75#endif
76
77int acpi_numa __initdata;
78
1da177e4
LT		 79/* Boot loader ID as an integer, for the benefit of proc_dointvec */
80int bootloader_type;
81
82unsigned long saved_video_mode;
83
84#ifdef CONFIG_SWIOTLB
85int swiotlb;
86EXPORT_SYMBOL(swiotlb);
87#endif
88
89/*
90 * Setup options
91 */
92struct drive_info_struct { char dummy[32]; } drive_info;
93struct screen_info screen_info;
94struct sys_desc_table_struct {
95 unsigned short length;
96 unsigned char table[0];
97};
98
99struct edid_info edid_info;
100struct e820map e820;
101
102extern int root_mountflags;
103extern char _text, _etext, _edata, _end;
104
105char command_line[COMMAND_LINE_SIZE];
106
107struct resource standard_io_resources[] = {
108 { .name = "dma1", .start = 0x00, .end = 0x1f,
109 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
110 { .name = "pic1", .start = 0x20, .end = 0x21,
111 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
112 { .name = "timer0", .start = 0x40, .end = 0x43,
113 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
114 { .name = "timer1", .start = 0x50, .end = 0x53,
115 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
116 { .name = "keyboard", .start = 0x60, .end = 0x6f,
117 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
118 { .name = "dma page reg", .start = 0x80, .end = 0x8f,
119 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
120 { .name = "pic2", .start = 0xa0, .end = 0xa1,
121 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
122 { .name = "dma2", .start = 0xc0, .end = 0xdf,
123 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
124 { .name = "fpu", .start = 0xf0, .end = 0xff,
125 .flags = IORESOURCE_BUSY | IORESOURCE_IO }
126};
127
128#define STANDARD_IO_RESOURCES \
129 (sizeof standard_io_resources / sizeof standard_io_resources[0])
130
131#define IORESOURCE_RAM (IORESOURCE_BUSY | IORESOURCE_MEM)
132
133struct resource data_resource = {
134 .name = "Kernel data",
135 .start = 0,
136 .end = 0,
137 .flags = IORESOURCE_RAM,
138};
139struct resource code_resource = {
140 .name = "Kernel code",
141 .start = 0,
142 .end = 0,
143 .flags = IORESOURCE_RAM,
144};
145
146#define IORESOURCE_ROM (IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM)
147
148static struct resource system_rom_resource = {
149 .name = "System ROM",
150 .start = 0xf0000,
151 .end = 0xfffff,
152 .flags = IORESOURCE_ROM,
153};
154
155static struct resource extension_rom_resource = {
156 .name = "Extension ROM",
157 .start = 0xe0000,
158 .end = 0xeffff,
159 .flags = IORESOURCE_ROM,
160};
161
162static struct resource adapter_rom_resources[] = {
163 { .name = "Adapter ROM", .start = 0xc8000, .end = 0,
164 .flags = IORESOURCE_ROM },
165 { .name = "Adapter ROM", .start = 0, .end = 0,
166 .flags = IORESOURCE_ROM },
167 { .name = "Adapter ROM", .start = 0, .end = 0,
168 .flags = IORESOURCE_ROM },
169 { .name = "Adapter ROM", .start = 0, .end = 0,
170 .flags = IORESOURCE_ROM },
171 { .name = "Adapter ROM", .start = 0, .end = 0,
172 .flags = IORESOURCE_ROM },
173 { .name = "Adapter ROM", .start = 0, .end = 0,
174 .flags = IORESOURCE_ROM }
175};
176
177#define ADAPTER_ROM_RESOURCES \
178 (sizeof adapter_rom_resources / sizeof adapter_rom_resources[0])
179
180static struct resource video_rom_resource = {
181 .name = "Video ROM",
182 .start = 0xc0000,
183 .end = 0xc7fff,
184 .flags = IORESOURCE_ROM,
185};
186
187static struct resource video_ram_resource = {
188 .name = "Video RAM area",
189 .start = 0xa0000,
190 .end = 0xbffff,
191 .flags = IORESOURCE_RAM,
192};
193
194#define romsignature(x) (*(unsigned short *)(x) == 0xaa55)
195
196static int __init romchecksum(unsigned char *rom, unsigned long length)
197{
198 unsigned char *p, sum = 0;
199
200 for (p = rom; p < rom + length; p++)
201 sum += *p;
202 return sum == 0;
203}
204
205static void __init probe_roms(void)
206{
207 unsigned long start, length, upper;
208 unsigned char *rom;
209 int i;
210
211 /* video rom */
212 upper = adapter_rom_resources[0].start;
213 for (start = video_rom_resource.start; start < upper; start += 2048) {
214 rom = isa_bus_to_virt(start);
215 if (!romsignature(rom))
216 continue;
217
218 video_rom_resource.start = start;
219
220 /* 0 < length <= 0x7f * 512, historically */
221 length = rom[2] * 512;
222
223 /* if checksum okay, trust length byte */
224 if (length && romchecksum(rom, length))
225 video_rom_resource.end = start + length - 1;
226
227 request_resource(&iomem_resource, &video_rom_resource);
228 break;
229 }
230
231 start = (video_rom_resource.end + 1 + 2047) & ~2047UL;
232 if (start < upper)
233 start = upper;
234
235 /* system rom */
236 request_resource(&iomem_resource, &system_rom_resource);
237 upper = system_rom_resource.start;
238
239 /* check for extension rom (ignore length byte!) */
240 rom = isa_bus_to_virt(extension_rom_resource.start);
241 if (romsignature(rom)) {
242 length = extension_rom_resource.end - extension_rom_resource.start + 1;
243 if (romchecksum(rom, length)) {
244 request_resource(&iomem_resource, &extension_rom_resource);
245 upper = extension_rom_resource.start;
246 }
247 }
248
249 /* check for adapter roms on 2k boundaries */
250 for (i = 0; i < ADAPTER_ROM_RESOURCES && start < upper; start += 2048) {
251 rom = isa_bus_to_virt(start);
252 if (!romsignature(rom))
253 continue;
254
255 /* 0 < length <= 0x7f * 512, historically */
256 length = rom[2] * 512;
257
258 /* but accept any length that fits if checksum okay */
259 if (!length || start + length > upper || !romchecksum(rom, length))
260 continue;
261
262 adapter_rom_resources[i].start = start;
263 adapter_rom_resources[i].end = start + length - 1;
264 request_resource(&iomem_resource, &adapter_rom_resources[i]);
265
266 start = adapter_rom_resources[i++].end & ~2047UL;
267 }
268}
269
270static __init void parse_cmdline_early (char ** cmdline_p)
271{
272 char c = ' ', *to = command_line, *from = COMMAND_LINE;
273 int len = 0;
274
275 /* Save unparsed command line copy for /proc/cmdline */
276 memcpy(saved_command_line, COMMAND_LINE, COMMAND_LINE_SIZE);
277 saved_command_line[COMMAND_LINE_SIZE-1] = '\0';
278
279 for (;;) {
280 if (c != ' ')
281 goto next_char;
282
283#ifdef CONFIG_SMP
284 /*
285 * If the BIOS enumerates physical processors before logical,
286 * maxcpus=N at enumeration-time can be used to disable HT.
287 */
288 else if (!memcmp(from, "maxcpus=", 8)) {
289 extern unsigned int maxcpus;
290
291 maxcpus = simple_strtoul(from + 8, NULL, 0);
292 }
293#endif
294#ifdef CONFIG_ACPI_BOOT
295 /* "acpi=off" disables both ACPI table parsing and interpreter init */
296 if (!memcmp(from, "acpi=off", 8))
297 disable_acpi();
298
299 if (!memcmp(from, "acpi=force", 10)) {
300 /* add later when we do DMI horrors: */
301 acpi_force = 1;
302 acpi_disabled = 0;
303 }
304
305 /* acpi=ht just means: do ACPI MADT parsing
306 at bootup, but don't enable the full ACPI interpreter */
307 if (!memcmp(from, "acpi=ht", 7)) {
308 if (!acpi_force)
309 disable_acpi();
310 acpi_ht = 1;
311 }
312 else if (!memcmp(from, "pci=noacpi", 10))
313 acpi_disable_pci();
314 else if (!memcmp(from, "acpi=noirq", 10))
315 acpi_noirq_set();
316
317 else if (!memcmp(from, "acpi_sci=edge", 13))
318 acpi_sci_flags.trigger = 1;
319 else if (!memcmp(from, "acpi_sci=level", 14))
320 acpi_sci_flags.trigger = 3;
321 else if (!memcmp(from, "acpi_sci=high", 13))
322 acpi_sci_flags.polarity = 1;
323 else if (!memcmp(from, "acpi_sci=low", 12))
324 acpi_sci_flags.polarity = 3;
325
326 /* acpi=strict disables out-of-spec workarounds */
327 else if (!memcmp(from, "acpi=strict", 11)) {
328 acpi_strict = 1;
329 }
22999244
AK		 330#ifdef CONFIG_X86_IO_APIC
331 else if (!memcmp(from, "acpi_skip_timer_override", 24))
332 acpi_skip_timer_override = 1;
333#endif
1da177e4
LT		 334#endif
335
336 if (!memcmp(from, "nolapic", 7) ||
337 !memcmp(from, "disableapic", 11))
338 disable_apic = 1;
339
340 if (!memcmp(from, "noapic", 6))
341 skip_ioapic_setup = 1;
342
343 if (!memcmp(from, "apic", 4)) {
344 skip_ioapic_setup = 0;
345 ioapic_force = 1;
346 }
347
348 if (!memcmp(from, "mem=", 4))
349 parse_memopt(from+4, &from);
350
351#ifdef CONFIG_DISCONTIGMEM
352 if (!memcmp(from, "numa=", 5))
353 numa_setup(from+5);
354#endif
355
356#ifdef CONFIG_GART_IOMMU
357 if (!memcmp(from,"iommu=",6)) {
358 iommu_setup(from+6);
359 }
360#endif
361
362 if (!memcmp(from,"oops=panic", 10))
363 panic_on_oops = 1;
364
365 if (!memcmp(from, "noexec=", 7))
366 nonx_setup(from + 7);
367
368 next_char:
369 c = *(from++);
370 if (!c)
371 break;
372 if (COMMAND_LINE_SIZE <= ++len)
373 break;
374 *(to++) = c;
375 }
376 *to = '\0';
377 *cmdline_p = command_line;
378}
379
380#ifndef CONFIG_DISCONTIGMEM
381static void __init contig_initmem_init(void)
382{
383 unsigned long bootmap_size, bootmap;
384 bootmap_size = bootmem_bootmap_pages(end_pfn)<<PAGE_SHIFT;
385 bootmap = find_e820_area(0, end_pfn<<PAGE_SHIFT, bootmap_size);
386 if (bootmap == -1L)
387 panic("Cannot find bootmem map of size %ld\n",bootmap_size);
388 bootmap_size = init_bootmem(bootmap >> PAGE_SHIFT, end_pfn);
389 e820_bootmem_free(&contig_page_data, 0, end_pfn << PAGE_SHIFT);
390 reserve_bootmem(bootmap, bootmap_size);
391}
392#endif
393
394/* Use inline assembly to define this because the nops are defined
395 as inline assembly strings in the include files and we cannot
396 get them easily into strings. */
397asm("\t.data\nk8nops: "
398 K8_NOP1 K8_NOP2 K8_NOP3 K8_NOP4 K8_NOP5 K8_NOP6
399 K8_NOP7 K8_NOP8);
400
401extern unsigned char k8nops[];
402static unsigned char *k8_nops[ASM_NOP_MAX+1] = {
403 NULL,
404 k8nops,
405 k8nops + 1,
406 k8nops + 1 + 2,
407 k8nops + 1 + 2 + 3,
408 k8nops + 1 + 2 + 3 + 4,
409 k8nops + 1 + 2 + 3 + 4 + 5,
410 k8nops + 1 + 2 + 3 + 4 + 5 + 6,
411 k8nops + 1 + 2 + 3 + 4 + 5 + 6 + 7,
412};
413
414/* Replace instructions with better alternatives for this CPU type.
415
416 This runs before SMP is initialized to avoid SMP problems with
417 self modifying code. This implies that assymetric systems where
418 APs have less capabilities than the boot processor are not handled.
419 In this case boot with "noreplacement". */
420void apply_alternatives(void *start, void *end)
421{
422 struct alt_instr *a;
423 int diff, i, k;
424 for (a = start; (void *)a < end; a++) {
425 if (!boot_cpu_has(a->cpuid))
426 continue;
427
428 BUG_ON(a->replacementlen > a->instrlen);
429 __inline_memcpy(a->instr, a->replacement, a->replacementlen);
430 diff = a->instrlen - a->replacementlen;
431
432 /* Pad the rest with nops */
433 for (i = a->replacementlen; diff > 0; diff -= k, i += k) {
434 k = diff;
435 if (k > ASM_NOP_MAX)
436 k = ASM_NOP_MAX;
437 __inline_memcpy(a->instr + i, k8_nops[k], k);
438 }
439 }
440}
441
442static int no_replacement __initdata = 0;
443
444void __init alternative_instructions(void)
445{
446 extern struct alt_instr __alt_instructions[], __alt_instructions_end[];
447 if (no_replacement)
448 return;
449 apply_alternatives(__alt_instructions, __alt_instructions_end);
450}
451
452static int __init noreplacement_setup(char *s)
453{
454 no_replacement = 1;
455 return 0;
456}
457
458__setup("noreplacement", noreplacement_setup);
459
460#if defined(CONFIG_EDD) || defined(CONFIG_EDD_MODULE)
461struct edd edd;
462#ifdef CONFIG_EDD_MODULE
463EXPORT_SYMBOL(edd);
464#endif
465/**
466 * copy_edd() - Copy the BIOS EDD information
467 * from boot_params into a safe place.
468 *
469 */
470static inline void copy_edd(void)
471{
472 memcpy(edd.mbr_signature, EDD_MBR_SIGNATURE, sizeof(edd.mbr_signature));
473 memcpy(edd.edd_info, EDD_BUF, sizeof(edd.edd_info));
474 edd.mbr_signature_nr = EDD_MBR_SIG_NR;
475 edd.edd_info_nr = EDD_NR;
476}
477#else
478static inline void copy_edd(void)
479{
480}
481#endif
482
483#define EBDA_ADDR_POINTER 0x40E
484static void __init reserve_ebda_region(void)
485{
486 unsigned int addr;
487 /**
488 * there is a real-mode segmented pointer pointing to the
489 * 4K EBDA area at 0x40E
490 */
491 addr = *(unsigned short *)phys_to_virt(EBDA_ADDR_POINTER);
492 addr <<= 4;
493 if (addr)
494 reserve_bootmem_generic(addr, PAGE_SIZE);
495}
496
497void __init setup_arch(char **cmdline_p)
498{
1da177e4
LT		 499 unsigned long kernel_end;
500
501 ROOT_DEV = old_decode_dev(ORIG_ROOT_DEV);
502 drive_info = DRIVE_INFO;
503 screen_info = SCREEN_INFO;
504 edid_info = EDID_INFO;
505 saved_video_mode = SAVED_VIDEO_MODE;
506 bootloader_type = LOADER_TYPE;
507
508#ifdef CONFIG_BLK_DEV_RAM
509 rd_image_start = RAMDISK_FLAGS & RAMDISK_IMAGE_START_MASK;
510 rd_prompt = ((RAMDISK_FLAGS & RAMDISK_PROMPT_FLAG) != 0);
511 rd_doload = ((RAMDISK_FLAGS & RAMDISK_LOAD_FLAG) != 0);
512#endif
513 setup_memory_region();
514 copy_edd();
515
516 if (!MOUNT_ROOT_RDONLY)
517 root_mountflags &= ~MS_RDONLY;
518 init_mm.start_code = (unsigned long) &_text;
519 init_mm.end_code = (unsigned long) &_etext;
520 init_mm.end_data = (unsigned long) &_edata;
521 init_mm.brk = (unsigned long) &_end;
522
523 code_resource.start = virt_to_phys(&_text);
524 code_resource.end = virt_to_phys(&_etext)-1;
525 data_resource.start = virt_to_phys(&_etext);
526 data_resource.end = virt_to_phys(&_edata)-1;
527
528 parse_cmdline_early(cmdline_p);
529
530 early_identify_cpu(&boot_cpu_data);
531
532 /*
533 * partially used pages are not usable - thus
534 * we are rounding upwards:
535 */
536 end_pfn = e820_end_of_ram();
537
538 check_efer();
539
540 init_memory_mapping(0, (end_pfn_map << PAGE_SHIFT));
541
542#ifdef CONFIG_ACPI_BOOT
543 /*
544 * Initialize the ACPI boot-time table parser (gets the RSDP and SDT).
545 * Call this early for SRAT node setup.
546 */
547 acpi_boot_table_init();
548#endif
549
550#ifdef CONFIG_ACPI_NUMA
551 /*
552 * Parse SRAT to discover nodes.
553 */
554 acpi_numa_init();
555#endif
556
557#ifdef CONFIG_DISCONTIGMEM
558 numa_initmem_init(0, end_pfn);
559#else
560 contig_initmem_init();
561#endif
562
563 /* Reserve direct mapping */
564 reserve_bootmem_generic(table_start << PAGE_SHIFT,
565 (table_end - table_start) << PAGE_SHIFT);
566
567 /* reserve kernel */
568 kernel_end = round_up(__pa_symbol(&_end),PAGE_SIZE);
569 reserve_bootmem_generic(HIGH_MEMORY, kernel_end - HIGH_MEMORY);
570
571 /*
572 * reserve physical page 0 - it's a special BIOS page on many boxes,
573 * enabling clean reboots, SMP operation, laptop functions.
574 */
575 reserve_bootmem_generic(0, PAGE_SIZE);
576
577 /* reserve ebda region */
578 reserve_ebda_region();
579
580#ifdef CONFIG_SMP
581 /*
582 * But first pinch a few for the stack/trampoline stuff
583 * FIXME: Don't need the extra page at 4K, but need to fix
584 * trampoline before removing it. (see the GDT stuff)
585 */
586 reserve_bootmem_generic(PAGE_SIZE, PAGE_SIZE);
587
588 /* Reserve SMP trampoline */
589 reserve_bootmem_generic(SMP_TRAMPOLINE_BASE, PAGE_SIZE);
590#endif
591
592#ifdef CONFIG_ACPI_SLEEP
593 /*
594 * Reserve low memory region for sleep support.
595 */
596 acpi_reserve_bootmem();
597#endif
598#ifdef CONFIG_X86_LOCAL_APIC
599 /*
600 * Find and reserve possible boot-time SMP configuration:
601 */
602 find_smp_config();
603#endif
604#ifdef CONFIG_BLK_DEV_INITRD
605 if (LOADER_TYPE && INITRD_START) {
606 if (INITRD_START + INITRD_SIZE <= (end_pfn << PAGE_SHIFT)) {
607 reserve_bootmem_generic(INITRD_START, INITRD_SIZE);
608 initrd_start =
609 INITRD_START ? INITRD_START + PAGE_OFFSET : 0;
610 initrd_end = initrd_start+INITRD_SIZE;
611 }
612 else {
613 printk(KERN_ERR "initrd extends beyond end of memory "
614 "(0x%08lx > 0x%08lx)\ndisabling initrd\n",
615 (unsigned long)(INITRD_START + INITRD_SIZE),
616 (unsigned long)(end_pfn << PAGE_SHIFT));
617 initrd_start = 0;
618 }
619 }
620#endif
621 paging_init();
622
623 check_ioapic();
624
625#ifdef CONFIG_ACPI_BOOT
626 /*
627 * Read APIC and some other early information from ACPI tables.
628 */
629 acpi_boot_init();
630#endif
631
632#ifdef CONFIG_X86_LOCAL_APIC
633 /*
634 * get boot-time SMP configuration:
635 */
636 if (smp_found_config)
637 get_smp_config();
638 init_apic_mappings();
639#endif
640
641 /*
642 * Request address space for all standard RAM and ROM resources
643 * and also for regions reported as reserved by the e820.
644 */
645 probe_roms();
646 e820_reserve_resources();
647
648 request_resource(&iomem_resource, &video_ram_resource);
649
650 {
651 unsigned i;
652 /* request I/O space for devices used on all i[345]86 PCs */
653 for (i = 0; i < STANDARD_IO_RESOURCES; i++)
654 request_resource(&ioport_resource, &standard_io_resources[i]);
655 }
656
a1e97782 657 e820_setup_gap();
1da177e4
LT		 658
659#ifdef CONFIG_GART_IOMMU
660 iommu_hole_init();
661#endif
662
663#ifdef CONFIG_VT
664#if defined(CONFIG_VGA_CONSOLE)
665 conswitchp = &vga_con;
666#elif defined(CONFIG_DUMMY_CONSOLE)
667 conswitchp = &dummy_con;
668#endif
669#endif
670}
671
672static int __init get_model_name(struct cpuinfo_x86 *c)
673{
674 unsigned int *v;
675
ebfcaa96 676 if (c->extended_cpuid_level < 0x80000004)
1da177e4
LT		 677 return 0;
678
679 v = (unsigned int *) c->x86_model_id;
680 cpuid(0x80000002, &v[0], &v[1], &v[2], &v[3]);
681 cpuid(0x80000003, &v[4], &v[5], &v[6], &v[7]);
682 cpuid(0x80000004, &v[8], &v[9], &v[10], &v[11]);
683 c->x86_model_id[48] = 0;
684 return 1;
685}
686
687
688static void __init display_cacheinfo(struct cpuinfo_x86 *c)
689{
690 unsigned int n, dummy, eax, ebx, ecx, edx;
691
ebfcaa96 692 n = c->extended_cpuid_level;
1da177e4
LT		 693
694 if (n >= 0x80000005) {
695 cpuid(0x80000005, &dummy, &ebx, &ecx, &edx);
696 printk(KERN_INFO "CPU: L1 I Cache: %dK (%d bytes/line), D cache %dK (%d bytes/line)\n",
697 edx>>24, edx&0xFF, ecx>>24, ecx&0xFF);
698 c->x86_cache_size=(ecx>>24)+(edx>>24);
699 /* On K8 L1 TLB is inclusive, so don't count it */
700 c->x86_tlbsize = 0;
701 }
702
703 if (n >= 0x80000006) {
704 cpuid(0x80000006, &dummy, &ebx, &ecx, &edx);
705 ecx = cpuid_ecx(0x80000006);
706 c->x86_cache_size = ecx >> 16;
707 c->x86_tlbsize += ((ebx >> 16) & 0xfff) + (ebx & 0xfff);
708
709 printk(KERN_INFO "CPU: L2 Cache: %dK (%d bytes/line)\n",
710 c->x86_cache_size, ecx & 0xFF);
711 }
712
713 if (n >= 0x80000007)
714 cpuid(0x80000007, &dummy, &dummy, &dummy, &c->x86_power);
715 if (n >= 0x80000008) {
716 cpuid(0x80000008, &eax, &dummy, &dummy, &dummy);
717 c->x86_virt_bits = (eax >> 8) & 0xff;
718 c->x86_phys_bits = eax & 0xff;
719 }
720}
721
63518644
AK		 722#ifdef CONFIG_SMP
723/*
724 * On a AMD dual core setup the lower bits of the APIC id distingush the cores.
725 * Assumes number of cores is a power of two.
726 */
727static void __init amd_detect_cmp(struct cpuinfo_x86 *c)
728{
729#ifdef CONFIG_SMP
2942283e 730 int cpu = smp_processor_id();
63518644
AK		 731 int node = 0;
732 if (c->x86_num_cores == 1)
733 return;
a158608b
AK		 734 /* Fix up the APIC ID following the AMD specification. */
735 cpu_core_id[cpu] >>= hweight32(c->x86_num_cores - 1);
63518644
AK		 736
737#ifdef CONFIG_NUMA
738 /* When an ACPI SRAT table is available use the mappings from SRAT
739 instead. */
740 if (acpi_numa <= 0) {
741 node = cpu_core_id[cpu];
742 if (!node_online(node))
743 node = first_node(node_online_map);
744 cpu_to_node[cpu] = node;
745 } else {
746 node = cpu_to_node[cpu];
747 }
748#endif
a158608b
AK		 749 /* For now: - better than BAD_APIC_ID at least*/
750 phys_proc_id[cpu] = cpu_core_id[cpu];
751
63518644
AK		 752 printk(KERN_INFO "CPU %d(%d) -> Node %d -> Core %d\n",
753 cpu, c->x86_num_cores, node, cpu_core_id[cpu]);
754#endif
755}
756#else
757static void __init amd_detect_cmp(struct cpuinfo_x86 *c)
758{
759}
760#endif
1da177e4
LT		 761
762static int __init init_amd(struct cpuinfo_x86 *c)
763{
764 int r;
765 int level;
1da177e4
LT		 766
767 /* Bit 31 in normal CPUID used for nonstandard 3DNow ID;
768 3DNow is IDd by bit 31 in extended CPUID (1*32+31) anyway */
769 clear_bit(0*32+31, &c->x86_capability);
770
771 /* C-stepping K8? */
772 level = cpuid_eax(1);
773 if ((level >= 0x0f48 && level < 0x0f50) || level >= 0x0f58)
774 set_bit(X86_FEATURE_K8_C, &c->x86_capability);
775
776 r = get_model_name(c);
777 if (!r) {
778 switch (c->x86) {
779 case 15:
780 /* Should distinguish Models here, but this is only
781 a fallback anyways. */
782 strcpy(c->x86_model_id, "Hammer");
783 break;
784 }
785 }
786 display_cacheinfo(c);
787
ebfcaa96 788 if (c->extended_cpuid_level >= 0x80000008) {
1da177e4
LT		 789 c->x86_num_cores = (cpuid_ecx(0x80000008) & 0xff) + 1;
790 if (c->x86_num_cores & (c->x86_num_cores - 1))
791 c->x86_num_cores = 1;
792
63518644 793 amd_detect_cmp(c);
1da177e4
LT		 794 }
795
796 return r;
797}
798
799static void __init detect_ht(struct cpuinfo_x86 *c)
800{
801#ifdef CONFIG_SMP
802 u32 eax, ebx, ecx, edx;
3dd9d514 803 int index_msb, tmp;
1da177e4
LT		 804 int cpu = smp_processor_id();
805
63518644 806 if (!cpu_has(c, X86_FEATURE_HT) || cpu_has(c, X86_FEATURE_CMP_LEGACY))
1da177e4
LT		 807 return;
808
809 cpuid(1, &eax, &ebx, &ecx, &edx);
810 smp_num_siblings = (ebx & 0xff0000) >> 16;
811
812 if (smp_num_siblings == 1) {
813 printk(KERN_INFO "CPU: Hyper-Threading is disabled\n");
814 } else if (smp_num_siblings > 1) {
1da177e4
LT		 815 index_msb = 31;
816 /*
817 * At this point we only support two siblings per
818 * processor package.
819 */
820 if (smp_num_siblings > NR_CPUS) {
821 printk(KERN_WARNING "CPU: Unsupported number of the siblings %d", smp_num_siblings);
822 smp_num_siblings = 1;
823 return;
824 }
825 tmp = smp_num_siblings;
1da177e4
LT		 826 while ((tmp & 0x80000000 ) == 0) {
827 tmp <<=1 ;
828 index_msb--;
829 }
3dd9d514 830 if (smp_num_siblings & (smp_num_siblings - 1))
1da177e4
LT		 831 index_msb++;
832 phys_proc_id[cpu] = phys_pkg_id(index_msb);
833
834 printk(KERN_INFO "CPU: Physical Processor ID: %d\n",
835 phys_proc_id[cpu]);
3dd9d514
AK		 836
837 smp_num_siblings = smp_num_siblings / c->x86_num_cores;
838
839 tmp = smp_num_siblings;
840 index_msb = 31;
841 while ((tmp & 0x80000000) == 0) {
842 tmp <<=1 ;
843 index_msb--;
844 }
845 if (smp_num_siblings & (smp_num_siblings - 1))
846 index_msb++;
847
848 cpu_core_id[cpu] = phys_pkg_id(index_msb);
849
850 if (c->x86_num_cores > 1)
851 printk(KERN_INFO "CPU: Processor Core ID: %d\n",
852 cpu_core_id[cpu]);
1da177e4
LT		 853 }
854#endif
855}
856
3dd9d514
AK		 857/*
858 * find out the number of processor cores on the die
859 */
860static int __init intel_num_cpu_cores(struct cpuinfo_x86 *c)
861{
862 unsigned int eax;
863
864 if (c->cpuid_level < 4)
865 return 1;
866
867 __asm__("cpuid"
868 : "=a" (eax)
869 : "0" (4), "c" (0)
870 : "bx", "dx");
871
872 if (eax & 0x1f)
873 return ((eax >> 26) + 1);
874 else
875 return 1;
876}
877
1da177e4
LT		 878static void __init init_intel(struct cpuinfo_x86 *c)
879{
880 /* Cache sizes */
881 unsigned n;
882
883 init_intel_cacheinfo(c);
ebfcaa96 884 n = c->extended_cpuid_level;
1da177e4
LT		 885 if (n >= 0x80000008) {
886 unsigned eax = cpuid_eax(0x80000008);
887 c->x86_virt_bits = (eax >> 8) & 0xff;
888 c->x86_phys_bits = eax & 0xff;
889 }
890
891 if (c->x86 == 15)
892 c->x86_cache_alignment = c->x86_clflush_size * 2;
c29601e9
AK		 893 if (c->x86 >= 15)
894 set_bit(X86_FEATURE_CONSTANT_TSC, &c->x86_capability);
3dd9d514 895 c->x86_num_cores = intel_num_cpu_cores(c);
1da177e4
LT		 896}
897
898void __init get_cpu_vendor(struct cpuinfo_x86 *c)
899{
900 char *v = c->x86_vendor_id;
901
902 if (!strcmp(v, "AuthenticAMD"))
903 c->x86_vendor = X86_VENDOR_AMD;
904 else if (!strcmp(v, "GenuineIntel"))
905 c->x86_vendor = X86_VENDOR_INTEL;
906 else
907 c->x86_vendor = X86_VENDOR_UNKNOWN;
908}
909
910struct cpu_model_info {
911 int vendor;
912 int family;
913 char *model_names[16];
914};
915
916/* Do some early cpuid on the boot CPU to get some parameter that are
917 needed before check_bugs. Everything advanced is in identify_cpu
918 below. */
919void __init early_identify_cpu(struct cpuinfo_x86 *c)
920{
921 u32 tfms;
922
923 c->loops_per_jiffy = loops_per_jiffy;
924 c->x86_cache_size = -1;
925 c->x86_vendor = X86_VENDOR_UNKNOWN;
926 c->x86_model = c->x86_mask = 0; /* So far unknown... */
927 c->x86_vendor_id[0] = '\0'; /* Unset */
928 c->x86_model_id[0] = '\0'; /* Unset */
929 c->x86_clflush_size = 64;
930 c->x86_cache_alignment = c->x86_clflush_size;
931 c->x86_num_cores = 1;
ebfcaa96 932 c->extended_cpuid_level = 0;
1da177e4
LT		 933 memset(&c->x86_capability, 0, sizeof c->x86_capability);
934
935 /* Get vendor name */
936 cpuid(0x00000000, (unsigned int *)&c->cpuid_level,
937 (unsigned int *)&c->x86_vendor_id[0],
938 (unsigned int *)&c->x86_vendor_id[8],
939 (unsigned int *)&c->x86_vendor_id[4]);
940
941 get_cpu_vendor(c);
942
943 /* Initialize the standard set of capabilities */
944 /* Note that the vendor-specific code below might override */
945
946 /* Intel-defined flags: level 0x00000001 */
947 if (c->cpuid_level >= 0x00000001) {
948 __u32 misc;
949 cpuid(0x00000001, &tfms, &misc, &c->x86_capability[4],
950 &c->x86_capability[0]);
951 c->x86 = (tfms >> 8) & 0xf;
952 c->x86_model = (tfms >> 4) & 0xf;
953 c->x86_mask = tfms & 0xf;
954 if (c->x86 == 0xf) {
955 c->x86 += (tfms >> 20) & 0xff;
956 c->x86_model += ((tfms >> 16) & 0xF) << 4;
957 }
958 if (c->x86_capability[0] & (1<<19))
959 c->x86_clflush_size = ((misc >> 8) & 0xff) * 8;
1da177e4
LT		 960 } else {
961 /* Have CPUID level 0 only - unheard of */
962 c->x86 = 4;
963 }
a158608b
AK		 964
965#ifdef CONFIG_SMP
966 phys_proc_id[smp_processor_id()] =
967 cpu_core_id[smp_processor_id()] = (cpuid_ebx(1) >> 24) & 0xff;
968#endif
1da177e4
LT		 969}
970
971/*
972 * This does the hard work of actually picking apart the CPU stuff...
973 */
974void __init identify_cpu(struct cpuinfo_x86 *c)
975{
976 int i;
977 u32 xlvl;
978
979 early_identify_cpu(c);
980
981 /* AMD-defined flags: level 0x80000001 */
982 xlvl = cpuid_eax(0x80000000);
ebfcaa96 983 c->extended_cpuid_level = xlvl;
1da177e4
LT		 984 if ((xlvl & 0xffff0000) == 0x80000000) {
985 if (xlvl >= 0x80000001) {
986 c->x86_capability[1] = cpuid_edx(0x80000001);
5b7abc6f 987 c->x86_capability[6] = cpuid_ecx(0x80000001);
1da177e4
LT		 988 }
989 if (xlvl >= 0x80000004)
990 get_model_name(c); /* Default name */
991 }
992
993 /* Transmeta-defined flags: level 0x80860001 */
994 xlvl = cpuid_eax(0x80860000);
995 if ((xlvl & 0xffff0000) == 0x80860000) {
996 /* Don't set x86_cpuid_level here for now to not confuse. */
997 if (xlvl >= 0x80860001)
998 c->x86_capability[2] = cpuid_edx(0x80860001);
999 }
1000
1001 /*
1002 * Vendor-specific initialization. In this section we
1003 * canonicalize the feature flags, meaning if there are
1004 * features a certain CPU supports which CPUID doesn't
1005 * tell us, CPUID claiming incorrect flags, or other bugs,
1006 * we handle them here.
1007 *
1008 * At the end of this section, c->x86_capability better
1009 * indicate the features this CPU genuinely supports!
1010 */
1011 switch (c->x86_vendor) {
1012 case X86_VENDOR_AMD:
1013 init_amd(c);
1014 break;
1015
1016 case X86_VENDOR_INTEL:
1017 init_intel(c);
1018 break;
1019
1020 case X86_VENDOR_UNKNOWN:
1021 default:
1022 display_cacheinfo(c);
1023 break;
1024 }
1025
1026 select_idle_routine(c);
1027 detect_ht(c);
1da177e4
LT		 1028
1029 /*
1030 * On SMP, boot_cpu_data holds the common feature set between
1031 * all CPUs; so make sure that we indicate which features are
1032 * common between the CPUs. The first time this routine gets
1033 * executed, c == &boot_cpu_data.
1034 */
1035 if (c != &boot_cpu_data) {
1036 /* AND the already accumulated flags with these */
1037 for (i = 0 ; i < NCAPINTS ; i++)
1038 boot_cpu_data.x86_capability[i] &= c->x86_capability[i];
1039 }
1040
1041#ifdef CONFIG_X86_MCE
1042 mcheck_init(c);
1043#endif
1044#ifdef CONFIG_NUMA
1045 if (c != &boot_cpu_data)
1046 numa_add_cpu(c - cpu_data);
1047#endif
1048}
1049
1050
1051void __init print_cpu_info(struct cpuinfo_x86 *c)
1052{
1053 if (c->x86_model_id[0])
1054 printk("%s", c->x86_model_id);
1055
1056 if (c->x86_mask || c->cpuid_level >= 0)
1057 printk(" stepping %02x\n", c->x86_mask);
1058 else
1059 printk("\n");
1060}
1061
1062/*
1063 * Get CPU information for use by the procfs.
1064 */
1065
1066static int show_cpuinfo(struct seq_file *m, void *v)
1067{
1068 struct cpuinfo_x86 *c = v;
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 char *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", NULL,
1084
1085 /* AMD-defined */
3c3b73b6 1086 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1da177e4
LT		 1087 NULL, NULL, NULL, "syscall", NULL, NULL, NULL, NULL,
1088 NULL, NULL, NULL, NULL, "nx", NULL, "mmxext", NULL,
1089 NULL, "fxsr_opt", NULL, NULL, NULL, "lm", "3dnowext", "3dnow",
1090
1091 /* Transmeta-defined */
1092 "recovery", "longrun", NULL, "lrti", NULL, NULL, NULL, NULL,
1093 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1094 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1095 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1096
1097 /* Other (Linux-defined) */
622dcaf9 1098 "cxmmx", NULL, "cyrix_arr", "centaur_mcr", NULL,
c29601e9 1099 "constant_tsc", NULL, NULL,
1da177e4
LT		 1100 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1101 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1102 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1103
1104 /* Intel-defined (#2) */
1105 "pni", NULL, NULL, "monitor", "ds_cpl", NULL, NULL, "est",
1106 "tm2", NULL, "cid", NULL, NULL, "cx16", "xtpr", NULL,
1107 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1108 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1109
5b7abc6f
PA		 1110 /* VIA/Cyrix/Centaur-defined */
1111 NULL, NULL, "rng", "rng_en", NULL, NULL, "ace", "ace_en",
1112 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1113 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1114 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1115
1da177e4
LT		 1116 /* AMD-defined (#2) */
1117 "lahf_lm", "cmp_legacy", NULL, NULL, NULL, NULL, NULL, NULL,
1118 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1119 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
5b7abc6f 1120 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1da177e4
LT		 1121 };
1122 static char *x86_power_flags[] = {
1123 "ts", /* temperature sensor */
1124 "fid", /* frequency id control */
1125 "vid", /* voltage id control */
1126 "ttp", /* thermal trip */
1127 "tm",
1128 "stc"
1129 };
1130
1131
1132#ifdef CONFIG_SMP
1133 if (!cpu_online(c-cpu_data))
1134 return 0;
1135#endif
1136
1137 seq_printf(m,"processor\t: %u\n"
1138 "vendor_id\t: %s\n"
1139 "cpu family\t: %d\n"
1140 "model\t\t: %d\n"
1141 "model name\t: %s\n",
1142 (unsigned)(c-cpu_data),
1143 c->x86_vendor_id[0] ? c->x86_vendor_id : "unknown",
1144 c->x86,
1145 (int)c->x86_model,
1146 c->x86_model_id[0] ? c->x86_model_id : "unknown");
1147
1148 if (c->x86_mask || c->cpuid_level >= 0)
1149 seq_printf(m, "stepping\t: %d\n", c->x86_mask);
1150 else
1151 seq_printf(m, "stepping\t: unknown\n");
1152
1153 if (cpu_has(c,X86_FEATURE_TSC)) {
1154 seq_printf(m, "cpu MHz\t\t: %u.%03u\n",
1155 cpu_khz / 1000, (cpu_khz % 1000));
1156 }
1157
1158 /* Cache size */
1159 if (c->x86_cache_size >= 0)
1160 seq_printf(m, "cache size\t: %d KB\n", c->x86_cache_size);
1161
1162#ifdef CONFIG_SMP
db468681
AK		 1163 if (smp_num_siblings * c->x86_num_cores > 1) {
1164 int cpu = c - cpu_data;
1165 seq_printf(m, "physical id\t: %d\n", phys_proc_id[cpu]);
1166 seq_printf(m, "siblings\t: %d\n",
1167 c->x86_num_cores * smp_num_siblings);
d31ddaa1
SS		 1168 seq_printf(m, "core id\t\t: %d\n", cpu_core_id[cpu]);
1169 seq_printf(m, "cpu cores\t: %d\n", c->x86_num_cores);
db468681 1170 }
1da177e4
LT		 1171#endif
1172
1173 seq_printf(m,
1174 "fpu\t\t: yes\n"
1175 "fpu_exception\t: yes\n"
1176 "cpuid level\t: %d\n"
1177 "wp\t\t: yes\n"
1178 "flags\t\t:",
1179 c->cpuid_level);
1180
1181 {
1182 int i;
1183 for ( i = 0 ; i < 32*NCAPINTS ; i++ )
1184 if ( test_bit(i, &c->x86_capability) &&
1185 x86_cap_flags[i] != NULL )
1186 seq_printf(m, " %s", x86_cap_flags[i]);
1187 }
1188
1189 seq_printf(m, "\nbogomips\t: %lu.%02lu\n",
1190 c->loops_per_jiffy/(500000/HZ),
1191 (c->loops_per_jiffy/(5000/HZ)) % 100);
1192
1193 if (c->x86_tlbsize > 0)
1194 seq_printf(m, "TLB size\t: %d 4K pages\n", c->x86_tlbsize);
1195 seq_printf(m, "clflush size\t: %d\n", c->x86_clflush_size);
1196 seq_printf(m, "cache_alignment\t: %d\n", c->x86_cache_alignment);
1197
1198 seq_printf(m, "address sizes\t: %u bits physical, %u bits virtual\n",
1199 c->x86_phys_bits, c->x86_virt_bits);
1200
1201 seq_printf(m, "power management:");
1202 {
1203 unsigned i;
1204 for (i = 0; i < 32; i++)
1205 if (c->x86_power & (1 << i)) {
1206 if (i < ARRAY_SIZE(x86_power_flags))
1207 seq_printf(m, " %s", x86_power_flags[i]);
1208 else
1209 seq_printf(m, " [%d]", i);
1210 }
1211 }
1da177e4 1212
d31ddaa1 1213 seq_printf(m, "\n\n");
1da177e4
LT		 1214
1215 return 0;
1216}
1217
1218static void *c_start(struct seq_file *m, loff_t *pos)
1219{
1220 return *pos < NR_CPUS ? cpu_data + *pos : NULL;
1221}
1222
1223static void *c_next(struct seq_file *m, void *v, loff_t *pos)
1224{
1225 ++*pos;
1226 return c_start(m, pos);
1227}
1228
1229static void c_stop(struct seq_file *m, void *v)
1230{
1231}
1232
1233struct seq_operations cpuinfo_op = {
1234 .start =c_start,
1235 .next = c_next,
1236 .stop = c_stop,
1237 .show = show_cpuinfo,
1238};
Linux kernel - Deliverables
This page took 0.086028 seconds and 5 git commands to generate.