arch/x86_64/kernel/setup.c

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