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