arch/x86/kernel/setup_64.c

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