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