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