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