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/crash_dump.h>
  39 #include <linux/root_dev.h>
  40 #include <linux/pci.h>
  41 #include <linux/acpi.h>
  42 #include <linux/kallsyms.h>
  43 #include <linux/edd.h>
  44 #include <linux/mmzone.h>
  45 #include <linux/kexec.h>
  46 #include <linux/cpufreq.h>
  47 #include <linux/dmi.h>
  48 #include <linux/dma-mapping.h>
  49
  50 #include <asm/mtrr.h>
  51 #include <asm/uaccess.h>
  52 #include <asm/system.h>
  53 #include <asm/io.h>
  54 #include <asm/smp.h>
  55 #include <asm/msr.h>
  56 #include <asm/desc.h>
  57 #include <video/edid.h>
  58 #include <asm/e820.h>
  59 #include <asm/dma.h>
  60 #include <asm/mpspec.h>
  61 #include <asm/mmu_context.h>
  62 #include <asm/bootsetup.h>
  63 #include <asm/proto.h>
  64 #include <asm/setup.h>
  65 #include <asm/mach_apic.h>
  66 #include <asm/numa.h>
  67 #include <asm/swiotlb.h>
  68 #include <asm/sections.h>
  69 #include <asm/gart-mapping.h>
  70
  71 /*
  72  * Machine setup..
  73  */
  74
  75 struct cpuinfo_x86 boot_cpu_data __read_mostly;
  76
  77 unsigned long mmu_cr4_features;
  78
  79 int acpi_disabled;
  80 EXPORT_SYMBOL(acpi_disabled);
  81 #ifdef  CONFIG_ACPI
  82 extern int __initdata acpi_ht;
  83 extern acpi_interrupt_flags     acpi_sci_flags;
  84 int __initdata acpi_force = 0;
  85 #endif
  86
  87 int acpi_numa __initdata;
  88
  89 /* Boot loader ID as an integer, for the benefit of proc_dointvec */
  90 int bootloader_type;
  91
  92 unsigned long saved_video_mode;
  93
  94 /*
  95  * Setup options
  96  */
  97 struct screen_info screen_info;
  98 struct sys_desc_table_struct {
  99         unsigned short length;
 100         unsigned char table[0];
 101 };
 102
 103 struct edid_info edid_info;
 104 struct e820map e820;
 105
 106 extern int root_mountflags;
 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         int userdef = 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
 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                 }
 330 #ifdef CONFIG_X86_IO_APIC
 331                 else if (!memcmp(from, "acpi_skip_timer_override", 24))
 332                         acpi_skip_timer_override = 1;
 333 #endif
 334 #endif
 335
 336                 if (!memcmp(from, "disable_timer_pin_1", 19))
 337                         disable_timer_pin_1 = 1;
 338                 if (!memcmp(from, "enable_timer_pin_1", 18))
 339                         disable_timer_pin_1 = -1;
 340
 341                 if (!memcmp(from, "nolapic", 7) ||
 342                     !memcmp(from, "disableapic", 11))
 343                         disable_apic = 1;
 344
 345                 /* Don't confuse with noapictimer */
 346                 if (!memcmp(from, "noapic", 6) &&
 347                         (from[6] == ' ' || from[6] == 0))
 348                         skip_ioapic_setup = 1;
 349
 350                 /* Make sure to not confuse with apic= */
 351                 if (!memcmp(from, "apic", 4) &&
 352                         (from[4] == ' ' || from[4] == 0)) {
 353                         skip_ioapic_setup = 0;
 354                         ioapic_force = 1;
 355                 }
 356
 357                 if (!memcmp(from, "mem=", 4))
 358                         parse_memopt(from+4, &from);
 359
 360                 if (!memcmp(from, "memmap=", 7)) {
 361                         /* exactmap option is for used defined memory */
 362                         if (!memcmp(from+7, "exactmap", 8)) {
 363 #ifdef CONFIG_CRASH_DUMP
 364                                 /* If we are doing a crash dump, we
 365                                  * still need to know the real mem
 366                                  * size before original memory map is
 367                                  * reset.
 368                                  */
 369                                 saved_max_pfn = e820_end_of_ram();
 370 #endif
 371                                 from += 8+7;
 372                                 end_pfn_map = 0;
 373                                 e820.nr_map = 0;
 374                                 userdef = 1;
 375                         }
 376                         else {
 377                                 parse_memmapopt(from+7, &from);
 378                                 userdef = 1;
 379                         }
 380                 }
 381
 382 #ifdef CONFIG_NUMA
 383                 if (!memcmp(from, "numa=", 5))
 384                         numa_setup(from+5);
 385 #endif
 386
 387                 if (!memcmp(from,"iommu=",6)) {
 388                         iommu_setup(from+6);
 389                 }
 390
 391                 if (!memcmp(from,"oops=panic", 10))
 392                         panic_on_oops = 1;
 393
 394                 if (!memcmp(from, "noexec=", 7))
 395                         nonx_setup(from + 7);
 396
 397 #ifdef CONFIG_KEXEC
 398                 /* crashkernel=size@addr specifies the location to reserve for
 399                  * a crash kernel.  By reserving this memory we guarantee
 400                  * that linux never set's it up as a DMA target.
 401                  * Useful for holding code to do something appropriate
 402                  * after a kernel panic.
 403                  */
 404                 else if (!memcmp(from, "crashkernel=", 12)) {
 405                         unsigned long size, base;
 406                         size = memparse(from+12, &from);
 407                         if (*from == '@') {
 408                                 base = memparse(from+1, &from);
 409                                 /* FIXME: Do I want a sanity check
 410                                  * to validate the memory range?
 411                                  */
 412                                 crashk_res.start = base;
 413                                 crashk_res.end   = base + size - 1;
 414                         }
 415                 }
 416 #endif
 417
 418 #ifdef CONFIG_PROC_VMCORE
 419                 /* elfcorehdr= specifies the location of elf core header
 420                  * stored by the crashed kernel. This option will be passed
 421                  * by kexec loader to the capture kernel.
 422                  */
 423                 else if(!memcmp(from, "elfcorehdr=", 11))
 424                         elfcorehdr_addr = memparse(from+11, &from);
 425 #endif
 426
 427 #ifdef CONFIG_HOTPLUG_CPU
 428                 else if (!memcmp(from, "additional_cpus=", 16))
 429                         setup_additional_cpus(from+16);
 430 #endif
 431
 432         next_char:
 433                 c = *(from++);
 434                 if (!c)
 435                         break;
 436                 if (COMMAND_LINE_SIZE <= ++len)
 437                         break;
 438                 *(to++) = c;
 439         }
 440         if (userdef) {
 441                 printk(KERN_INFO "user-defined physical RAM map:\n");
 442                 e820_print_map("user");
 443         }
 444         *to = '\0';
 445         *cmdline_p = command_line;
 446 }
 447
 448 #ifndef CONFIG_NUMA
 449 static void __init
 450 contig_initmem_init(unsigned long start_pfn, unsigned long end_pfn)
 451 {
 452         unsigned long bootmap_size, bootmap;
 453
 454         bootmap_size = bootmem_bootmap_pages(end_pfn)<<PAGE_SHIFT;
 455         bootmap = find_e820_area(0, end_pfn<<PAGE_SHIFT, bootmap_size);
 456         if (bootmap == -1L)
 457                 panic("Cannot find bootmem map of size %ld\n",bootmap_size);
 458         bootmap_size = init_bootmem(bootmap >> PAGE_SHIFT, end_pfn);
 459         e820_bootmem_free(NODE_DATA(0), 0, end_pfn << PAGE_SHIFT);
 460         reserve_bootmem(bootmap, bootmap_size);
 461 }
 462 #endif
 463
 464 /* Use inline assembly to define this because the nops are defined
 465    as inline assembly strings in the include files and we cannot
 466    get them easily into strings. */
 467 asm("\t.data\nk8nops: "
 468     K8_NOP1 K8_NOP2 K8_NOP3 K8_NOP4 K8_NOP5 K8_NOP6
 469     K8_NOP7 K8_NOP8);
 470
 471 extern unsigned char k8nops[];
 472 static unsigned char *k8_nops[ASM_NOP_MAX+1] = {
 473      NULL,
 474      k8nops,
 475      k8nops + 1,
 476      k8nops + 1 + 2,
 477      k8nops + 1 + 2 + 3,
 478      k8nops + 1 + 2 + 3 + 4,
 479      k8nops + 1 + 2 + 3 + 4 + 5,
 480      k8nops + 1 + 2 + 3 + 4 + 5 + 6,
 481      k8nops + 1 + 2 + 3 + 4 + 5 + 6 + 7,
 482 };
 483
 484 extern char __vsyscall_0;
 485
 486 /* Replace instructions with better alternatives for this CPU type.
 487
 488    This runs before SMP is initialized to avoid SMP problems with
 489    self modifying code. This implies that assymetric systems where
 490    APs have less capabilities than the boot processor are not handled.
 491    In this case boot with "noreplacement". */
 492 void apply_alternatives(void *start, void *end)
 493 {
 494         struct alt_instr *a;
 495         int diff, i, k;
 496         for (a = start; (void *)a < end; a++) {
 497                 u8 *instr;
 498
 499                 if (!boot_cpu_has(a->cpuid))
 500                         continue;
 501
 502                 BUG_ON(a->replacementlen > a->instrlen);
 503                 instr = a->instr;
 504                 /* vsyscall code is not mapped yet. resolve it manually. */
 505                 if (instr >= (u8 *)VSYSCALL_START && instr < (u8*)VSYSCALL_END)
 506                         instr = __va(instr - (u8*)VSYSCALL_START + (u8*)__pa_symbol(&__vsyscall_0));
 507                 __inline_memcpy(instr, a->replacement, a->replacementlen);
 508                 diff = a->instrlen - a->replacementlen;
 509
 510                 /* Pad the rest with nops */
 511                 for (i = a->replacementlen; diff > 0; diff -= k, i += k) {
 512                         k = diff;
 513                         if (k > ASM_NOP_MAX)
 514                                 k = ASM_NOP_MAX;
 515                         __inline_memcpy(instr + i, k8_nops[k], k);
 516                 }
 517         }
 518 }
 519
 520 static int no_replacement __initdata = 0;
 521
 522 void __init alternative_instructions(void)
 523 {
 524         extern struct alt_instr __alt_instructions[], __alt_instructions_end[];
 525         if (no_replacement)
 526                 return;
 527         apply_alternatives(__alt_instructions, __alt_instructions_end);
 528 }
 529
 530 static int __init noreplacement_setup(char *s)
 531 {
 532      no_replacement = 1;
 533      return 0;
 534 }
 535
 536 __setup("noreplacement", noreplacement_setup);
 537
 538 #if defined(CONFIG_EDD) || defined(CONFIG_EDD_MODULE)
 539 struct edd edd;
 540 #ifdef CONFIG_EDD_MODULE
 541 EXPORT_SYMBOL(edd);
 542 #endif
 543 /**
 544  * copy_edd() - Copy the BIOS EDD information
 545  *              from boot_params into a safe place.
 546  *
 547  */
 548 static inline void copy_edd(void)
 549 {
 550      memcpy(edd.mbr_signature, EDD_MBR_SIGNATURE, sizeof(edd.mbr_signature));
 551      memcpy(edd.edd_info, EDD_BUF, sizeof(edd.edd_info));
 552      edd.mbr_signature_nr = EDD_MBR_SIG_NR;
 553      edd.edd_info_nr = EDD_NR;
 554 }
 555 #else
 556 static inline void copy_edd(void)
 557 {
 558 }
 559 #endif
 560
 561 #define EBDA_ADDR_POINTER 0x40E
 562 static void __init reserve_ebda_region(void)
 563 {
 564         unsigned int addr;
 565         /**
 566          * there is a real-mode segmented pointer pointing to the
 567          * 4K EBDA area at 0x40E
 568          */
 569         addr = *(unsigned short *)phys_to_virt(EBDA_ADDR_POINTER);
 570         addr <<= 4;
 571         if (addr)
 572                 reserve_bootmem_generic(addr, PAGE_SIZE);
 573 }
 574
 575 void __init setup_arch(char **cmdline_p)
 576 {
 577         unsigned long kernel_end;
 578
 579         ROOT_DEV = old_decode_dev(ORIG_ROOT_DEV);
 580         screen_info = SCREEN_INFO;
 581         edid_info = EDID_INFO;
 582         saved_video_mode = SAVED_VIDEO_MODE;
 583         bootloader_type = LOADER_TYPE;
 584
 585 #ifdef CONFIG_BLK_DEV_RAM
 586         rd_image_start = RAMDISK_FLAGS & RAMDISK_IMAGE_START_MASK;
 587         rd_prompt = ((RAMDISK_FLAGS & RAMDISK_PROMPT_FLAG) != 0);
 588         rd_doload = ((RAMDISK_FLAGS & RAMDISK_LOAD_FLAG) != 0);
 589 #endif
 590         setup_memory_region();
 591         copy_edd();
 592
 593         if (!MOUNT_ROOT_RDONLY)
 594                 root_mountflags &= ~MS_RDONLY;
 595         init_mm.start_code = (unsigned long) &_text;
 596         init_mm.end_code = (unsigned long) &_etext;
 597         init_mm.end_data = (unsigned long) &_edata;
 598         init_mm.brk = (unsigned long) &_end;
 599
 600         code_resource.start = virt_to_phys(&_text);
 601         code_resource.end = virt_to_phys(&_etext)-1;
 602         data_resource.start = virt_to_phys(&_etext);
 603         data_resource.end = virt_to_phys(&_edata)-1;
 604
 605         parse_cmdline_early(cmdline_p);
 606
 607         early_identify_cpu(&boot_cpu_data);
 608
 609         /*
 610          * partially used pages are not usable - thus
 611          * we are rounding upwards:
 612          */
 613         end_pfn = e820_end_of_ram();
 614
 615         check_efer();
 616
 617         init_memory_mapping(0, (end_pfn_map << PAGE_SHIFT));
 618
 619         zap_low_mappings(0);
 620
 621 #ifdef CONFIG_ACPI
 622         /*
 623          * Initialize the ACPI boot-time table parser (gets the RSDP and SDT).
 624          * Call this early for SRAT node setup.
 625          */
 626         acpi_boot_table_init();
 627 #endif
 628
 629 #ifdef CONFIG_ACPI_NUMA
 630         /*
 631          * Parse SRAT to discover nodes.
 632          */
 633         acpi_numa_init();
 634 #endif
 635
 636 #ifdef CONFIG_NUMA
 637         numa_initmem_init(0, end_pfn);
 638 #else
 639         contig_initmem_init(0, end_pfn);
 640 #endif
 641
 642         /* Reserve direct mapping */
 643         reserve_bootmem_generic(table_start << PAGE_SHIFT,
 644                                 (table_end - table_start) << PAGE_SHIFT);
 645
 646         /* reserve kernel */
 647         kernel_end = round_up(__pa_symbol(&_end),PAGE_SIZE);
 648         reserve_bootmem_generic(HIGH_MEMORY, kernel_end - HIGH_MEMORY);
 649
 650         /*
 651          * reserve physical page 0 - it's a special BIOS page on many boxes,
 652          * enabling clean reboots, SMP operation, laptop functions.
 653          */
 654         reserve_bootmem_generic(0, PAGE_SIZE);
 655
 656         /* reserve ebda region */
 657         reserve_ebda_region();
 658
 659 #ifdef CONFIG_SMP
 660         /*
 661          * But first pinch a few for the stack/trampoline stuff
 662          * FIXME: Don't need the extra page at 4K, but need to fix
 663          * trampoline before removing it. (see the GDT stuff)
 664          */
 665         reserve_bootmem_generic(PAGE_SIZE, PAGE_SIZE);
 666
 667         /* Reserve SMP trampoline */
 668         reserve_bootmem_generic(SMP_TRAMPOLINE_BASE, PAGE_SIZE);
 669 #endif
 670
 671 #ifdef CONFIG_ACPI_SLEEP
 672        /*
 673         * Reserve low memory region for sleep support.
 674         */
 675        acpi_reserve_bootmem();
 676 #endif
 677 #ifdef CONFIG_X86_LOCAL_APIC
 678         /*
 679          * Find and reserve possible boot-time SMP configuration:
 680          */
 681         find_smp_config();
 682 #endif
 683 #ifdef CONFIG_BLK_DEV_INITRD
 684         if (LOADER_TYPE && INITRD_START) {
 685                 if (INITRD_START + INITRD_SIZE <= (end_pfn << PAGE_SHIFT)) {
 686                         reserve_bootmem_generic(INITRD_START, INITRD_SIZE);
 687                         initrd_start =
 688                                 INITRD_START ? INITRD_START + PAGE_OFFSET : 0;
 689                         initrd_end = initrd_start+INITRD_SIZE;
 690                 }
 691                 else {
 692                         printk(KERN_ERR "initrd extends beyond end of memory "
 693                             "(0x%08lx > 0x%08lx)\ndisabling initrd\n",
 694                             (unsigned long)(INITRD_START + INITRD_SIZE),
 695                             (unsigned long)(end_pfn << PAGE_SHIFT));
 696                         initrd_start = 0;
 697                 }
 698         }
 699 #endif
 700 #ifdef CONFIG_KEXEC
 701         if (crashk_res.start != crashk_res.end) {
 702                 reserve_bootmem(crashk_res.start,
 703                         crashk_res.end - crashk_res.start + 1);
 704         }
 705 #endif
 706
 707         paging_init();
 708
 709         check_ioapic();
 710
 711 #ifdef CONFIG_ACPI
 712         /*
 713          * Read APIC and some other early information from ACPI tables.
 714          */
 715         acpi_boot_init();
 716 #endif
 717
 718         init_cpu_to_node();
 719
 720 #ifdef CONFIG_X86_LOCAL_APIC
 721         /*
 722          * get boot-time SMP configuration:
 723          */
 724         if (smp_found_config)
 725                 get_smp_config();
 726         init_apic_mappings();
 727 #endif
 728
 729         /*
 730          * Request address space for all standard RAM and ROM resources
 731          * and also for regions reported as reserved by the e820.
 732          */
 733         probe_roms();
 734         e820_reserve_resources();
 735
 736         request_resource(&iomem_resource, &video_ram_resource);
 737
 738         {
 739         unsigned i;
 740         /* request I/O space for devices used on all i[345]86 PCs */
 741         for (i = 0; i < STANDARD_IO_RESOURCES; i++)
 742                 request_resource(&ioport_resource, &standard_io_resources[i]);
 743         }
 744
 745         e820_setup_gap();
 746
 747 #ifdef CONFIG_GART_IOMMU
 748         iommu_hole_init();
 749 #endif
 750
 751 #ifdef CONFIG_VT
 752 #if defined(CONFIG_VGA_CONSOLE)
 753         conswitchp = &vga_con;
 754 #elif defined(CONFIG_DUMMY_CONSOLE)
 755         conswitchp = &dummy_con;
 756 #endif
 757 #endif
 758 }
 759
 760 static int __cpuinit get_model_name(struct cpuinfo_x86 *c)
 761 {
 762         unsigned int *v;
 763
 764         if (c->extended_cpuid_level < 0x80000004)
 765                 return 0;
 766
 767         v = (unsigned int *) c->x86_model_id;
 768         cpuid(0x80000002, &v[0], &v[1], &v[2], &v[3]);
 769         cpuid(0x80000003, &v[4], &v[5], &v[6], &v[7]);
 770         cpuid(0x80000004, &v[8], &v[9], &v[10], &v[11]);
 771         c->x86_model_id[48] = 0;
 772         return 1;
 773 }
 774
 775
 776 static void __cpuinit display_cacheinfo(struct cpuinfo_x86 *c)
 777 {
 778         unsigned int n, dummy, eax, ebx, ecx, edx;
 779
 780         n = c->extended_cpuid_level;
 781
 782         if (n >= 0x80000005) {
 783                 cpuid(0x80000005, &dummy, &ebx, &ecx, &edx);
 784                 printk(KERN_INFO "CPU: L1 I Cache: %dK (%d bytes/line), D cache %dK (%d bytes/line)\n",
 785                         edx>>24, edx&0xFF, ecx>>24, ecx&0xFF);
 786                 c->x86_cache_size=(ecx>>24)+(edx>>24);
 787                 /* On K8 L1 TLB is inclusive, so don't count it */
 788                 c->x86_tlbsize = 0;
 789         }
 790
 791         if (n >= 0x80000006) {
 792                 cpuid(0x80000006, &dummy, &ebx, &ecx, &edx);
 793                 ecx = cpuid_ecx(0x80000006);
 794                 c->x86_cache_size = ecx >> 16;
 795                 c->x86_tlbsize += ((ebx >> 16) & 0xfff) + (ebx & 0xfff);
 796
 797                 printk(KERN_INFO "CPU: L2 Cache: %dK (%d bytes/line)\n",
 798                 c->x86_cache_size, ecx & 0xFF);
 799         }
 800
 801         if (n >= 0x80000007)
 802                 cpuid(0x80000007, &dummy, &dummy, &dummy, &c->x86_power);
 803         if (n >= 0x80000008) {
 804                 cpuid(0x80000008, &eax, &dummy, &dummy, &dummy);
 805                 c->x86_virt_bits = (eax >> 8) & 0xff;
 806                 c->x86_phys_bits = eax & 0xff;
 807         }
 808 }
 809
 810 #ifdef CONFIG_NUMA
 811 static int nearby_node(int apicid)
 812 {
 813         int i;
 814         for (i = apicid - 1; i >= 0; i--) {
 815                 int node = apicid_to_node[i];
 816                 if (node != NUMA_NO_NODE && node_online(node))
 817                         return node;
 818         }
 819         for (i = apicid + 1; i < MAX_LOCAL_APIC; i++) {
 820                 int node = apicid_to_node[i];
 821                 if (node != NUMA_NO_NODE && node_online(node))
 822                         return node;
 823         }
 824         return first_node(node_online_map); /* Shouldn't happen */
 825 }
 826 #endif
 827
 828 /*
 829  * On a AMD dual core setup the lower bits of the APIC id distingush the cores.
 830  * Assumes number of cores is a power of two.
 831  */
 832 static void __init amd_detect_cmp(struct cpuinfo_x86 *c)
 833 {
 834 #ifdef CONFIG_SMP
 835         int cpu = smp_processor_id();
 836         unsigned bits;
 837 #ifdef CONFIG_NUMA
 838         int node = 0;
 839         unsigned apicid = phys_proc_id[cpu];
 840 #endif
 841
 842         bits = 0;
 843         while ((1 << bits) < c->x86_max_cores)
 844                 bits++;
 845
 846         /* Low order bits define the core id (index of core in socket) */
 847         cpu_core_id[cpu] = phys_proc_id[cpu] & ((1 << bits)-1);
 848         /* Convert the APIC ID into the socket ID */
 849         phys_proc_id[cpu] >>= bits;
 850
 851 #ifdef CONFIG_NUMA
 852         node = phys_proc_id[cpu];
 853         if (apicid_to_node[apicid] != NUMA_NO_NODE)
 854                 node = apicid_to_node[apicid];
 855         if (!node_online(node)) {
 856                 /* Two possibilities here:
 857                    - The CPU is missing memory and no node was created.
 858                    In that case try picking one from a nearby CPU
 859                    - The APIC IDs differ from the HyperTransport node IDs
 860                    which the K8 northbridge parsing fills in.
 861                    Assume they are all increased by a constant offset,
 862                    but in the same order as the HT nodeids.
 863                    If that doesn't result in a usable node fall back to the
 864                    path for the previous case.  */
 865                 int ht_nodeid = apicid - (phys_proc_id[0] << bits);
 866                 if (ht_nodeid >= 0 &&
 867                     apicid_to_node[ht_nodeid] != NUMA_NO_NODE)
 868                         node = apicid_to_node[ht_nodeid];
 869                 /* Pick a nearby node */
 870                 if (!node_online(node))
 871                         node = nearby_node(apicid);
 872         }
 873         numa_set_node(cpu, node);
 874
 875         printk(KERN_INFO "CPU %d(%d) -> Node %d -> Core %d\n",
 876                         cpu, c->x86_max_cores, node, cpu_core_id[cpu]);
 877 #endif
 878 #endif
 879 }
 880
 881 static int __init init_amd(struct cpuinfo_x86 *c)
 882 {
 883         int r;
 884         unsigned level;
 885
 886 #ifdef CONFIG_SMP
 887         unsigned long value;
 888
 889         /*
 890          * Disable TLB flush filter by setting HWCR.FFDIS on K8
 891          * bit 6 of msr C001_0015
 892          *
 893          * Errata 63 for SH-B3 steppings
 894          * Errata 122 for all steppings (F+ have it disabled by default)
 895          */
 896         if (c->x86 == 15) {
 897                 rdmsrl(MSR_K8_HWCR, value);
 898                 value |= 1 << 6;
 899                 wrmsrl(MSR_K8_HWCR, value);
 900         }
 901 #endif
 902
 903         /* Bit 31 in normal CPUID used for nonstandard 3DNow ID;
 904            3DNow is IDd by bit 31 in extended CPUID (1*32+31) anyway */
 905         clear_bit(0*32+31, &c->x86_capability);
 906
 907         /* On C+ stepping K8 rep microcode works well for copy/memset */
 908         level = cpuid_eax(1);
 909         if (c->x86 == 15 && ((level >= 0x0f48 && level < 0x0f50) || level >= 0x0f58))
 910                 set_bit(X86_FEATURE_REP_GOOD, &c->x86_capability);
 911
 912         /* Enable workaround for FXSAVE leak */
 913         if (c->x86 >= 6)
 914                 set_bit(X86_FEATURE_FXSAVE_LEAK, &c->x86_capability);
 915
 916         r = get_model_name(c);
 917         if (!r) {
 918                 switch (c->x86) {
 919                 case 15:
 920                         /* Should distinguish Models here, but this is only
 921                            a fallback anyways. */
 922                         strcpy(c->x86_model_id, "Hammer");
 923                         break;
 924                 }
 925         }
 926         display_cacheinfo(c);
 927
 928         /* c->x86_power is 8000_0007 edx. Bit 8 is constant TSC */
 929         if (c->x86_power & (1<<8))
 930                 set_bit(X86_FEATURE_CONSTANT_TSC, &c->x86_capability);
 931
 932         if (c->extended_cpuid_level >= 0x80000008) {
 933                 c->x86_max_cores = (cpuid_ecx(0x80000008) & 0xff) + 1;
 934                 if (c->x86_max_cores & (c->x86_max_cores - 1))
 935                         c->x86_max_cores = 1;
 936
 937                 amd_detect_cmp(c);
 938         }
 939
 940         return r;
 941 }
 942
 943 static void __cpuinit detect_ht(struct cpuinfo_x86 *c)
 944 {
 945 #ifdef CONFIG_SMP
 946         u32     eax, ebx, ecx, edx;
 947         int     index_msb, core_bits;
 948         int     cpu = smp_processor_id();
 949
 950         cpuid(1, &eax, &ebx, &ecx, &edx);
 951
 952         c->apicid = phys_pkg_id(0);
 953
 954         if (!cpu_has(c, X86_FEATURE_HT) || cpu_has(c, X86_FEATURE_CMP_LEGACY))
 955                 return;
 956
 957         smp_num_siblings = (ebx & 0xff0000) >> 16;
 958
 959         if (smp_num_siblings == 1) {
 960                 printk(KERN_INFO  "CPU: Hyper-Threading is disabled\n");
 961         } else if (smp_num_siblings > 1 ) {
 962
 963                 if (smp_num_siblings > NR_CPUS) {
 964                         printk(KERN_WARNING "CPU: Unsupported number of the siblings %d", smp_num_siblings);
 965                         smp_num_siblings = 1;
 966                         return;
 967                 }
 968
 969                 index_msb = get_count_order(smp_num_siblings);
 970                 phys_proc_id[cpu] = phys_pkg_id(index_msb);
 971
 972                 printk(KERN_INFO  "CPU: Physical Processor ID: %d\n",
 973                        phys_proc_id[cpu]);
 974
 975                 smp_num_siblings = smp_num_siblings / c->x86_max_cores;
 976
 977                 index_msb = get_count_order(smp_num_siblings) ;
 978
 979                 core_bits = get_count_order(c->x86_max_cores);
 980
 981                 cpu_core_id[cpu] = phys_pkg_id(index_msb) &
 982                                                ((1 << core_bits) - 1);
 983
 984                 if (c->x86_max_cores > 1)
 985                         printk(KERN_INFO  "CPU: Processor Core ID: %d\n",
 986                                cpu_core_id[cpu]);
 987         }
 988 #endif
 989 }
 990
 991 /*
 992  * find out the number of processor cores on the die
 993  */
 994 static int __cpuinit intel_num_cpu_cores(struct cpuinfo_x86 *c)
 995 {
 996         unsigned int eax;
 997
 998         if (c->cpuid_level < 4)
 999                 return 1;
1000
1001         __asm__("cpuid"
1002                 : "=a" (eax)
1003                 : "0" (4), "c" (0)
1004                 : "bx", "dx");
1005
1006         if (eax & 0x1f)
1007                 return ((eax >> 26) + 1);
1008         else
1009                 return 1;
1010 }
1011
1012 static void srat_detect_node(void)
1013 {
1014 #ifdef CONFIG_NUMA
1015         unsigned node;
1016         int cpu = smp_processor_id();
1017
1018         /* Don't do the funky fallback heuristics the AMD version employs
1019            for now. */
1020         node = apicid_to_node[hard_smp_processor_id()];
1021         if (node == NUMA_NO_NODE)
1022                 node = 0;
1023         numa_set_node(cpu, node);
1024
1025         if (acpi_numa > 0)
1026                 printk(KERN_INFO "CPU %d -> Node %d\n", cpu, node);
1027 #endif
1028 }
1029
1030 static void __cpuinit init_intel(struct cpuinfo_x86 *c)
1031 {
1032         /* Cache sizes */
1033         unsigned n;
1034
1035         init_intel_cacheinfo(c);
1036         n = c->extended_cpuid_level;
1037         if (n >= 0x80000008) {
1038                 unsigned eax = cpuid_eax(0x80000008);
1039                 c->x86_virt_bits = (eax >> 8) & 0xff;
1040                 c->x86_phys_bits = eax & 0xff;
1041                 /* CPUID workaround for Intel 0F34 CPU */
1042                 if (c->x86_vendor == X86_VENDOR_INTEL &&
1043                     c->x86 == 0xF && c->x86_model == 0x3 &&
1044                     c->x86_mask == 0x4)
1045                         c->x86_phys_bits = 36;
1046         }
1047
1048         if (c->x86 == 15)
1049                 c->x86_cache_alignment = c->x86_clflush_size * 2;
1050         if ((c->x86 == 0xf && c->x86_model >= 0x03) ||
1051             (c->x86 == 0x6 && c->x86_model >= 0x0e))
1052                 set_bit(X86_FEATURE_CONSTANT_TSC, &c->x86_capability);
1053         if (c->x86 == 15)
1054                 set_bit(X86_FEATURE_SYNC_RDTSC, &c->x86_capability);
1055         else
1056                 clear_bit(X86_FEATURE_SYNC_RDTSC, &c->x86_capability);
1057         c->x86_max_cores = intel_num_cpu_cores(c);
1058
1059         srat_detect_node();
1060 }
1061
1062 static void __cpuinit get_cpu_vendor(struct cpuinfo_x86 *c)
1063 {
1064         char *v = c->x86_vendor_id;
1065
1066         if (!strcmp(v, "AuthenticAMD"))
1067                 c->x86_vendor = X86_VENDOR_AMD;
1068         else if (!strcmp(v, "GenuineIntel"))
1069                 c->x86_vendor = X86_VENDOR_INTEL;
1070         else
1071                 c->x86_vendor = X86_VENDOR_UNKNOWN;
1072 }
1073
1074 struct cpu_model_info {
1075         int vendor;
1076         int family;
1077         char *model_names[16];
1078 };
1079
1080 /* Do some early cpuid on the boot CPU to get some parameter that are
1081    needed before check_bugs. Everything advanced is in identify_cpu
1082    below. */
1083 void __cpuinit early_identify_cpu(struct cpuinfo_x86 *c)
1084 {
1085         u32 tfms;
1086
1087         c->loops_per_jiffy = loops_per_jiffy;
1088         c->x86_cache_size = -1;
1089         c->x86_vendor = X86_VENDOR_UNKNOWN;
1090         c->x86_model = c->x86_mask = 0; /* So far unknown... */
1091         c->x86_vendor_id[0] = '\0'; /* Unset */
1092         c->x86_model_id[0] = '\0';  /* Unset */
1093         c->x86_clflush_size = 64;
1094         c->x86_cache_alignment = c->x86_clflush_size;
1095         c->x86_max_cores = 1;
1096         c->extended_cpuid_level = 0;
1097         memset(&c->x86_capability, 0, sizeof c->x86_capability);
1098
1099         /* Get vendor name */
1100         cpuid(0x00000000, (unsigned int *)&c->cpuid_level,
1101               (unsigned int *)&c->x86_vendor_id[0],
1102               (unsigned int *)&c->x86_vendor_id[8],
1103               (unsigned int *)&c->x86_vendor_id[4]);
1104
1105         get_cpu_vendor(c);
1106
1107         /* Initialize the standard set of capabilities */
1108         /* Note that the vendor-specific code below might override */
1109
1110         /* Intel-defined flags: level 0x00000001 */
1111         if (c->cpuid_level >= 0x00000001) {
1112                 __u32 misc;
1113                 cpuid(0x00000001, &tfms, &misc, &c->x86_capability[4],
1114                       &c->x86_capability[0]);
1115                 c->x86 = (tfms >> 8) & 0xf;
1116                 c->x86_model = (tfms >> 4) & 0xf;
1117                 c->x86_mask = tfms & 0xf;
1118                 if (c->x86 == 0xf)
1119                         c->x86 += (tfms >> 20) & 0xff;
1120                 if (c->x86 >= 0x6)
1121                         c->x86_model += ((tfms >> 16) & 0xF) << 4;
1122                 if (c->x86_capability[0] & (1<<19))
1123                         c->x86_clflush_size = ((misc >> 8) & 0xff) * 8;
1124         } else {
1125                 /* Have CPUID level 0 only - unheard of */
1126                 c->x86 = 4;
1127         }
1128
1129 #ifdef CONFIG_SMP
1130         phys_proc_id[smp_processor_id()] = (cpuid_ebx(1) >> 24) & 0xff;
1131 #endif
1132 }
1133
1134 /*
1135  * This does the hard work of actually picking apart the CPU stuff...
1136  */
1137 void __cpuinit identify_cpu(struct cpuinfo_x86 *c)
1138 {
1139         int i;
1140         u32 xlvl;
1141
1142         early_identify_cpu(c);
1143
1144         /* AMD-defined flags: level 0x80000001 */
1145         xlvl = cpuid_eax(0x80000000);
1146         c->extended_cpuid_level = xlvl;
1147         if ((xlvl & 0xffff0000) == 0x80000000) {
1148                 if (xlvl >= 0x80000001) {
1149                         c->x86_capability[1] = cpuid_edx(0x80000001);
1150                         c->x86_capability[6] = cpuid_ecx(0x80000001);
1151                 }
1152                 if (xlvl >= 0x80000004)
1153                         get_model_name(c); /* Default name */
1154         }
1155
1156         /* Transmeta-defined flags: level 0x80860001 */
1157         xlvl = cpuid_eax(0x80860000);
1158         if ((xlvl & 0xffff0000) == 0x80860000) {
1159                 /* Don't set x86_cpuid_level here for now to not confuse. */
1160                 if (xlvl >= 0x80860001)
1161                         c->x86_capability[2] = cpuid_edx(0x80860001);
1162         }
1163
1164         /*
1165          * Vendor-specific initialization.  In this section we
1166          * canonicalize the feature flags, meaning if there are
1167          * features a certain CPU supports which CPUID doesn't
1168          * tell us, CPUID claiming incorrect flags, or other bugs,
1169          * we handle them here.
1170          *
1171          * At the end of this section, c->x86_capability better
1172          * indicate the features this CPU genuinely supports!
1173          */
1174         switch (c->x86_vendor) {
1175         case X86_VENDOR_AMD:
1176                 init_amd(c);
1177                 break;
1178
1179         case X86_VENDOR_INTEL:
1180                 init_intel(c);
1181                 break;
1182
1183         case X86_VENDOR_UNKNOWN:
1184         default:
1185                 display_cacheinfo(c);
1186                 break;
1187         }
1188
1189         select_idle_routine(c);
1190         detect_ht(c);
1191
1192         /*
1193          * On SMP, boot_cpu_data holds the common feature set between
1194          * all CPUs; so make sure that we indicate which features are
1195          * common between the CPUs.  The first time this routine gets
1196          * executed, c == &boot_cpu_data.
1197          */
1198         if (c != &boot_cpu_data) {
1199                 /* AND the already accumulated flags with these */
1200                 for (i = 0 ; i < NCAPINTS ; i++)
1201                         boot_cpu_data.x86_capability[i] &= c->x86_capability[i];
1202         }
1203
1204 #ifdef CONFIG_X86_MCE
1205         mcheck_init(c);
1206 #endif
1207         if (c == &boot_cpu_data)
1208                 mtrr_bp_init();
1209         else
1210                 mtrr_ap_init();
1211 #ifdef CONFIG_NUMA
1212         numa_add_cpu(smp_processor_id());
1213 #endif
1214 }
1215
1216
1217 void __cpuinit print_cpu_info(struct cpuinfo_x86 *c)
1218 {
1219         if (c->x86_model_id[0])
1220                 printk("%s", c->x86_model_id);
1221
1222         if (c->x86_mask || c->cpuid_level >= 0)
1223                 printk(" stepping %02x\n", c->x86_mask);
1224         else
1225                 printk("\n");
1226 }
1227
1228 /*
1229  *      Get CPU information for use by the procfs.
1230  */
1231
1232 static int show_cpuinfo(struct seq_file *m, void *v)
1233 {
1234         struct cpuinfo_x86 *c = v;
1235
1236         /*
1237          * These flag bits must match the definitions in <asm/cpufeature.h>.
1238          * NULL means this bit is undefined or reserved; either way it doesn't
1239          * have meaning as far as Linux is concerned.  Note that it's important
1240          * to realize there is a difference between this table and CPUID -- if
1241          * applications want to get the raw CPUID data, they should access
1242          * /dev/cpu/<cpu_nr>/cpuid instead.
1243          */
1244         static char *x86_cap_flags[] = {
1245                 /* Intel-defined */
1246                 "fpu", "vme", "de", "pse", "tsc", "msr", "pae", "mce",
1247                 "cx8", "apic", NULL, "sep", "mtrr", "pge", "mca", "cmov",
1248                 "pat", "pse36", "pn", "clflush", NULL, "dts", "acpi", "mmx",
1249                 "fxsr", "sse", "sse2", "ss", "ht", "tm", "ia64", NULL,
1250
1251                 /* AMD-defined */
1252                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1253                 NULL, NULL, NULL, "syscall", NULL, NULL, NULL, NULL,
1254                 NULL, NULL, NULL, NULL, "nx", NULL, "mmxext", NULL,
1255                 NULL, "fxsr_opt", "rdtscp", NULL, NULL, "lm", "3dnowext", "3dnow",
1256
1257                 /* Transmeta-defined */
1258                 "recovery", "longrun", NULL, "lrti", NULL, NULL, NULL, NULL,
1259                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1260                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1261                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1262
1263                 /* Other (Linux-defined) */
1264                 "cxmmx", NULL, "cyrix_arr", "centaur_mcr", NULL,
1265                 "constant_tsc", NULL, NULL,
1266                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1267                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1268                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1269
1270                 /* Intel-defined (#2) */
1271                 "pni", NULL, NULL, "monitor", "ds_cpl", "vmx", NULL, "est",
1272                 "tm2", NULL, "cid", NULL, NULL, "cx16", "xtpr", NULL,
1273                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1274                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1275
1276                 /* VIA/Cyrix/Centaur-defined */
1277                 NULL, NULL, "rng", "rng_en", NULL, NULL, "ace", "ace_en",
1278                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1279                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1280                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1281
1282                 /* AMD-defined (#2) */
1283                 "lahf_lm", "cmp_legacy", "svm", NULL, "cr8_legacy", NULL, NULL, NULL,
1284                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1285                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1286                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1287         };
1288         static char *x86_power_flags[] = {
1289                 "ts",   /* temperature sensor */
1290                 "fid",  /* frequency id control */
1291                 "vid",  /* voltage id control */
1292                 "ttp",  /* thermal trip */
1293                 "tm",
1294                 "stc",
1295                 NULL,
1296                 /* nothing */   /* constant_tsc - moved to flags */
1297         };
1298
1299
1300 #ifdef CONFIG_SMP
1301         if (!cpu_online(c-cpu_data))
1302                 return 0;
1303 #endif
1304
1305         seq_printf(m,"processor\t: %u\n"
1306                      "vendor_id\t: %s\n"
1307                      "cpu family\t: %d\n"
1308                      "model\t\t: %d\n"
1309                      "model name\t: %s\n",
1310                      (unsigned)(c-cpu_data),
1311                      c->x86_vendor_id[0] ? c->x86_vendor_id : "unknown",
1312                      c->x86,
1313                      (int)c->x86_model,
1314                      c->x86_model_id[0] ? c->x86_model_id : "unknown");
1315
1316         if (c->x86_mask || c->cpuid_level >= 0)
1317                 seq_printf(m, "stepping\t: %d\n", c->x86_mask);
1318         else
1319                 seq_printf(m, "stepping\t: unknown\n");
1320
1321         if (cpu_has(c,X86_FEATURE_TSC)) {
1322                 unsigned int freq = cpufreq_quick_get((unsigned)(c-cpu_data));
1323                 if (!freq)
1324                         freq = cpu_khz;
1325                 seq_printf(m, "cpu MHz\t\t: %u.%03u\n",
1326                              freq / 1000, (freq % 1000));
1327         }
1328
1329         /* Cache size */
1330         if (c->x86_cache_size >= 0)
1331                 seq_printf(m, "cache size\t: %d KB\n", c->x86_cache_size);
1332
1333 #ifdef CONFIG_SMP
1334         if (smp_num_siblings * c->x86_max_cores > 1) {
1335                 int cpu = c - cpu_data;
1336                 seq_printf(m, "physical id\t: %d\n", phys_proc_id[cpu]);
1337                 seq_printf(m, "siblings\t: %d\n", cpus_weight(cpu_core_map[cpu]));
1338                 seq_printf(m, "core id\t\t: %d\n", cpu_core_id[cpu]);
1339                 seq_printf(m, "cpu cores\t: %d\n", c->booted_cores);
1340         }
1341 #endif
1342
1343         seq_printf(m,
1344                 "fpu\t\t: yes\n"
1345                 "fpu_exception\t: yes\n"
1346                 "cpuid level\t: %d\n"
1347                 "wp\t\t: yes\n"
1348                 "flags\t\t:",
1349                    c->cpuid_level);
1350
1351         {
1352                 int i;
1353                 for ( i = 0 ; i < 32*NCAPINTS ; i++ )
1354                         if ( test_bit(i, &c->x86_capability) &&
1355                              x86_cap_flags[i] != NULL )
1356                                 seq_printf(m, " %s", x86_cap_flags[i]);
1357         }
1358
1359         seq_printf(m, "\nbogomips\t: %lu.%02lu\n",
1360                    c->loops_per_jiffy/(500000/HZ),
1361                    (c->loops_per_jiffy/(5000/HZ)) % 100);
1362
1363         if (c->x86_tlbsize > 0)
1364                 seq_printf(m, "TLB size\t: %d 4K pages\n", c->x86_tlbsize);
1365         seq_printf(m, "clflush size\t: %d\n", c->x86_clflush_size);
1366         seq_printf(m, "cache_alignment\t: %d\n", c->x86_cache_alignment);
1367
1368         seq_printf(m, "address sizes\t: %u bits physical, %u bits virtual\n",
1369                    c->x86_phys_bits, c->x86_virt_bits);
1370
1371         seq_printf(m, "power management:");
1372         {
1373                 unsigned i;
1374                 for (i = 0; i < 32; i++)
1375                         if (c->x86_power & (1 << i)) {
1376                                 if (i < ARRAY_SIZE(x86_power_flags) &&
1377                                         x86_power_flags[i])
1378                                         seq_printf(m, "%s%s",
1379                                                 x86_power_flags[i][0]?" ":"",
1380                                                 x86_power_flags[i]);
1381                                 else
1382                                         seq_printf(m, " [%d]", i);
1383                         }
1384         }
1385
1386         seq_printf(m, "\n\n");
1387
1388         return 0;
1389 }
1390
1391 static void *c_start(struct seq_file *m, loff_t *pos)
1392 {
1393         return *pos < NR_CPUS ? cpu_data + *pos : NULL;
1394 }
1395
1396 static void *c_next(struct seq_file *m, void *v, loff_t *pos)
1397 {
1398         ++*pos;
1399         return c_start(m, pos);
1400 }
1401
1402 static void c_stop(struct seq_file *m, void *v)
1403 {
1404 }
1405
1406 struct seq_operations cpuinfo_op = {
1407         .start =c_start,
1408         .next = c_next,
1409         .stop = c_stop,
1410         .show = show_cpuinfo,
1411 };
1412
1413 static int __init run_dmi_scan(void)
1414 {
1415         dmi_scan_machine();
1416         return 0;
1417 }
1418 core_initcall(run_dmi_scan);
1419