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