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