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         x86_bios_cpu_apicid_early_ptr = (void *)&x86_bios_cpu_apicid_init;
 342 #endif
 343
 344 #ifdef CONFIG_ACPI
 345         /*
 346          * Initialize the ACPI boot-time table parser (gets the RSDP and SDT).
 347          * Call this early for SRAT node setup.
 348          */
 349         acpi_boot_table_init();
 350 #endif
 351
 352         /* How many end-of-memory variables you have, grandma! */
 353         max_low_pfn = end_pfn;
 354         max_pfn = end_pfn;
 355         high_memory = (void *)__va(end_pfn * PAGE_SIZE - 1) + 1;
 356
 357         /* Remove active ranges so rediscovery with NUMA-awareness happens */
 358         remove_all_active_ranges();
 359
 360 #ifdef CONFIG_ACPI_NUMA
 361         /*
 362          * Parse SRAT to discover nodes.
 363          */
 364         acpi_numa_init();
 365 #endif
 366
 367 #ifdef CONFIG_NUMA
 368         numa_initmem_init(0, end_pfn);
 369 #else
 370         contig_initmem_init(0, end_pfn);
 371 #endif
 372
 373         early_res_to_bootmem();
 374
 375 #ifdef CONFIG_ACPI_SLEEP
 376         /*
 377          * Reserve low memory region for sleep support.
 378          */
 379        acpi_reserve_bootmem();
 380 #endif
 381
 382         if (efi_enabled) {
 383                 efi_map_memmap();
 384                 efi_reserve_bootmem();
 385         }
 386
 387        /*
 388         * Find and reserve possible boot-time SMP configuration:
 389         */
 390         find_smp_config();
 391 #ifdef CONFIG_BLK_DEV_INITRD
 392         if (boot_params.hdr.type_of_loader && boot_params.hdr.ramdisk_image) {
 393                 unsigned long ramdisk_image = boot_params.hdr.ramdisk_image;
 394                 unsigned long ramdisk_size  = boot_params.hdr.ramdisk_size;
 395                 unsigned long ramdisk_end   = ramdisk_image + ramdisk_size;
 396                 unsigned long end_of_mem    = end_pfn << PAGE_SHIFT;
 397
 398                 if (ramdisk_end <= end_of_mem) {
 399                         reserve_bootmem_generic(ramdisk_image, ramdisk_size);
 400                         initrd_start = ramdisk_image + PAGE_OFFSET;
 401                         initrd_end = initrd_start+ramdisk_size;
 402                 } else {
 403                         /* Assumes everything on node 0 */
 404                         free_bootmem(ramdisk_image, ramdisk_size);
 405                         printk(KERN_ERR "initrd extends beyond end of memory "
 406                                "(0x%08lx > 0x%08lx)\ndisabling initrd\n",
 407                                ramdisk_end, end_of_mem);
 408                         initrd_start = 0;
 409                 }
 410         }
 411 #endif
 412         reserve_crashkernel();
 413         paging_init();
 414         map_vsyscall();
 415
 416         early_quirks();
 417
 418         /*
 419          * set this early, so we dont allocate cpu0
 420          * if MADT list doesnt list BSP first
 421          * mpparse.c/MP_processor_info() allocates logical cpu numbers.
 422          */
 423         cpu_set(0, cpu_present_map);
 424 #ifdef CONFIG_ACPI
 425         /*
 426          * Read APIC and some other early information from ACPI tables.
 427          */
 428         acpi_boot_init();
 429 #endif
 430
 431         init_cpu_to_node();
 432
 433         /*
 434          * get boot-time SMP configuration:
 435          */
 436         if (smp_found_config)
 437                 get_smp_config();
 438         init_apic_mappings();
 439         ioapic_init_mappings();
 440
 441         /*
 442          * We trust e820 completely. No explicit ROM probing in memory.
 443          */
 444         e820_reserve_resources(&code_resource, &data_resource, &bss_resource);
 445         e820_mark_nosave_regions();
 446
 447         /* request I/O space for devices used on all i[345]86 PCs */
 448         for (i = 0; i < ARRAY_SIZE(standard_io_resources); i++)
 449                 request_resource(&ioport_resource, &standard_io_resources[i]);
 450
 451         e820_setup_gap();
 452
 453 #ifdef CONFIG_VT
 454 #if defined(CONFIG_VGA_CONSOLE)
 455         if (!efi_enabled || (efi_mem_type(0xa0000) != EFI_CONVENTIONAL_MEMORY))
 456                 conswitchp = &vga_con;
 457 #elif defined(CONFIG_DUMMY_CONSOLE)
 458         conswitchp = &dummy_con;
 459 #endif
 460 #endif
 461 }
 462
 463 static int __cpuinit get_model_name(struct cpuinfo_x86 *c)
 464 {
 465         unsigned int *v;
 466
 467         if (c->extended_cpuid_level < 0x80000004)
 468                 return 0;
 469
 470         v = (unsigned int *) c->x86_model_id;
 471         cpuid(0x80000002, &v[0], &v[1], &v[2], &v[3]);
 472         cpuid(0x80000003, &v[4], &v[5], &v[6], &v[7]);
 473         cpuid(0x80000004, &v[8], &v[9], &v[10], &v[11]);
 474         c->x86_model_id[48] = 0;
 475         return 1;
 476 }
 477
 478
 479 static void __cpuinit display_cacheinfo(struct cpuinfo_x86 *c)
 480 {
 481         unsigned int n, dummy, eax, ebx, ecx, edx;
 482
 483         n = c->extended_cpuid_level;
 484
 485         if (n >= 0x80000005) {
 486                 cpuid(0x80000005, &dummy, &ebx, &ecx, &edx);
 487                 printk(KERN_INFO "CPU: L1 I Cache: %dK (%d bytes/line), "
 488                        "D cache %dK (%d bytes/line)\n",
 489                        edx>>24, edx&0xFF, ecx>>24, ecx&0xFF);
 490                 c->x86_cache_size = (ecx>>24) + (edx>>24);
 491                 /* On K8 L1 TLB is inclusive, so don't count it */
 492                 c->x86_tlbsize = 0;
 493         }
 494
 495         if (n >= 0x80000006) {
 496                 cpuid(0x80000006, &dummy, &ebx, &ecx, &edx);
 497                 ecx = cpuid_ecx(0x80000006);
 498                 c->x86_cache_size = ecx >> 16;
 499                 c->x86_tlbsize += ((ebx >> 16) & 0xfff) + (ebx & 0xfff);
 500
 501                 printk(KERN_INFO "CPU: L2 Cache: %dK (%d bytes/line)\n",
 502                 c->x86_cache_size, ecx & 0xFF);
 503         }
 504         if (n >= 0x80000008) {
 505                 cpuid(0x80000008, &eax, &dummy, &dummy, &dummy);
 506                 c->x86_virt_bits = (eax >> 8) & 0xff;
 507                 c->x86_phys_bits = eax & 0xff;
 508         }
 509 }
 510
 511 #ifdef CONFIG_NUMA
 512 static int nearby_node(int apicid)
 513 {
 514         int i, node;
 515
 516         for (i = apicid - 1; i >= 0; i--) {
 517                 node = apicid_to_node[i];
 518                 if (node != NUMA_NO_NODE && node_online(node))
 519                         return node;
 520         }
 521         for (i = apicid + 1; i < MAX_LOCAL_APIC; i++) {
 522                 node = apicid_to_node[i];
 523                 if (node != NUMA_NO_NODE && node_online(node))
 524                         return node;
 525         }
 526         return first_node(node_online_map); /* Shouldn't happen */
 527 }
 528 #endif
 529
 530 /*
 531  * On a AMD dual core setup the lower bits of the APIC id distingush the cores.
 532  * Assumes number of cores is a power of two.
 533  */
 534 static void __init amd_detect_cmp(struct cpuinfo_x86 *c)
 535 {
 536 #ifdef CONFIG_SMP
 537         unsigned bits;
 538 #ifdef CONFIG_NUMA
 539         int cpu = smp_processor_id();
 540         int node = 0;
 541         unsigned apicid = hard_smp_processor_id();
 542 #endif
 543         bits = c->x86_coreid_bits;
 544
 545         /* Low order bits define the core id (index of core in socket) */
 546         c->cpu_core_id = c->phys_proc_id & ((1 << bits)-1);
 547         /* Convert the APIC ID into the socket ID */
 548         c->phys_proc_id = phys_pkg_id(bits);
 549
 550 #ifdef CONFIG_NUMA
 551         node = c->phys_proc_id;
 552         if (apicid_to_node[apicid] != NUMA_NO_NODE)
 553                 node = apicid_to_node[apicid];
 554         if (!node_online(node)) {
 555                 /* Two possibilities here:
 556                    - The CPU is missing memory and no node was created.
 557                    In that case try picking one from a nearby CPU
 558                    - The APIC IDs differ from the HyperTransport node IDs
 559                    which the K8 northbridge parsing fills in.
 560                    Assume they are all increased by a constant offset,
 561                    but in the same order as the HT nodeids.
 562                    If that doesn't result in a usable node fall back to the
 563                    path for the previous case.  */
 564
 565                 int ht_nodeid = apicid - (cpu_data(0).phys_proc_id << bits);
 566
 567                 if (ht_nodeid >= 0 &&
 568                     apicid_to_node[ht_nodeid] != NUMA_NO_NODE)
 569                         node = apicid_to_node[ht_nodeid];
 570                 /* Pick a nearby node */
 571                 if (!node_online(node))
 572                         node = nearby_node(apicid);
 573         }
 574         numa_set_node(cpu, node);
 575
 576         printk(KERN_INFO "CPU %d/%x -> Node %d\n", cpu, apicid, node);
 577 #endif
 578 #endif
 579 }
 580
 581 static void __cpuinit early_init_amd_mc(struct cpuinfo_x86 *c)
 582 {
 583 #ifdef CONFIG_SMP
 584         unsigned bits, ecx;
 585
 586         /* Multi core CPU? */
 587         if (c->extended_cpuid_level < 0x80000008)
 588                 return;
 589
 590         ecx = cpuid_ecx(0x80000008);
 591
 592         c->x86_max_cores = (ecx & 0xff) + 1;
 593
 594         /* CPU telling us the core id bits shift? */
 595         bits = (ecx >> 12) & 0xF;
 596
 597         /* Otherwise recompute */
 598         if (bits == 0) {
 599                 while ((1 << bits) < c->x86_max_cores)
 600                         bits++;
 601         }
 602
 603         c->x86_coreid_bits = bits;
 604
 605 #endif
 606 }
 607
 608 #define ENABLE_C1E_MASK         0x18000000
 609 #define CPUID_PROCESSOR_SIGNATURE       1
 610 #define CPUID_XFAM              0x0ff00000
 611 #define CPUID_XFAM_K8           0x00000000
 612 #define CPUID_XFAM_10H          0x00100000
 613 #define CPUID_XFAM_11H          0x00200000
 614 #define CPUID_XMOD              0x000f0000
 615 #define CPUID_XMOD_REV_F        0x00040000
 616
 617 /* AMD systems with C1E don't have a working lAPIC timer. Check for that. */
 618 static __cpuinit int amd_apic_timer_broken(void)
 619 {
 620         u32 lo, hi, eax = cpuid_eax(CPUID_PROCESSOR_SIGNATURE);
 621
 622         switch (eax & CPUID_XFAM) {
 623         case CPUID_XFAM_K8:
 624                 if ((eax & CPUID_XMOD) < CPUID_XMOD_REV_F)
 625                         break;
 626         case CPUID_XFAM_10H:
 627         case CPUID_XFAM_11H:
 628                 rdmsr(MSR_K8_ENABLE_C1E, lo, hi);
 629                 if (lo & ENABLE_C1E_MASK)
 630                         return 1;
 631                 break;
 632         default:
 633                 /* err on the side of caution */
 634                 return 1;
 635         }
 636         return 0;
 637 }
 638
 639 static void __cpuinit early_init_amd(struct cpuinfo_x86 *c)
 640 {
 641         early_init_amd_mc(c);
 642
 643         /* c->x86_power is 8000_0007 edx. Bit 8 is constant TSC */
 644         if (c->x86_power & (1<<8))
 645                 set_cpu_cap(c, X86_FEATURE_CONSTANT_TSC);
 646 }
 647
 648 static void __cpuinit init_amd(struct cpuinfo_x86 *c)
 649 {
 650         unsigned level;
 651
 652 #ifdef CONFIG_SMP
 653         unsigned long value;
 654
 655         /*
 656          * Disable TLB flush filter by setting HWCR.FFDIS on K8
 657          * bit 6 of msr C001_0015
 658          *
 659          * Errata 63 for SH-B3 steppings
 660          * Errata 122 for all steppings (F+ have it disabled by default)
 661          */
 662         if (c->x86 == 15) {
 663                 rdmsrl(MSR_K8_HWCR, value);
 664                 value |= 1 << 6;
 665                 wrmsrl(MSR_K8_HWCR, value);
 666         }
 667 #endif
 668
 669         /* Bit 31 in normal CPUID used for nonstandard 3DNow ID;
 670            3DNow is IDd by bit 31 in extended CPUID (1*32+31) anyway */
 671         clear_bit(0*32+31, (unsigned long *)&c->x86_capability);
 672
 673         /* On C+ stepping K8 rep microcode works well for copy/memset */
 674         level = cpuid_eax(1);
 675         if (c->x86 == 15 && ((level >= 0x0f48 && level < 0x0f50) ||
 676                              level >= 0x0f58))
 677                 set_cpu_cap(c, X86_FEATURE_REP_GOOD);
 678         if (c->x86 == 0x10 || c->x86 == 0x11)
 679                 set_cpu_cap(c, X86_FEATURE_REP_GOOD);
 680
 681         /* Enable workaround for FXSAVE leak */
 682         if (c->x86 >= 6)
 683                 set_cpu_cap(c, X86_FEATURE_FXSAVE_LEAK);
 684
 685         level = get_model_name(c);
 686         if (!level) {
 687                 switch (c->x86) {
 688                 case 15:
 689                         /* Should distinguish Models here, but this is only
 690                            a fallback anyways. */
 691                         strcpy(c->x86_model_id, "Hammer");
 692                         break;
 693                 }
 694         }
 695         display_cacheinfo(c);
 696
 697         /* Multi core CPU? */
 698         if (c->extended_cpuid_level >= 0x80000008)
 699                 amd_detect_cmp(c);
 700
 701         if (c->extended_cpuid_level >= 0x80000006 &&
 702                 (cpuid_edx(0x80000006) & 0xf000))
 703                 num_cache_leaves = 4;
 704         else
 705                 num_cache_leaves = 3;
 706
 707         if (c->x86 == 0xf || c->x86 == 0x10 || c->x86 == 0x11)
 708                 set_cpu_cap(c, X86_FEATURE_K8);
 709
 710         /* MFENCE stops RDTSC speculation */
 711         set_cpu_cap(c, X86_FEATURE_MFENCE_RDTSC);
 712
 713         if (amd_apic_timer_broken())
 714                 disable_apic_timer = 1;
 715 }
 716
 717 void __cpuinit detect_ht(struct cpuinfo_x86 *c)
 718 {
 719 #ifdef CONFIG_SMP
 720         u32 eax, ebx, ecx, edx;
 721         int index_msb, core_bits;
 722
 723         cpuid(1, &eax, &ebx, &ecx, &edx);
 724
 725
 726         if (!cpu_has(c, X86_FEATURE_HT))
 727                 return;
 728         if (cpu_has(c, X86_FEATURE_CMP_LEGACY))
 729                 goto out;
 730
 731         smp_num_siblings = (ebx & 0xff0000) >> 16;
 732
 733         if (smp_num_siblings == 1) {
 734                 printk(KERN_INFO  "CPU: Hyper-Threading is disabled\n");
 735         } else if (smp_num_siblings > 1) {
 736
 737                 if (smp_num_siblings > NR_CPUS) {
 738                         printk(KERN_WARNING "CPU: Unsupported number of "
 739                                "siblings %d", smp_num_siblings);
 740                         smp_num_siblings = 1;
 741                         return;
 742                 }
 743
 744                 index_msb = get_count_order(smp_num_siblings);
 745                 c->phys_proc_id = phys_pkg_id(index_msb);
 746
 747                 smp_num_siblings = smp_num_siblings / c->x86_max_cores;
 748
 749                 index_msb = get_count_order(smp_num_siblings);
 750
 751                 core_bits = get_count_order(c->x86_max_cores);
 752
 753                 c->cpu_core_id = phys_pkg_id(index_msb) &
 754                                                ((1 << core_bits) - 1);
 755         }
 756 out:
 757         if ((c->x86_max_cores * smp_num_siblings) > 1) {
 758                 printk(KERN_INFO  "CPU: Physical Processor ID: %d\n",
 759                        c->phys_proc_id);
 760                 printk(KERN_INFO  "CPU: Processor Core ID: %d\n",
 761                        c->cpu_core_id);
 762         }
 763
 764 #endif
 765 }
 766
 767 /*
 768  * find out the number of processor cores on the die
 769  */
 770 static int __cpuinit intel_num_cpu_cores(struct cpuinfo_x86 *c)
 771 {
 772         unsigned int eax, t;
 773
 774         if (c->cpuid_level < 4)
 775                 return 1;
 776
 777         cpuid_count(4, 0, &eax, &t, &t, &t);
 778
 779         if (eax & 0x1f)
 780                 return ((eax >> 26) + 1);
 781         else
 782                 return 1;
 783 }
 784
 785 static void srat_detect_node(void)
 786 {
 787 #ifdef CONFIG_NUMA
 788         unsigned node;
 789         int cpu = smp_processor_id();
 790         int apicid = hard_smp_processor_id();
 791
 792         /* Don't do the funky fallback heuristics the AMD version employs
 793            for now. */
 794         node = apicid_to_node[apicid];
 795         if (node == NUMA_NO_NODE)
 796                 node = first_node(node_online_map);
 797         numa_set_node(cpu, node);
 798
 799         printk(KERN_INFO "CPU %d/%x -> Node %d\n", cpu, apicid, node);
 800 #endif
 801 }
 802
 803 static void __cpuinit early_init_intel(struct cpuinfo_x86 *c)
 804 {
 805         if ((c->x86 == 0xf && c->x86_model >= 0x03) ||
 806             (c->x86 == 0x6 && c->x86_model >= 0x0e))
 807                 set_bit(X86_FEATURE_CONSTANT_TSC, &c->x86_capability);
 808 }
 809
 810 static void __cpuinit init_intel(struct cpuinfo_x86 *c)
 811 {
 812         /* Cache sizes */
 813         unsigned n;
 814
 815         init_intel_cacheinfo(c);
 816         if (c->cpuid_level > 9) {
 817                 unsigned eax = cpuid_eax(10);
 818                 /* Check for version and the number of counters */
 819                 if ((eax & 0xff) && (((eax>>8) & 0xff) > 1))
 820                         set_cpu_cap(c, X86_FEATURE_ARCH_PERFMON);
 821         }
 822
 823         if (cpu_has_ds) {
 824                 unsigned int l1, l2;
 825                 rdmsr(MSR_IA32_MISC_ENABLE, l1, l2);
 826                 if (!(l1 & (1<<11)))
 827                         set_cpu_cap(c, X86_FEATURE_BTS);
 828                 if (!(l1 & (1<<12)))
 829                         set_cpu_cap(c, X86_FEATURE_PEBS);
 830         }
 831
 832
 833         if (cpu_has_bts)
 834                 ds_init_intel(c);
 835
 836         n = c->extended_cpuid_level;
 837         if (n >= 0x80000008) {
 838                 unsigned eax = cpuid_eax(0x80000008);
 839                 c->x86_virt_bits = (eax >> 8) & 0xff;
 840                 c->x86_phys_bits = eax & 0xff;
 841                 /* CPUID workaround for Intel 0F34 CPU */
 842                 if (c->x86_vendor == X86_VENDOR_INTEL &&
 843                     c->x86 == 0xF && c->x86_model == 0x3 &&
 844                     c->x86_mask == 0x4)
 845                         c->x86_phys_bits = 36;
 846         }
 847
 848         if (c->x86 == 15)
 849                 c->x86_cache_alignment = c->x86_clflush_size * 2;
 850         if ((c->x86 == 0xf && c->x86_model >= 0x03) ||
 851             (c->x86 == 0x6 && c->x86_model >= 0x0e))
 852                 set_cpu_cap(c, X86_FEATURE_CONSTANT_TSC);
 853         if (c->x86 == 6)
 854                 set_cpu_cap(c, X86_FEATURE_REP_GOOD);
 855         set_cpu_cap(c, X86_FEATURE_LFENCE_RDTSC);
 856         c->x86_max_cores = intel_num_cpu_cores(c);
 857
 858         srat_detect_node();
 859 }
 860
 861 static void __cpuinit get_cpu_vendor(struct cpuinfo_x86 *c)
 862 {
 863         char *v = c->x86_vendor_id;
 864
 865         if (!strcmp(v, "AuthenticAMD"))
 866                 c->x86_vendor = X86_VENDOR_AMD;
 867         else if (!strcmp(v, "GenuineIntel"))
 868                 c->x86_vendor = X86_VENDOR_INTEL;
 869         else
 870                 c->x86_vendor = X86_VENDOR_UNKNOWN;
 871 }
 872
 873 struct cpu_model_info {
 874         int vendor;
 875         int family;
 876         char *model_names[16];
 877 };
 878
 879 /* Do some early cpuid on the boot CPU to get some parameter that are
 880    needed before check_bugs. Everything advanced is in identify_cpu
 881    below. */
 882 static void __cpuinit early_identify_cpu(struct cpuinfo_x86 *c)
 883 {
 884         u32 tfms, xlvl;
 885
 886         c->loops_per_jiffy = loops_per_jiffy;
 887         c->x86_cache_size = -1;
 888         c->x86_vendor = X86_VENDOR_UNKNOWN;
 889         c->x86_model = c->x86_mask = 0; /* So far unknown... */
 890         c->x86_vendor_id[0] = '\0'; /* Unset */
 891         c->x86_model_id[0] = '\0';  /* Unset */
 892         c->x86_clflush_size = 64;
 893         c->x86_cache_alignment = c->x86_clflush_size;
 894         c->x86_max_cores = 1;
 895         c->x86_coreid_bits = 0;
 896         c->extended_cpuid_level = 0;
 897         memset(&c->x86_capability, 0, sizeof c->x86_capability);
 898
 899         /* Get vendor name */
 900         cpuid(0x00000000, (unsigned int *)&c->cpuid_level,
 901               (unsigned int *)&c->x86_vendor_id[0],
 902               (unsigned int *)&c->x86_vendor_id[8],
 903               (unsigned int *)&c->x86_vendor_id[4]);
 904
 905         get_cpu_vendor(c);
 906
 907         /* Initialize the standard set of capabilities */
 908         /* Note that the vendor-specific code below might override */
 909
 910         /* Intel-defined flags: level 0x00000001 */
 911         if (c->cpuid_level >= 0x00000001) {
 912                 __u32 misc;
 913                 cpuid(0x00000001, &tfms, &misc, &c->x86_capability[4],
 914                       &c->x86_capability[0]);
 915                 c->x86 = (tfms >> 8) & 0xf;
 916                 c->x86_model = (tfms >> 4) & 0xf;
 917                 c->x86_mask = tfms & 0xf;
 918                 if (c->x86 == 0xf)
 919                         c->x86 += (tfms >> 20) & 0xff;
 920                 if (c->x86 >= 0x6)
 921                         c->x86_model += ((tfms >> 16) & 0xF) << 4;
 922                 if (c->x86_capability[0] & (1<<19))
 923                         c->x86_clflush_size = ((misc >> 8) & 0xff) * 8;
 924         } else {
 925                 /* Have CPUID level 0 only - unheard of */
 926                 c->x86 = 4;
 927         }
 928
 929 #ifdef CONFIG_SMP
 930         c->phys_proc_id = (cpuid_ebx(1) >> 24) & 0xff;
 931 #endif
 932         /* AMD-defined flags: level 0x80000001 */
 933         xlvl = cpuid_eax(0x80000000);
 934         c->extended_cpuid_level = xlvl;
 935         if ((xlvl & 0xffff0000) == 0x80000000) {
 936                 if (xlvl >= 0x80000001) {
 937                         c->x86_capability[1] = cpuid_edx(0x80000001);
 938                         c->x86_capability[6] = cpuid_ecx(0x80000001);
 939                 }
 940                 if (xlvl >= 0x80000004)
 941                         get_model_name(c); /* Default name */
 942         }
 943
 944         /* Transmeta-defined flags: level 0x80860001 */
 945         xlvl = cpuid_eax(0x80860000);
 946         if ((xlvl & 0xffff0000) == 0x80860000) {
 947                 /* Don't set x86_cpuid_level here for now to not confuse. */
 948                 if (xlvl >= 0x80860001)
 949                         c->x86_capability[2] = cpuid_edx(0x80860001);
 950         }
 951
 952         c->extended_cpuid_level = cpuid_eax(0x80000000);
 953         if (c->extended_cpuid_level >= 0x80000007)
 954                 c->x86_power = cpuid_edx(0x80000007);
 955
 956         switch (c->x86_vendor) {
 957         case X86_VENDOR_AMD:
 958                 early_init_amd(c);
 959                 break;
 960         case X86_VENDOR_INTEL:
 961                 early_init_intel(c);
 962                 break;
 963         }
 964
 965 }
 966
 967 /*
 968  * This does the hard work of actually picking apart the CPU stuff...
 969  */
 970 void __cpuinit identify_cpu(struct cpuinfo_x86 *c)
 971 {
 972         int i;
 973
 974         early_identify_cpu(c);
 975
 976         init_scattered_cpuid_features(c);
 977
 978         c->apicid = phys_pkg_id(0);
 979
 980         /*
 981          * Vendor-specific initialization.  In this section we
 982          * canonicalize the feature flags, meaning if there are
 983          * features a certain CPU supports which CPUID doesn't
 984          * tell us, CPUID claiming incorrect flags, or other bugs,
 985          * we handle them here.
 986          *
 987          * At the end of this section, c->x86_capability better
 988          * indicate the features this CPU genuinely supports!
 989          */
 990         switch (c->x86_vendor) {
 991         case X86_VENDOR_AMD:
 992                 init_amd(c);
 993                 break;
 994
 995         case X86_VENDOR_INTEL:
 996                 init_intel(c);
 997                 break;
 998
 999         case X86_VENDOR_UNKNOWN:
1000         default:
1001                 display_cacheinfo(c);
1002                 break;
1003         }
1004
1005         detect_ht(c);
1006
1007         /*
1008          * On SMP, boot_cpu_data holds the common feature set between
1009          * all CPUs; so make sure that we indicate which features are
1010          * common between the CPUs.  The first time this routine gets
1011          * executed, c == &boot_cpu_data.
1012          */
1013         if (c != &boot_cpu_data) {
1014                 /* AND the already accumulated flags with these */
1015                 for (i = 0; i < NCAPINTS; i++)
1016                         boot_cpu_data.x86_capability[i] &= c->x86_capability[i];
1017         }
1018
1019         /* Clear all flags overriden by options */
1020         for (i = 0; i < NCAPINTS; i++)
1021                 c->x86_capability[i] ^= cleared_cpu_caps[i];
1022
1023 #ifdef CONFIG_X86_MCE
1024         mcheck_init(c);
1025 #endif
1026         select_idle_routine(c);
1027
1028         if (c != &boot_cpu_data)
1029                 mtrr_ap_init();
1030 #ifdef CONFIG_NUMA
1031         numa_add_cpu(smp_processor_id());
1032 #endif
1033
1034 }
1035
1036 static __init int setup_noclflush(char *arg)
1037 {
1038         setup_clear_cpu_cap(X86_FEATURE_CLFLSH);
1039         return 1;
1040 }
1041 __setup("noclflush", setup_noclflush);
1042
1043 void __cpuinit print_cpu_info(struct cpuinfo_x86 *c)
1044 {
1045         if (c->x86_model_id[0])
1046                 printk(KERN_INFO "%s", c->x86_model_id);
1047
1048         if (c->x86_mask || c->cpuid_level >= 0)
1049                 printk(KERN_CONT " stepping %02x\n", c->x86_mask);
1050         else
1051                 printk(KERN_CONT "\n");
1052 }
1053
1054 static __init int setup_disablecpuid(char *arg)
1055 {
1056         int bit;
1057         if (get_option(&arg, &bit) && bit < NCAPINTS*32)
1058                 setup_clear_cpu_cap(bit);
1059         else
1060                 return 0;
1061         return 1;
1062 }
1063 __setup("clearcpuid=", setup_disablecpuid);
1064
1065 /*
1066  *      Get CPU information for use by the procfs.
1067  */
1068
1069 static int show_cpuinfo(struct seq_file *m, void *v)
1070 {
1071         struct cpuinfo_x86 *c = v;
1072         int cpu = 0, i;
1073
1074         /*
1075          * These flag bits must match the definitions in <asm/cpufeature.h>.
1076          * NULL means this bit is undefined or reserved; either way it doesn't
1077          * have meaning as far as Linux is concerned.  Note that it's important
1078          * to realize there is a difference between this table and CPUID -- if
1079          * applications want to get the raw CPUID data, they should access
1080          * /dev/cpu/<cpu_nr>/cpuid instead.
1081          */
1082         static const char *const x86_cap_flags[] = {
1083                 /* Intel-defined */
1084                 "fpu", "vme", "de", "pse", "tsc", "msr", "pae", "mce",
1085                 "cx8", "apic", NULL, "sep", "mtrr", "pge", "mca", "cmov",
1086                 "pat", "pse36", "pn", "clflush", NULL, "dts", "acpi", "mmx",
1087                 "fxsr", "sse", "sse2", "ss", "ht", "tm", "ia64", "pbe",
1088
1089                 /* AMD-defined */
1090                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1091                 NULL, NULL, NULL, "syscall", NULL, NULL, NULL, NULL,
1092                 NULL, NULL, NULL, NULL, "nx", NULL, "mmxext", NULL,
1093                 NULL, "fxsr_opt", "pdpe1gb", "rdtscp", NULL, "lm",
1094                 "3dnowext", "3dnow",
1095
1096                 /* Transmeta-defined */
1097                 "recovery", "longrun", NULL, "lrti", NULL, NULL, NULL, NULL,
1098                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1099                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1100                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1101
1102                 /* Other (Linux-defined) */
1103                 "cxmmx", "k6_mtrr", "cyrix_arr", "centaur_mcr",
1104                 NULL, NULL, NULL, NULL,
1105                 "constant_tsc", "up", NULL, "arch_perfmon",
1106                 "pebs", "bts", NULL, "sync_rdtsc",
1107                 "rep_good", NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1108                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1109
1110                 /* Intel-defined (#2) */
1111                 "pni", NULL, NULL, "monitor", "ds_cpl", "vmx", "smx", "est",
1112                 "tm2", "ssse3", "cid", NULL, NULL, "cx16", "xtpr", NULL,
1113                 NULL, NULL, "dca", "sse4_1", "sse4_2", NULL, NULL, "popcnt",
1114                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1115
1116                 /* VIA/Cyrix/Centaur-defined */
1117                 NULL, NULL, "rng", "rng_en", NULL, NULL, "ace", "ace_en",
1118                 "ace2", "ace2_en", "phe", "phe_en", "pmm", "pmm_en", NULL, NULL,
1119                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1120                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1121
1122                 /* AMD-defined (#2) */
1123                 "lahf_lm", "cmp_legacy", "svm", "extapic",
1124                 "cr8_legacy", "abm", "sse4a", "misalignsse",
1125                 "3dnowprefetch", "osvw", "ibs", "sse5",
1126                 "skinit", "wdt", NULL, NULL,
1127                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1128                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1129
1130                 /* Auxiliary (Linux-defined) */
1131                 "ida", 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                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1135         };
1136         static const char *const x86_power_flags[] = {
1137                 "ts",   /* temperature sensor */
1138                 "fid",  /* frequency id control */
1139                 "vid",  /* voltage id control */
1140                 "ttp",  /* thermal trip */
1141                 "tm",
1142                 "stc",
1143                 "100mhzsteps",
1144                 "hwpstate",
1145                 "",     /* tsc invariant mapped to constant_tsc */
1146                 /* nothing */
1147         };
1148
1149
1150 #ifdef CONFIG_SMP
1151         cpu = c->cpu_index;
1152 #endif
1153
1154         seq_printf(m, "processor\t: %u\n"
1155                    "vendor_id\t: %s\n"
1156                    "cpu family\t: %d\n"
1157                    "model\t\t: %d\n"
1158                    "model name\t: %s\n",
1159                    (unsigned)cpu,
1160                    c->x86_vendor_id[0] ? c->x86_vendor_id : "unknown",
1161                    c->x86,
1162                    (int)c->x86_model,
1163                    c->x86_model_id[0] ? c->x86_model_id : "unknown");
1164
1165         if (c->x86_mask || c->cpuid_level >= 0)
1166                 seq_printf(m, "stepping\t: %d\n", c->x86_mask);
1167         else
1168                 seq_printf(m, "stepping\t: unknown\n");
1169
1170         if (cpu_has(c, X86_FEATURE_TSC)) {
1171                 unsigned int freq = cpufreq_quick_get((unsigned)cpu);
1172
1173                 if (!freq)
1174                         freq = cpu_khz;
1175                 seq_printf(m, "cpu MHz\t\t: %u.%03u\n",
1176                            freq / 1000, (freq % 1000));
1177         }
1178
1179         /* Cache size */
1180         if (c->x86_cache_size >= 0)
1181                 seq_printf(m, "cache size\t: %d KB\n", c->x86_cache_size);
1182
1183 #ifdef CONFIG_SMP
1184         if (smp_num_siblings * c->x86_max_cores > 1) {
1185                 seq_printf(m, "physical id\t: %d\n", c->phys_proc_id);
1186                 seq_printf(m, "siblings\t: %d\n",
1187                                cpus_weight(per_cpu(cpu_core_map, cpu)));
1188                 seq_printf(m, "core id\t\t: %d\n", c->cpu_core_id);
1189                 seq_printf(m, "cpu cores\t: %d\n", c->booted_cores);
1190         }
1191 #endif
1192
1193         seq_printf(m,
1194                    "fpu\t\t: yes\n"
1195                    "fpu_exception\t: yes\n"
1196                    "cpuid level\t: %d\n"
1197                    "wp\t\t: yes\n"
1198                    "flags\t\t:",
1199                    c->cpuid_level);
1200
1201         for (i = 0; i < 32*NCAPINTS; i++)
1202                 if (cpu_has(c, i) && x86_cap_flags[i] != NULL)
1203                         seq_printf(m, " %s", x86_cap_flags[i]);
1204
1205         seq_printf(m, "\nbogomips\t: %lu.%02lu\n",
1206                    c->loops_per_jiffy/(500000/HZ),
1207                    (c->loops_per_jiffy/(5000/HZ)) % 100);
1208
1209         if (c->x86_tlbsize > 0)
1210                 seq_printf(m, "TLB size\t: %d 4K pages\n", c->x86_tlbsize);
1211         seq_printf(m, "clflush size\t: %d\n", c->x86_clflush_size);
1212         seq_printf(m, "cache_alignment\t: %d\n", c->x86_cache_alignment);
1213
1214         seq_printf(m, "address sizes\t: %u bits physical, %u bits virtual\n",
1215                    c->x86_phys_bits, c->x86_virt_bits);
1216
1217         seq_printf(m, "power management:");
1218         for (i = 0; i < 32; i++) {
1219                 if (c->x86_power & (1 << i)) {
1220                         if (i < ARRAY_SIZE(x86_power_flags) &&
1221                             x86_power_flags[i])
1222                                 seq_printf(m, "%s%s",
1223                                            x86_power_flags[i][0]?" ":"",
1224                                            x86_power_flags[i]);
1225                         else
1226                                 seq_printf(m, " [%d]", i);
1227                 }
1228         }
1229
1230         seq_printf(m, "\n\n");
1231
1232         return 0;
1233 }
1234
1235 static void *c_start(struct seq_file *m, loff_t *pos)
1236 {
1237         if (*pos == 0)  /* just in case, cpu 0 is not the first */
1238                 *pos = first_cpu(cpu_online_map);
1239         if ((*pos) < NR_CPUS && cpu_online(*pos))
1240                 return &cpu_data(*pos);
1241         return NULL;
1242 }
1243
1244 static void *c_next(struct seq_file *m, void *v, loff_t *pos)
1245 {
1246         *pos = next_cpu(*pos, cpu_online_map);
1247         return c_start(m, pos);
1248 }
1249
1250 static void c_stop(struct seq_file *m, void *v)
1251 {
1252 }
1253
1254 struct seq_operations cpuinfo_op = {
1255         .start = c_start,
1256         .next = c_next,
1257         .stop = c_stop,
1258         .show = show_cpuinfo,
1259 };