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