projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Linux-2.6.12-rc2
[deliverable/linux.git] / arch / x86_64 / kernel / setup.c
1 /*
2 * linux/arch/x86-64/kernel/setup.c
3 *
4 * Copyright (C) 1995 Linus Torvalds
5 *
6 * Nov 2001 Dave Jones <davej@suse.de>
7 * Forked from i386 setup code.
8 *
9 * $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
65 struct cpuinfo_x86 boot_cpu_data;
66
67 unsigned long mmu_cr4_features;
68
69 int acpi_disabled;
70 EXPORT_SYMBOL(acpi_disabled);
71 #ifdef CONFIG_ACPI_BOOT
72 extern int __initdata acpi_ht;
73 extern acpi_interrupt_flags acpi_sci_flags;
74 int __initdata acpi_force = 0;
75 #endif
76
77 int acpi_numa __initdata;
78
79 /* For PCI or other memory-mapped resources */
80 unsigned long pci_mem_start = 0x10000000;
81
82 /* Boot loader ID as an integer, for the benefit of proc_dointvec */
83 int bootloader_type;
84
85 unsigned long saved_video_mode;
86
87 #ifdef CONFIG_SWIOTLB
88 int swiotlb;
89 EXPORT_SYMBOL(swiotlb);
90 #endif
91
92 /*
93 * Setup options
94 */
95 struct drive_info_struct { char dummy[32]; } drive_info;
96 struct screen_info screen_info;
97 struct sys_desc_table_struct {
98 unsigned short length;
99 unsigned char table[0];
100 };
101
102 struct edid_info edid_info;
103 struct e820map e820;
104
105 extern int root_mountflags;
106 extern char _text, _etext, _edata, _end;
107
108 char command_line[COMMAND_LINE_SIZE];
109
110 struct resource standard_io_resources[] = {
111 { .name = "dma1", .start = 0x00, .end = 0x1f,
112 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
113 { .name = "pic1", .start = 0x20, .end = 0x21,
114 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
115 { .name = "timer0", .start = 0x40, .end = 0x43,
116 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
117 { .name = "timer1", .start = 0x50, .end = 0x53,
118 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
119 { .name = "keyboard", .start = 0x60, .end = 0x6f,
120 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
121 { .name = "dma page reg", .start = 0x80, .end = 0x8f,
122 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
123 { .name = "pic2", .start = 0xa0, .end = 0xa1,
124 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
125 { .name = "dma2", .start = 0xc0, .end = 0xdf,
126 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
127 { .name = "fpu", .start = 0xf0, .end = 0xff,
128 .flags = IORESOURCE_BUSY | IORESOURCE_IO }
129 };
130
131 #define STANDARD_IO_RESOURCES \
132 (sizeof standard_io_resources / sizeof standard_io_resources[0])
133
134 #define IORESOURCE_RAM (IORESOURCE_BUSY | IORESOURCE_MEM)
135
136 struct resource data_resource = {
137 .name = "Kernel data",
138 .start = 0,
139 .end = 0,
140 .flags = IORESOURCE_RAM,
141 };
142 struct resource code_resource = {
143 .name = "Kernel code",
144 .start = 0,
145 .end = 0,
146 .flags = IORESOURCE_RAM,
147 };
148
149 #define IORESOURCE_ROM (IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM)
150
151 static struct resource system_rom_resource = {
152 .name = "System ROM",
153 .start = 0xf0000,
154 .end = 0xfffff,
155 .flags = IORESOURCE_ROM,
156 };
157
158 static struct resource extension_rom_resource = {
159 .name = "Extension ROM",
160 .start = 0xe0000,
161 .end = 0xeffff,
162 .flags = IORESOURCE_ROM,
163 };
164
165 static struct resource adapter_rom_resources[] = {
166 { .name = "Adapter ROM", .start = 0xc8000, .end = 0,
167 .flags = IORESOURCE_ROM },
168 { .name = "Adapter ROM", .start = 0, .end = 0,
169 .flags = IORESOURCE_ROM },
170 { .name = "Adapter ROM", .start = 0, .end = 0,
171 .flags = IORESOURCE_ROM },
172 { .name = "Adapter ROM", .start = 0, .end = 0,
173 .flags = IORESOURCE_ROM },
174 { .name = "Adapter ROM", .start = 0, .end = 0,
175 .flags = IORESOURCE_ROM },
176 { .name = "Adapter ROM", .start = 0, .end = 0,
177 .flags = IORESOURCE_ROM }
178 };
179
180 #define ADAPTER_ROM_RESOURCES \
181 (sizeof adapter_rom_resources / sizeof adapter_rom_resources[0])
182
183 static struct resource video_rom_resource = {
184 .name = "Video ROM",
185 .start = 0xc0000,
186 .end = 0xc7fff,
187 .flags = IORESOURCE_ROM,
188 };
189
190 static struct resource video_ram_resource = {
191 .name = "Video RAM area",
192 .start = 0xa0000,
193 .end = 0xbffff,
194 .flags = IORESOURCE_RAM,
195 };
196
197 #define romsignature(x) (*(unsigned short *)(x) == 0xaa55)
198
199 static int __init romchecksum(unsigned char *rom, unsigned long length)
200 {
201 unsigned char *p, sum = 0;
202
203 for (p = rom; p < rom + length; p++)
204 sum += *p;
205 return sum == 0;
206 }
207
208 static void __init probe_roms(void)
209 {
210 unsigned long start, length, upper;
211 unsigned char *rom;
212 int i;
213
214 /* video rom */
215 upper = adapter_rom_resources[0].start;
216 for (start = video_rom_resource.start; start < upper; start += 2048) {
217 rom = isa_bus_to_virt(start);
218 if (!romsignature(rom))
219 continue;
220
221 video_rom_resource.start = start;
222
223 /* 0 < length <= 0x7f * 512, historically */
224 length = rom[2] * 512;
225
226 /* if checksum okay, trust length byte */
227 if (length && romchecksum(rom, length))
228 video_rom_resource.end = start + length - 1;
229
230 request_resource(&iomem_resource, &video_rom_resource);
231 break;
232 }
233
234 start = (video_rom_resource.end + 1 + 2047) & ~2047UL;
235 if (start < upper)
236 start = upper;
237
238 /* system rom */
239 request_resource(&iomem_resource, &system_rom_resource);
240 upper = system_rom_resource.start;
241
242 /* check for extension rom (ignore length byte!) */
243 rom = isa_bus_to_virt(extension_rom_resource.start);
244 if (romsignature(rom)) {
245 length = extension_rom_resource.end - extension_rom_resource.start + 1;
246 if (romchecksum(rom, length)) {
247 request_resource(&iomem_resource, &extension_rom_resource);
248 upper = extension_rom_resource.start;
249 }
250 }
251
252 /* check for adapter roms on 2k boundaries */
253 for (i = 0; i < ADAPTER_ROM_RESOURCES && start < upper; start += 2048) {
254 rom = isa_bus_to_virt(start);
255 if (!romsignature(rom))
256 continue;
257
258 /* 0 < length <= 0x7f * 512, historically */
259 length = rom[2] * 512;
260
261 /* but accept any length that fits if checksum okay */
262 if (!length || start + length > upper || !romchecksum(rom, length))
263 continue;
264
265 adapter_rom_resources[i].start = start;
266 adapter_rom_resources[i].end = start + length - 1;
267 request_resource(&iomem_resource, &adapter_rom_resources[i]);
268
269 start = adapter_rom_resources[i++].end & ~2047UL;
270 }
271 }
272
273 static __init void parse_cmdline_early (char ** cmdline_p)
274 {
275 char c = ' ', *to = command_line, *from = COMMAND_LINE;
276 int len = 0;
277
278 /* Save unparsed command line copy for /proc/cmdline */
279 memcpy(saved_command_line, COMMAND_LINE, COMMAND_LINE_SIZE);
280 saved_command_line[COMMAND_LINE_SIZE-1] = '\0';
281
282 for (;;) {
283 if (c != ' ')
284 goto next_char;
285
286 #ifdef CONFIG_SMP
287 /*
288 * If the BIOS enumerates physical processors before logical,
289 * maxcpus=N at enumeration-time can be used to disable HT.
290 */
291 else if (!memcmp(from, "maxcpus=", 8)) {
292 extern unsigned int maxcpus;
293
294 maxcpus = simple_strtoul(from + 8, NULL, 0);
295 }
296 #endif
297 #ifdef CONFIG_ACPI_BOOT
298 /* "acpi=off" disables both ACPI table parsing and interpreter init */
299 if (!memcmp(from, "acpi=off", 8))
300 disable_acpi();
301
302 if (!memcmp(from, "acpi=force", 10)) {
303 /* add later when we do DMI horrors: */
304 acpi_force = 1;
305 acpi_disabled = 0;
306 }
307
308 /* acpi=ht just means: do ACPI MADT parsing
309 at bootup, but don't enable the full ACPI interpreter */
310 if (!memcmp(from, "acpi=ht", 7)) {
311 if (!acpi_force)
312 disable_acpi();
313 acpi_ht = 1;
314 }
315 else if (!memcmp(from, "pci=noacpi", 10))
316 acpi_disable_pci();
317 else if (!memcmp(from, "acpi=noirq", 10))
318 acpi_noirq_set();
319
320 else if (!memcmp(from, "acpi_sci=edge", 13))
321 acpi_sci_flags.trigger = 1;
322 else if (!memcmp(from, "acpi_sci=level", 14))
323 acpi_sci_flags.trigger = 3;
324 else if (!memcmp(from, "acpi_sci=high", 13))
325 acpi_sci_flags.polarity = 1;
326 else if (!memcmp(from, "acpi_sci=low", 12))
327 acpi_sci_flags.polarity = 3;
328
329 /* acpi=strict disables out-of-spec workarounds */
330 else if (!memcmp(from, "acpi=strict", 11)) {
331 acpi_strict = 1;
332 }
333 #endif
334
335 if (!memcmp(from, "nolapic", 7) ||
336 !memcmp(from, "disableapic", 11))
337 disable_apic = 1;
338
339 if (!memcmp(from, "noapic", 6))
340 skip_ioapic_setup = 1;
341
342 if (!memcmp(from, "apic", 4)) {
343 skip_ioapic_setup = 0;
344 ioapic_force = 1;
345 }
346
347 if (!memcmp(from, "mem=", 4))
348 parse_memopt(from+4, &from);
349
350 #ifdef CONFIG_DISCONTIGMEM
351 if (!memcmp(from, "numa=", 5))
352 numa_setup(from+5);
353 #endif
354
355 #ifdef CONFIG_GART_IOMMU
356 if (!memcmp(from,"iommu=",6)) {
357 iommu_setup(from+6);
358 }
359 #endif
360
361 if (!memcmp(from,"oops=panic", 10))
362 panic_on_oops = 1;
363
364 if (!memcmp(from, "noexec=", 7))
365 nonx_setup(from + 7);
366
367 next_char:
368 c = *(from++);
369 if (!c)
370 break;
371 if (COMMAND_LINE_SIZE <= ++len)
372 break;
373 *(to++) = c;
374 }
375 *to = '\0';
376 *cmdline_p = command_line;
377 }
378
379 #ifndef CONFIG_DISCONTIGMEM
380 static void __init contig_initmem_init(void)
381 {
382 unsigned long bootmap_size, bootmap;
383 bootmap_size = bootmem_bootmap_pages(end_pfn)<<PAGE_SHIFT;
384 bootmap = find_e820_area(0, end_pfn<<PAGE_SHIFT, bootmap_size);
385 if (bootmap == -1L)
386 panic("Cannot find bootmem map of size %ld\n",bootmap_size);
387 bootmap_size = init_bootmem(bootmap >> PAGE_SHIFT, end_pfn);
388 e820_bootmem_free(&contig_page_data, 0, end_pfn << PAGE_SHIFT);
389 reserve_bootmem(bootmap, bootmap_size);
390 }
391 #endif
392
393 /* Use inline assembly to define this because the nops are defined
394 as inline assembly strings in the include files and we cannot
395 get them easily into strings. */
396 asm("\t.data\nk8nops: "
397 K8_NOP1 K8_NOP2 K8_NOP3 K8_NOP4 K8_NOP5 K8_NOP6
398 K8_NOP7 K8_NOP8);
399
400 extern unsigned char k8nops[];
401 static unsigned char *k8_nops[ASM_NOP_MAX+1] = {
402 NULL,
403 k8nops,
404 k8nops + 1,
405 k8nops + 1 + 2,
406 k8nops + 1 + 2 + 3,
407 k8nops + 1 + 2 + 3 + 4,
408 k8nops + 1 + 2 + 3 + 4 + 5,
409 k8nops + 1 + 2 + 3 + 4 + 5 + 6,
410 k8nops + 1 + 2 + 3 + 4 + 5 + 6 + 7,
411 };
412
413 /* Replace instructions with better alternatives for this CPU type.
414
415 This runs before SMP is initialized to avoid SMP problems with
416 self modifying code. This implies that assymetric systems where
417 APs have less capabilities than the boot processor are not handled.
418 In this case boot with "noreplacement". */
419 void apply_alternatives(void *start, void *end)
420 {
421 struct alt_instr *a;
422 int diff, i, k;
423 for (a = start; (void *)a < end; a++) {
424 if (!boot_cpu_has(a->cpuid))
425 continue;
426
427 BUG_ON(a->replacementlen > a->instrlen);
428 __inline_memcpy(a->instr, a->replacement, a->replacementlen);
429 diff = a->instrlen - a->replacementlen;
430
431 /* Pad the rest with nops */
432 for (i = a->replacementlen; diff > 0; diff -= k, i += k) {
433 k = diff;
434 if (k > ASM_NOP_MAX)
435 k = ASM_NOP_MAX;
436 __inline_memcpy(a->instr + i, k8_nops[k], k);
437 }
438 }
439 }
440
441 static int no_replacement __initdata = 0;
442
443 void __init alternative_instructions(void)
444 {
445 extern struct alt_instr __alt_instructions[], __alt_instructions_end[];
446 if (no_replacement)
447 return;
448 apply_alternatives(__alt_instructions, __alt_instructions_end);
449 }
450
451 static int __init noreplacement_setup(char *s)
452 {
453 no_replacement = 1;
454 return 0;
455 }
456
457 __setup("noreplacement", noreplacement_setup);
458
459 #if defined(CONFIG_EDD) || defined(CONFIG_EDD_MODULE)
460 struct edd edd;
461 #ifdef CONFIG_EDD_MODULE
462 EXPORT_SYMBOL(edd);
463 #endif
464 /**
465 * copy_edd() - Copy the BIOS EDD information
466 * from boot_params into a safe place.
467 *
468 */
469 static inline void copy_edd(void)
470 {
471 memcpy(edd.mbr_signature, EDD_MBR_SIGNATURE, sizeof(edd.mbr_signature));
472 memcpy(edd.edd_info, EDD_BUF, sizeof(edd.edd_info));
473 edd.mbr_signature_nr = EDD_MBR_SIG_NR;
474 edd.edd_info_nr = EDD_NR;
475 }
476 #else
477 static inline void copy_edd(void)
478 {
479 }
480 #endif
481
482 #define EBDA_ADDR_POINTER 0x40E
483 static void __init reserve_ebda_region(void)
484 {
485 unsigned int addr;
486 /**
487 * there is a real-mode segmented pointer pointing to the
488 * 4K EBDA area at 0x40E
489 */
490 addr = *(unsigned short *)phys_to_virt(EBDA_ADDR_POINTER);
491 addr <<= 4;
492 if (addr)
493 reserve_bootmem_generic(addr, PAGE_SIZE);
494 }
495
496 void __init setup_arch(char **cmdline_p)
497 {
498 unsigned long low_mem_size;
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
657 /* Will likely break when you have unassigned resources with more
658 than 4GB memory and bridges that don't support more than 4GB.
659 Doing it properly would require to use pci_alloc_consistent
660 in this case. */
661 low_mem_size = ((end_pfn << PAGE_SHIFT) + 0xfffff) & ~0xfffff;
662 if (low_mem_size > pci_mem_start)
663 pci_mem_start = low_mem_size;
664
665 #ifdef CONFIG_GART_IOMMU
666 iommu_hole_init();
667 #endif
668
669 #ifdef CONFIG_VT
670 #if defined(CONFIG_VGA_CONSOLE)
671 conswitchp = &vga_con;
672 #elif defined(CONFIG_DUMMY_CONSOLE)
673 conswitchp = &dummy_con;
674 #endif
675 #endif
676 }
677
678 static int __init get_model_name(struct cpuinfo_x86 *c)
679 {
680 unsigned int *v;
681
682 if (c->x86_cpuid_level < 0x80000004)
683 return 0;
684
685 v = (unsigned int *) c->x86_model_id;
686 cpuid(0x80000002, &v[0], &v[1], &v[2], &v[3]);
687 cpuid(0x80000003, &v[4], &v[5], &v[6], &v[7]);
688 cpuid(0x80000004, &v[8], &v[9], &v[10], &v[11]);
689 c->x86_model_id[48] = 0;
690 return 1;
691 }
692
693
694 static void __init display_cacheinfo(struct cpuinfo_x86 *c)
695 {
696 unsigned int n, dummy, eax, ebx, ecx, edx;
697
698 n = c->x86_cpuid_level;
699
700 if (n >= 0x80000005) {
701 cpuid(0x80000005, &dummy, &ebx, &ecx, &edx);
702 printk(KERN_INFO "CPU: L1 I Cache: %dK (%d bytes/line), D cache %dK (%d bytes/line)\n",
703 edx>>24, edx&0xFF, ecx>>24, ecx&0xFF);
704 c->x86_cache_size=(ecx>>24)+(edx>>24);
705 /* On K8 L1 TLB is inclusive, so don't count it */
706 c->x86_tlbsize = 0;
707 }
708
709 if (n >= 0x80000006) {
710 cpuid(0x80000006, &dummy, &ebx, &ecx, &edx);
711 ecx = cpuid_ecx(0x80000006);
712 c->x86_cache_size = ecx >> 16;
713 c->x86_tlbsize += ((ebx >> 16) & 0xfff) + (ebx & 0xfff);
714
715 printk(KERN_INFO "CPU: L2 Cache: %dK (%d bytes/line)\n",
716 c->x86_cache_size, ecx & 0xFF);
717 }
718
719 if (n >= 0x80000007)
720 cpuid(0x80000007, &dummy, &dummy, &dummy, &c->x86_power);
721 if (n >= 0x80000008) {
722 cpuid(0x80000008, &eax, &dummy, &dummy, &dummy);
723 c->x86_virt_bits = (eax >> 8) & 0xff;
724 c->x86_phys_bits = eax & 0xff;
725 }
726 }
727
728
729 static int __init init_amd(struct cpuinfo_x86 *c)
730 {
731 int r;
732 int level;
733 #ifdef CONFIG_NUMA
734 int cpu;
735 #endif
736
737 /* Bit 31 in normal CPUID used for nonstandard 3DNow ID;
738 3DNow is IDd by bit 31 in extended CPUID (1*32+31) anyway */
739 clear_bit(0*32+31, &c->x86_capability);
740
741 /* C-stepping K8? */
742 level = cpuid_eax(1);
743 if ((level >= 0x0f48 && level < 0x0f50) || level >= 0x0f58)
744 set_bit(X86_FEATURE_K8_C, &c->x86_capability);
745
746 r = get_model_name(c);
747 if (!r) {
748 switch (c->x86) {
749 case 15:
750 /* Should distinguish Models here, but this is only
751 a fallback anyways. */
752 strcpy(c->x86_model_id, "Hammer");
753 break;
754 }
755 }
756 display_cacheinfo(c);
757
758 if (c->x86_cpuid_level >= 0x80000008) {
759 c->x86_num_cores = (cpuid_ecx(0x80000008) & 0xff) + 1;
760 if (c->x86_num_cores & (c->x86_num_cores - 1))
761 c->x86_num_cores = 1;
762
763 #ifdef CONFIG_NUMA
764 /* On a dual core setup the lower bits of apic id
765 distingush the cores. Fix up the CPU<->node mappings
766 here based on that.
767 Assumes number of cores is a power of two.
768 When using SRAT use mapping from SRAT. */
769 cpu = c->x86_apicid;
770 if (acpi_numa <= 0 && c->x86_num_cores > 1) {
771 cpu_to_node[cpu] = cpu >> hweight32(c->x86_num_cores - 1);
772 if (!node_online(cpu_to_node[cpu]))
773 cpu_to_node[cpu] = first_node(node_online_map);
774 }
775 printk(KERN_INFO "CPU %d(%d) -> Node %d\n",
776 cpu, c->x86_num_cores, cpu_to_node[cpu]);
777 #endif
778 }
779
780 return r;
781 }
782
783 static void __init detect_ht(struct cpuinfo_x86 *c)
784 {
785 #ifdef CONFIG_SMP
786 u32 eax, ebx, ecx, edx;
787 int index_lsb, index_msb, tmp;
788 int cpu = smp_processor_id();
789
790 if (!cpu_has(c, X86_FEATURE_HT))
791 return;
792
793 cpuid(1, &eax, &ebx, &ecx, &edx);
794 smp_num_siblings = (ebx & 0xff0000) >> 16;
795
796 if (smp_num_siblings == 1) {
797 printk(KERN_INFO "CPU: Hyper-Threading is disabled\n");
798 } else if (smp_num_siblings > 1) {
799 index_lsb = 0;
800 index_msb = 31;
801 /*
802 * At this point we only support two siblings per
803 * processor package.
804 */
805 if (smp_num_siblings > NR_CPUS) {
806 printk(KERN_WARNING "CPU: Unsupported number of the siblings %d", smp_num_siblings);
807 smp_num_siblings = 1;
808 return;
809 }
810 tmp = smp_num_siblings;
811 while ((tmp & 1) == 0) {
812 tmp >>=1 ;
813 index_lsb++;
814 }
815 tmp = smp_num_siblings;
816 while ((tmp & 0x80000000 ) == 0) {
817 tmp <<=1 ;
818 index_msb--;
819 }
820 if (index_lsb != index_msb )
821 index_msb++;
822 phys_proc_id[cpu] = phys_pkg_id(index_msb);
823
824 printk(KERN_INFO "CPU: Physical Processor ID: %d\n",
825 phys_proc_id[cpu]);
826 }
827 #endif
828 }
829
830 static void __init sched_cmp_hack(struct cpuinfo_x86 *c)
831 {
832 #ifdef CONFIG_SMP
833 /* AMD dual core looks like HT but isn't really. Hide it from the
834 scheduler. This works around problems with the domain scheduler.
835 Also probably gives slightly better scheduling and disables
836 SMT nice which is harmful on dual core.
837 TBD tune the domain scheduler for dual core. */
838 if (c->x86_vendor == X86_VENDOR_AMD && cpu_has(c, X86_FEATURE_CMP_LEGACY))
839 smp_num_siblings = 1;
840 #endif
841 }
842
843 static void __init init_intel(struct cpuinfo_x86 *c)
844 {
845 /* Cache sizes */
846 unsigned n;
847
848 init_intel_cacheinfo(c);
849 n = c->x86_cpuid_level;
850 if (n >= 0x80000008) {
851 unsigned eax = cpuid_eax(0x80000008);
852 c->x86_virt_bits = (eax >> 8) & 0xff;
853 c->x86_phys_bits = eax & 0xff;
854 }
855
856 if (c->x86 == 15)
857 c->x86_cache_alignment = c->x86_clflush_size * 2;
858 }
859
860 void __init get_cpu_vendor(struct cpuinfo_x86 *c)
861 {
862 char *v = c->x86_vendor_id;
863
864 if (!strcmp(v, "AuthenticAMD"))
865 c->x86_vendor = X86_VENDOR_AMD;
866 else if (!strcmp(v, "GenuineIntel"))
867 c->x86_vendor = X86_VENDOR_INTEL;
868 else
869 c->x86_vendor = X86_VENDOR_UNKNOWN;
870 }
871
872 struct cpu_model_info {
873 int vendor;
874 int family;
875 char *model_names[16];
876 };
877
878 /* Do some early cpuid on the boot CPU to get some parameter that are
879 needed before check_bugs. Everything advanced is in identify_cpu
880 below. */
881 void __init early_identify_cpu(struct cpuinfo_x86 *c)
882 {
883 u32 tfms;
884
885 c->loops_per_jiffy = loops_per_jiffy;
886 c->x86_cache_size = -1;
887 c->x86_vendor = X86_VENDOR_UNKNOWN;
888 c->x86_model = c->x86_mask = 0; /* So far unknown... */
889 c->x86_vendor_id[0] = '\0'; /* Unset */
890 c->x86_model_id[0] = '\0'; /* Unset */
891 c->x86_clflush_size = 64;
892 c->x86_cache_alignment = c->x86_clflush_size;
893 c->x86_num_cores = 1;
894 c->x86_apicid = c == &boot_cpu_data ? 0 : c - cpu_data;
895 c->x86_cpuid_level = 0;
896 memset(&c->x86_capability, 0, sizeof c->x86_capability);
897
898 /* Get vendor name */
899 cpuid(0x00000000, (unsigned int *)&c->cpuid_level,
900 (unsigned int *)&c->x86_vendor_id[0],
901 (unsigned int *)&c->x86_vendor_id[8],
902 (unsigned int *)&c->x86_vendor_id[4]);
903
904 get_cpu_vendor(c);
905
906 /* Initialize the standard set of capabilities */
907 /* Note that the vendor-specific code below might override */
908
909 /* Intel-defined flags: level 0x00000001 */
910 if (c->cpuid_level >= 0x00000001) {
911 __u32 misc;
912 cpuid(0x00000001, &tfms, &misc, &c->x86_capability[4],
913 &c->x86_capability[0]);
914 c->x86 = (tfms >> 8) & 0xf;
915 c->x86_model = (tfms >> 4) & 0xf;
916 c->x86_mask = tfms & 0xf;
917 if (c->x86 == 0xf) {
918 c->x86 += (tfms >> 20) & 0xff;
919 c->x86_model += ((tfms >> 16) & 0xF) << 4;
920 }
921 if (c->x86_capability[0] & (1<<19))
922 c->x86_clflush_size = ((misc >> 8) & 0xff) * 8;
923 c->x86_apicid = misc >> 24;
924 } else {
925 /* Have CPUID level 0 only - unheard of */
926 c->x86 = 4;
927 }
928 }
929
930 /*
931 * This does the hard work of actually picking apart the CPU stuff...
932 */
933 void __init identify_cpu(struct cpuinfo_x86 *c)
934 {
935 int i;
936 u32 xlvl;
937
938 early_identify_cpu(c);
939
940 /* AMD-defined flags: level 0x80000001 */
941 xlvl = cpuid_eax(0x80000000);
942 c->x86_cpuid_level = xlvl;
943 if ((xlvl & 0xffff0000) == 0x80000000) {
944 if (xlvl >= 0x80000001) {
945 c->x86_capability[1] = cpuid_edx(0x80000001);
946 c->x86_capability[5] = cpuid_ecx(0x80000001);
947 }
948 if (xlvl >= 0x80000004)
949 get_model_name(c); /* Default name */
950 }
951
952 /* Transmeta-defined flags: level 0x80860001 */
953 xlvl = cpuid_eax(0x80860000);
954 if ((xlvl & 0xffff0000) == 0x80860000) {
955 /* Don't set x86_cpuid_level here for now to not confuse. */
956 if (xlvl >= 0x80860001)
957 c->x86_capability[2] = cpuid_edx(0x80860001);
958 }
959
960 /*
961 * Vendor-specific initialization. In this section we
962 * canonicalize the feature flags, meaning if there are
963 * features a certain CPU supports which CPUID doesn't
964 * tell us, CPUID claiming incorrect flags, or other bugs,
965 * we handle them here.
966 *
967 * At the end of this section, c->x86_capability better
968 * indicate the features this CPU genuinely supports!
969 */
970 switch (c->x86_vendor) {
971 case X86_VENDOR_AMD:
972 init_amd(c);
973 break;
974
975 case X86_VENDOR_INTEL:
976 init_intel(c);
977 break;
978
979 case X86_VENDOR_UNKNOWN:
980 default:
981 display_cacheinfo(c);
982 break;
983 }
984
985 select_idle_routine(c);
986 detect_ht(c);
987 sched_cmp_hack(c);
988
989 /*
990 * On SMP, boot_cpu_data holds the common feature set between
991 * all CPUs; so make sure that we indicate which features are
992 * common between the CPUs. The first time this routine gets
993 * executed, c == &boot_cpu_data.
994 */
995 if (c != &boot_cpu_data) {
996 /* AND the already accumulated flags with these */
997 for (i = 0 ; i < NCAPINTS ; i++)
998 boot_cpu_data.x86_capability[i] &= c->x86_capability[i];
999 }
1000
1001 #ifdef CONFIG_X86_MCE
1002 mcheck_init(c);
1003 #endif
1004 #ifdef CONFIG_NUMA
1005 if (c != &boot_cpu_data)
1006 numa_add_cpu(c - cpu_data);
1007 #endif
1008 }
1009
1010
1011 void __init print_cpu_info(struct cpuinfo_x86 *c)
1012 {
1013 if (c->x86_model_id[0])
1014 printk("%s", c->x86_model_id);
1015
1016 if (c->x86_mask || c->cpuid_level >= 0)
1017 printk(" stepping %02x\n", c->x86_mask);
1018 else
1019 printk("\n");
1020 }
1021
1022 /*
1023 * Get CPU information for use by the procfs.
1024 */
1025
1026 static int show_cpuinfo(struct seq_file *m, void *v)
1027 {
1028 struct cpuinfo_x86 *c = v;
1029
1030 /*
1031 * These flag bits must match the definitions in <asm/cpufeature.h>.
1032 * NULL means this bit is undefined or reserved; either way it doesn't
1033 * have meaning as far as Linux is concerned. Note that it's important
1034 * to realize there is a difference between this table and CPUID -- if
1035 * applications want to get the raw CPUID data, they should access
1036 * /dev/cpu/<cpu_nr>/cpuid instead.
1037 */
1038 static char *x86_cap_flags[] = {
1039 /* Intel-defined */
1040 "fpu", "vme", "de", "pse", "tsc", "msr", "pae", "mce",
1041 "cx8", "apic", NULL, "sep", "mtrr", "pge", "mca", "cmov",
1042 "pat", "pse36", "pn", "clflush", NULL, "dts", "acpi", "mmx",
1043 "fxsr", "sse", "sse2", "ss", "ht", "tm", "ia64", NULL,
1044
1045 /* AMD-defined */
1046 "pni", NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1047 NULL, NULL, NULL, "syscall", NULL, NULL, NULL, NULL,
1048 NULL, NULL, NULL, NULL, "nx", NULL, "mmxext", NULL,
1049 NULL, "fxsr_opt", NULL, NULL, NULL, "lm", "3dnowext", "3dnow",
1050
1051 /* Transmeta-defined */
1052 "recovery", "longrun", NULL, "lrti", NULL, NULL, NULL, NULL,
1053 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1054 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1055 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1056
1057 /* Other (Linux-defined) */
1058 "cxmmx", "k6_mtrr", "cyrix_arr", "centaur_mcr", NULL, NULL, NULL, NULL,
1059 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1060 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1061 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1062
1063 /* Intel-defined (#2) */
1064 "pni", NULL, NULL, "monitor", "ds_cpl", NULL, NULL, "est",
1065 "tm2", NULL, "cid", NULL, NULL, "cx16", "xtpr", NULL,
1066 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1067 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1068
1069 /* AMD-defined (#2) */
1070 "lahf_lm", "cmp_legacy", NULL, NULL, NULL, NULL, NULL, NULL,
1071 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1072 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1073 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
1074 };
1075 static char *x86_power_flags[] = {
1076 "ts", /* temperature sensor */
1077 "fid", /* frequency id control */
1078 "vid", /* voltage id control */
1079 "ttp", /* thermal trip */
1080 "tm",
1081 "stc"
1082 };
1083
1084
1085 #ifdef CONFIG_SMP
1086 if (!cpu_online(c-cpu_data))
1087 return 0;
1088 #endif
1089
1090 seq_printf(m,"processor\t: %u\n"
1091 "vendor_id\t: %s\n"
1092 "cpu family\t: %d\n"
1093 "model\t\t: %d\n"
1094 "model name\t: %s\n",
1095 (unsigned)(c-cpu_data),
1096 c->x86_vendor_id[0] ? c->x86_vendor_id : "unknown",
1097 c->x86,
1098 (int)c->x86_model,
1099 c->x86_model_id[0] ? c->x86_model_id : "unknown");
1100
1101 if (c->x86_mask || c->cpuid_level >= 0)
1102 seq_printf(m, "stepping\t: %d\n", c->x86_mask);
1103 else
1104 seq_printf(m, "stepping\t: unknown\n");
1105
1106 if (cpu_has(c,X86_FEATURE_TSC)) {
1107 seq_printf(m, "cpu MHz\t\t: %u.%03u\n",
1108 cpu_khz / 1000, (cpu_khz % 1000));
1109 }
1110
1111 /* Cache size */
1112 if (c->x86_cache_size >= 0)
1113 seq_printf(m, "cache size\t: %d KB\n", c->x86_cache_size);
1114
1115 #ifdef CONFIG_SMP
1116 seq_printf(m, "physical id\t: %d\n", phys_proc_id[c - cpu_data]);
1117 seq_printf(m, "siblings\t: %d\n", c->x86_num_cores * smp_num_siblings);
1118 #endif
1119
1120 seq_printf(m,
1121 "fpu\t\t: yes\n"
1122 "fpu_exception\t: yes\n"
1123 "cpuid level\t: %d\n"
1124 "wp\t\t: yes\n"
1125 "flags\t\t:",
1126 c->cpuid_level);
1127
1128 {
1129 int i;
1130 for ( i = 0 ; i < 32*NCAPINTS ; i++ )
1131 if ( test_bit(i, &c->x86_capability) &&
1132 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 seq_printf(m, " %s", x86_power_flags[i]);
1155 else
1156 seq_printf(m, " [%d]", i);
1157 }
1158 }
1159 seq_printf(m, "\n");
1160
1161 if (c->x86_num_cores > 1)
1162 seq_printf(m, "cpu cores\t: %d\n", c->x86_num_cores);
1163
1164 seq_printf(m, "\n\n");
1165
1166 return 0;
1167 }
1168
1169 static void *c_start(struct seq_file *m, loff_t *pos)
1170 {
1171 return *pos < NR_CPUS ? cpu_data + *pos : NULL;
1172 }
1173
1174 static void *c_next(struct seq_file *m, void *v, loff_t *pos)
1175 {
1176 ++*pos;
1177 return c_start(m, pos);
1178 }
1179
1180 static void c_stop(struct seq_file *m, void *v)
1181 {
1182 }
1183
1184 struct seq_operations cpuinfo_op = {
1185 .start =c_start,
1186 .next = c_next,
1187 .stop = c_stop,
1188 .show = show_cpuinfo,
1189 };
Linux kernel - Deliverables
This page took 0.060449 seconds and 5 git commands to generate.