arch/x86_64/kernel/setup-xen.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 #ifdef CONFIG_XEN
  68 #include <linux/percpu.h>
  69 #include <linux/pfn.h>
  70 #include <xen/interface/physdev.h>
  71 #include "setup_arch_pre.h"
  72 #include <asm/hypervisor.h>
  73 #include <xen/interface/nmi.h>
  74 #include <xen/features.h>
  75 #include <xen/xencons.h>
  76 #include <asm/mach-xen/setup_arch_post.h>
  77 #include <xen/interface/memory.h>
  78
  79 extern unsigned long start_pfn;
  80 extern struct edid_info edid_info;
  81 EXPORT_SYMBOL_GPL(edid_info);
  82
  83 shared_info_t *HYPERVISOR_shared_info = (shared_info_t *)empty_zero_page;
  84 EXPORT_SYMBOL(HYPERVISOR_shared_info);
  85
  86 extern char hypercall_page[PAGE_SIZE];
  87 EXPORT_SYMBOL(hypercall_page);
  88
  89 /* Allows setting of maximum possible memory size  */
  90 unsigned long xen_override_max_pfn;
  91
  92 static int xen_panic_event(struct notifier_block *, unsigned long, void *);
  93 static struct notifier_block xen_panic_block = {
  94         xen_panic_event, NULL, 0 /* try to go last */
  95 };
  96
  97 unsigned long *phys_to_machine_mapping;
  98 unsigned long *pfn_to_mfn_frame_list_list, *pfn_to_mfn_frame_list[512];
  99
 100 EXPORT_SYMBOL(phys_to_machine_mapping);
 101
 102 DEFINE_PER_CPU(multicall_entry_t, multicall_list[8]);
 103 DEFINE_PER_CPU(int, nr_multicall_ents);
 104
 105 /* Raw start-of-day parameters from the hypervisor. */
 106 start_info_t *xen_start_info;
 107 EXPORT_SYMBOL(xen_start_info);
 108 #endif
 109
 110 /*
 111  * Machine setup..
 112  */
 113
 114 struct cpuinfo_x86 boot_cpu_data __read_mostly;
 115 EXPORT_SYMBOL(boot_cpu_data);
 116
 117 unsigned long mmu_cr4_features;
 118
 119 int acpi_disabled;
 120 EXPORT_SYMBOL(acpi_disabled);
 121 #ifdef  CONFIG_ACPI
 122 extern int __initdata acpi_ht;
 123 extern acpi_interrupt_flags     acpi_sci_flags;
 124 int __initdata acpi_force = 0;
 125 #endif
 126
 127 int acpi_numa __initdata;
 128
 129 /* Boot loader ID as an integer, for the benefit of proc_dointvec */
 130 int bootloader_type;
 131
 132 unsigned long saved_video_mode;
 133
 134 /*
 135  * Early DMI memory
 136  */
 137 int dmi_alloc_index;
 138 char dmi_alloc_data[DMI_MAX_DATA];
 139
 140 /*
 141  * Setup options
 142  */
 143 struct screen_info screen_info;
 144 EXPORT_SYMBOL(screen_info);
 145 struct sys_desc_table_struct {
 146         unsigned short length;
 147         unsigned char table[0];
 148 };
 149
 150 struct edid_info edid_info;
 151 struct e820map e820;
 152 #ifdef CONFIG_XEN
 153 struct e820map machine_e820;
 154 #endif
 155
 156 extern int root_mountflags;
 157
 158 char command_line[COMMAND_LINE_SIZE];
 159
 160 struct resource standard_io_resources[] = {
 161         { .name = "dma1", .start = 0x00, .end = 0x1f,
 162                 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
 163         { .name = "pic1", .start = 0x20, .end = 0x21,
 164                 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
 165         { .name = "timer0", .start = 0x40, .end = 0x43,
 166                 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
 167         { .name = "timer1", .start = 0x50, .end = 0x53,
 168                 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
 169         { .name = "keyboard", .start = 0x60, .end = 0x6f,
 170                 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
 171         { .name = "dma page reg", .start = 0x80, .end = 0x8f,
 172                 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
 173         { .name = "pic2", .start = 0xa0, .end = 0xa1,
 174                 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
 175         { .name = "dma2", .start = 0xc0, .end = 0xdf,
 176                 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
 177         { .name = "fpu", .start = 0xf0, .end = 0xff,
 178                 .flags = IORESOURCE_BUSY | IORESOURCE_IO }
 179 };
 180
 181 #define STANDARD_IO_RESOURCES \
 182         (sizeof standard_io_resources / sizeof standard_io_resources[0])
 183
 184 #define IORESOURCE_RAM (IORESOURCE_BUSY | IORESOURCE_MEM)
 185
 186 struct resource data_resource = {
 187         .name = "Kernel data",
 188         .start = 0,
 189         .end = 0,
 190         .flags = IORESOURCE_RAM,
 191 };
 192 struct resource code_resource = {
 193         .name = "Kernel code",
 194         .start = 0,
 195         .end = 0,
 196         .flags = IORESOURCE_RAM,
 197 };
 198
 199 #define IORESOURCE_ROM (IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM)
 200
 201 static struct resource system_rom_resource = {
 202         .name = "System ROM",
 203         .start = 0xf0000,
 204         .end = 0xfffff,
 205         .flags = IORESOURCE_ROM,
 206 };
 207
 208 static struct resource extension_rom_resource = {
 209         .name = "Extension ROM",
 210         .start = 0xe0000,
 211         .end = 0xeffff,
 212         .flags = IORESOURCE_ROM,
 213 };
 214
 215 static struct resource adapter_rom_resources[] = {
 216         { .name = "Adapter ROM", .start = 0xc8000, .end = 0,
 217                 .flags = IORESOURCE_ROM },
 218         { .name = "Adapter ROM", .start = 0, .end = 0,
 219                 .flags = IORESOURCE_ROM },
 220         { .name = "Adapter ROM", .start = 0, .end = 0,
 221                 .flags = IORESOURCE_ROM },
 222         { .name = "Adapter ROM", .start = 0, .end = 0,
 223                 .flags = IORESOURCE_ROM },
 224         { .name = "Adapter ROM", .start = 0, .end = 0,
 225                 .flags = IORESOURCE_ROM },
 226         { .name = "Adapter ROM", .start = 0, .end = 0,
 227                 .flags = IORESOURCE_ROM }
 228 };
 229
 230 #define ADAPTER_ROM_RESOURCES \
 231         (sizeof adapter_rom_resources / sizeof adapter_rom_resources[0])
 232
 233 static struct resource video_rom_resource = {
 234         .name = "Video ROM",
 235         .start = 0xc0000,
 236         .end = 0xc7fff,
 237         .flags = IORESOURCE_ROM,
 238 };
 239
 240 static struct resource video_ram_resource = {
 241         .name = "Video RAM area",
 242         .start = 0xa0000,
 243         .end = 0xbffff,
 244         .flags = IORESOURCE_RAM,
 245 };
 246
 247 #define romsignature(x) (*(unsigned short *)(x) == 0xaa55)
 248
 249 static int __init romchecksum(unsigned char *rom, unsigned long length)
 250 {
 251         unsigned char *p, sum = 0;
 252
 253         for (p = rom; p < rom + length; p++)
 254                 sum += *p;
 255         return sum == 0;
 256 }
 257
 258 static void __init probe_roms(void)
 259 {
 260         unsigned long start, length, upper;
 261         unsigned char *rom;
 262         int           i;
 263
 264 #ifdef CONFIG_XEN
 265         /* Nothing to do if not running in dom0. */
 266         if (!is_initial_xendomain())
 267                 return;
 268 #endif
 269
 270         /* video rom */
 271         upper = adapter_rom_resources[0].start;
 272         for (start = video_rom_resource.start; start < upper; start += 2048) {
 273                 rom = isa_bus_to_virt(start);
 274                 if (!romsignature(rom))
 275                         continue;
 276
 277                 video_rom_resource.start = start;
 278
 279                 /* 0 < length <= 0x7f * 512, historically */
 280                 length = rom[2] * 512;
 281
 282                 /* if checksum okay, trust length byte */
 283                 if (length && romchecksum(rom, length))
 284                         video_rom_resource.end = start + length - 1;
 285
 286                 request_resource(&iomem_resource, &video_rom_resource);
 287                 break;
 288                         }
 289
 290         start = (video_rom_resource.end + 1 + 2047) & ~2047UL;
 291         if (start < upper)
 292                 start = upper;
 293
 294         /* system rom */
 295         request_resource(&iomem_resource, &system_rom_resource);
 296         upper = system_rom_resource.start;
 297
 298         /* check for extension rom (ignore length byte!) */
 299         rom = isa_bus_to_virt(extension_rom_resource.start);
 300         if (romsignature(rom)) {
 301                 length = extension_rom_resource.end - extension_rom_resource.start + 1;
 302                 if (romchecksum(rom, length)) {
 303                         request_resource(&iomem_resource, &extension_rom_resource);
 304                         upper = extension_rom_resource.start;
 305                 }
 306         }
 307
 308         /* check for adapter roms on 2k boundaries */
 309         for (i = 0; i < ADAPTER_ROM_RESOURCES && start < upper; start += 2048) {
 310                 rom = isa_bus_to_virt(start);
 311                 if (!romsignature(rom))
 312                         continue;
 313
 314                 /* 0 < length <= 0x7f * 512, historically */
 315                 length = rom[2] * 512;
 316
 317                 /* but accept any length that fits if checksum okay */
 318                 if (!length || start + length > upper || !romchecksum(rom, length))
 319                         continue;
 320
 321                 adapter_rom_resources[i].start = start;
 322                 adapter_rom_resources[i].end = start + length - 1;
 323                 request_resource(&iomem_resource, &adapter_rom_resources[i]);
 324
 325                 start = adapter_rom_resources[i++].end & ~2047UL;
 326         }
 327 }
 328
 329 /* Check for full argument with no trailing characters */
 330 static int fullarg(char *p, char *arg)
 331 {
 332         int l = strlen(arg);
 333         return !memcmp(p, arg, l) && (p[l] == 0 || isspace(p[l]));
 334 }
 335
 336 static __init void parse_cmdline_early (char ** cmdline_p)
 337 {
 338         char c = ' ', *to = command_line, *from = COMMAND_LINE;
 339         int len = 0;
 340         int userdef = 0;
 341
 342         for (;;) {
 343                 if (c != ' ')
 344                         goto next_char;
 345
 346 #ifdef  CONFIG_SMP
 347                 /*
 348                  * If the BIOS enumerates physical processors before logical,
 349                  * maxcpus=N at enumeration-time can be used to disable HT.
 350                  */
 351                 else if (!memcmp(from, "maxcpus=", 8)) {
 352                         extern unsigned int maxcpus;
 353
 354                         maxcpus = simple_strtoul(from + 8, NULL, 0);
 355                 }
 356 #endif
 357 #ifdef CONFIG_ACPI
 358                 /* "acpi=off" disables both ACPI table parsing and interpreter init */
 359                 if (fullarg(from,"acpi=off"))
 360                         disable_acpi();
 361
 362                 if (fullarg(from, "acpi=force")) {
 363                         /* add later when we do DMI horrors: */
 364                         acpi_force = 1;
 365                         acpi_disabled = 0;
 366                 }
 367
 368                 /* acpi=ht just means: do ACPI MADT parsing
 369                    at bootup, but don't enable the full ACPI interpreter */
 370                 if (fullarg(from, "acpi=ht")) {
 371                         if (!acpi_force)
 372                                 disable_acpi();
 373                         acpi_ht = 1;
 374                 }
 375                 else if (fullarg(from, "pci=noacpi"))
 376                         acpi_disable_pci();
 377                 else if (fullarg(from, "acpi=noirq"))
 378                         acpi_noirq_set();
 379
 380                 else if (fullarg(from, "acpi_sci=edge"))
 381                         acpi_sci_flags.trigger =  1;
 382                 else if (fullarg(from, "acpi_sci=level"))
 383                         acpi_sci_flags.trigger = 3;
 384                 else if (fullarg(from, "acpi_sci=high"))
 385                         acpi_sci_flags.polarity = 1;
 386                 else if (fullarg(from, "acpi_sci=low"))
 387                         acpi_sci_flags.polarity = 3;
 388
 389                 /* acpi=strict disables out-of-spec workarounds */
 390                 else if (fullarg(from, "acpi=strict")) {
 391                         acpi_strict = 1;
 392                 }
 393 #ifdef CONFIG_X86_IO_APIC
 394                 else if (fullarg(from, "acpi_skip_timer_override"))
 395                         acpi_skip_timer_override = 1;
 396 #endif
 397 #endif
 398
 399 #ifndef CONFIG_XEN
 400                 if (fullarg(from, "disable_timer_pin_1"))
 401                         disable_timer_pin_1 = 1;
 402                 if (fullarg(from, "enable_timer_pin_1"))
 403                         disable_timer_pin_1 = -1;
 404
 405                 if (fullarg(from, "nolapic") || fullarg(from, "disableapic")) {
 406                         clear_bit(X86_FEATURE_APIC, boot_cpu_data.x86_capability);
 407                         disable_apic = 1;
 408                 }
 409
 410                 if (fullarg(from, "noapic"))
 411                         skip_ioapic_setup = 1;
 412
 413                 if (fullarg(from,"apic")) {
 414                         skip_ioapic_setup = 0;
 415                         ioapic_force = 1;
 416                 }
 417 #endif
 418
 419                 if (!memcmp(from, "mem=", 4))
 420                         parse_memopt(from+4, &from);
 421
 422                 if (!memcmp(from, "memmap=", 7)) {
 423                         /* exactmap option is for used defined memory */
 424                         if (!memcmp(from+7, "exactmap", 8)) {
 425 #ifdef CONFIG_CRASH_DUMP
 426                                 /* If we are doing a crash dump, we
 427                                  * still need to know the real mem
 428                                  * size before original memory map is
 429                                  * reset.
 430                                  */
 431                                 saved_max_pfn = e820_end_of_ram();
 432 #endif
 433                                 from += 8+7;
 434                                 end_pfn_map = 0;
 435                                 e820.nr_map = 0;
 436                                 userdef = 1;
 437                         }
 438                         else {
 439                                 parse_memmapopt(from+7, &from);
 440                                 userdef = 1;
 441                         }
 442                 }
 443
 444 #ifdef CONFIG_NUMA
 445                 if (!memcmp(from, "numa=", 5))
 446                         numa_setup(from+5);
 447 #endif
 448
 449                 if (!memcmp(from,"iommu=",6)) {
 450                         iommu_setup(from+6);
 451                 }
 452
 453                 if (fullarg(from,"oops=panic"))
 454                         panic_on_oops = 1;
 455
 456                 if (!memcmp(from, "noexec=", 7))
 457                         nonx_setup(from + 7);
 458
 459 #ifdef CONFIG_KEXEC
 460                 /* crashkernel=size@addr specifies the location to reserve for
 461                  * a crash kernel.  By reserving this memory we guarantee
 462                  * that linux never set's it up as a DMA target.
 463                  * Useful for holding code to do something appropriate
 464                  * after a kernel panic.
 465                  */
 466                 else if (!memcmp(from, "crashkernel=", 12)) {
 467                         unsigned long size, base;
 468                         size = memparse(from+12, &from);
 469                         if (*from == '@') {
 470                                 base = memparse(from+1, &from);
 471                                 /* FIXME: Do I want a sanity check
 472                                  * to validate the memory range?
 473                                  */
 474                                 crashk_res.start = base;
 475                                 crashk_res.end   = base + size - 1;
 476                         }
 477                 }
 478 #endif
 479
 480 #ifdef CONFIG_PROC_VMCORE
 481                 /* elfcorehdr= specifies the location of elf core header
 482                  * stored by the crashed kernel. This option will be passed
 483                  * by kexec loader to the capture kernel.
 484                  */
 485                 else if(!memcmp(from, "elfcorehdr=", 11))
 486                         elfcorehdr_addr = memparse(from+11, &from);
 487 #endif
 488
 489 #if defined(CONFIG_HOTPLUG_CPU) && !defined(CONFIG_XEN)
 490                 else if (!memcmp(from, "additional_cpus=", 16))
 491                         setup_additional_cpus(from+16);
 492 #endif
 493
 494         next_char:
 495                 c = *(from++);
 496                 if (!c)
 497                         break;
 498                 if (COMMAND_LINE_SIZE <= ++len)
 499                         break;
 500                 *(to++) = c;
 501         }
 502         if (userdef) {
 503                 printk(KERN_INFO "user-defined physical RAM map:\n");
 504                 e820_print_map("user");
 505         }
 506         *to = '\0';
 507         *cmdline_p = command_line;
 508 }
 509
 510 #ifndef CONFIG_NUMA
 511 static void __init
 512 contig_initmem_init(unsigned long start_pfn, unsigned long end_pfn)
 513 {
 514         unsigned long bootmap_size, bootmap;
 515
 516         bootmap_size = bootmem_bootmap_pages(end_pfn)<<PAGE_SHIFT;
 517         bootmap = find_e820_area(0, end_pfn<<PAGE_SHIFT, bootmap_size);
 518         if (bootmap == -1L)
 519                 panic("Cannot find bootmem map of size %ld\n",bootmap_size);
 520         bootmap_size = init_bootmem(bootmap >> PAGE_SHIFT, end_pfn);
 521 #ifdef CONFIG_XEN
 522         e820_bootmem_free(NODE_DATA(0), 0, xen_start_info->nr_pages<<PAGE_SHIFT);
 523 #else
 524         e820_bootmem_free(NODE_DATA(0), 0, end_pfn << PAGE_SHIFT);
 525 #endif
 526         reserve_bootmem(bootmap, bootmap_size);
 527 }
 528 #endif
 529
 530 #if defined(CONFIG_EDD) || defined(CONFIG_EDD_MODULE)
 531 struct edd edd;
 532 #ifdef CONFIG_EDD_MODULE
 533 EXPORT_SYMBOL(edd);
 534 #endif
 535 /**
 536  * copy_edd() - Copy the BIOS EDD information
 537  *              from boot_params into a safe place.
 538  *
 539  */
 540 static inline void copy_edd(void)
 541 {
 542      memcpy(edd.mbr_signature, EDD_MBR_SIGNATURE, sizeof(edd.mbr_signature));
 543      memcpy(edd.edd_info, EDD_BUF, sizeof(edd.edd_info));
 544      edd.mbr_signature_nr = EDD_MBR_SIG_NR;
 545      edd.edd_info_nr = EDD_NR;
 546 }
 547 #else
 548 static inline void copy_edd(void)
 549 {
 550 }
 551 #endif
 552
 553 #ifndef CONFIG_XEN
 554 #define EBDA_ADDR_POINTER 0x40E
 555
 556 unsigned __initdata ebda_addr;
 557 unsigned __initdata ebda_size;
 558
 559 static void discover_ebda(void)
 560 {
 561         /*
 562          * there is a real-mode segmented pointer pointing to the
 563          * 4K EBDA area at 0x40E
 564          */
 565         ebda_addr = *(unsigned short *)EBDA_ADDR_POINTER;
 566         ebda_addr <<= 4;
 567
 568         ebda_size = *(unsigned short *)(unsigned long)ebda_addr;
 569
 570         /* Round EBDA up to pages */
 571         if (ebda_size == 0)
 572                 ebda_size = 1;
 573         ebda_size <<= 10;
 574         ebda_size = round_up(ebda_size + (ebda_addr & ~PAGE_MASK), PAGE_SIZE);
 575         if (ebda_size > 64*1024)
 576                 ebda_size = 64*1024;
 577 }
 578 #endif
 579
 580 void __init setup_arch(char **cmdline_p)
 581 {
 582         struct xen_memory_map memmap;
 583
 584 #ifdef CONFIG_XEN
 585         /* Register a call for panic conditions. */
 586         atomic_notifier_chain_register(&panic_notifier_list, &xen_panic_block);
 587
 588         ROOT_DEV = MKDEV(RAMDISK_MAJOR,0);
 589         screen_info = SCREEN_INFO;
 590
 591         if (is_initial_xendomain()) {
 592                 /* This is drawn from a dump from vgacon:startup in
 593                  * standard Linux. */
 594                 screen_info.orig_video_mode = 3;
 595                 screen_info.orig_video_isVGA = 1;
 596                 screen_info.orig_video_lines = 25;
 597                 screen_info.orig_video_cols = 80;
 598                 screen_info.orig_video_ega_bx = 3;
 599                 screen_info.orig_video_points = 16;
 600                 screen_info.orig_y = screen_info.orig_video_lines - 1;
 601                 if (xen_start_info->console.dom0.info_size >=
 602                     sizeof(struct dom0_vga_console_info)) {
 603                         const struct dom0_vga_console_info *info =
 604                                 (struct dom0_vga_console_info *)(
 605                                         (char *)xen_start_info +
 606                                         xen_start_info->console.dom0.info_off);
 607                         dom0_init_screen_info(info);
 608                 }
 609                 xen_start_info->console.domU.mfn = 0;
 610                 xen_start_info->console.domU.evtchn = 0;
 611         } else
 612                 screen_info.orig_video_isVGA = 0;
 613
 614         edid_info = EDID_INFO;
 615         saved_video_mode = SAVED_VIDEO_MODE;
 616         bootloader_type = LOADER_TYPE;
 617
 618 #ifdef CONFIG_BLK_DEV_RAM
 619         rd_image_start = RAMDISK_FLAGS & RAMDISK_IMAGE_START_MASK;
 620         rd_prompt = ((RAMDISK_FLAGS & RAMDISK_PROMPT_FLAG) != 0);
 621         rd_doload = ((RAMDISK_FLAGS & RAMDISK_LOAD_FLAG) != 0);
 622
 623
 624 #endif
 625
 626         setup_xen_features();
 627
 628         HYPERVISOR_vm_assist(VMASST_CMD_enable,
 629                              VMASST_TYPE_writable_pagetables);
 630
 631         ARCH_SETUP
 632 #else
 633         ROOT_DEV = old_decode_dev(ORIG_ROOT_DEV);
 634         screen_info = SCREEN_INFO;
 635         edid_info = EDID_INFO;
 636         saved_video_mode = SAVED_VIDEO_MODE;
 637         bootloader_type = LOADER_TYPE;
 638
 639 #ifdef CONFIG_BLK_DEV_RAM
 640         rd_image_start = RAMDISK_FLAGS & RAMDISK_IMAGE_START_MASK;
 641         rd_prompt = ((RAMDISK_FLAGS & RAMDISK_PROMPT_FLAG) != 0);
 642         rd_doload = ((RAMDISK_FLAGS & RAMDISK_LOAD_FLAG) != 0);
 643 #endif
 644 #endif  /* !CONFIG_XEN */
 645         setup_memory_region();
 646         copy_edd();
 647
 648         if (!MOUNT_ROOT_RDONLY)
 649                 root_mountflags &= ~MS_RDONLY;
 650         init_mm.start_code = (unsigned long) &_text;
 651         init_mm.end_code = (unsigned long) &_etext;
 652         init_mm.end_data = (unsigned long) &_edata;
 653         init_mm.brk = (unsigned long) &_end;
 654
 655         code_resource.start = virt_to_phys(&_text);
 656         code_resource.end = virt_to_phys(&_etext)-1;
 657         data_resource.start = virt_to_phys(&_etext);
 658         data_resource.end = virt_to_phys(&_edata)-1;
 659
 660         parse_cmdline_early(cmdline_p);
 661
 662         early_identify_cpu(&boot_cpu_data);
 663
 664         /*
 665          * partially used pages are not usable - thus
 666          * we are rounding upwards:
 667          */
 668         end_pfn = e820_end_of_ram();
 669         num_physpages = end_pfn;                /* for pfn_valid */
 670
 671         check_efer();
 672
 673 #ifndef CONFIG_XEN
 674         discover_ebda();
 675 #endif
 676
 677         init_memory_mapping(0, (end_pfn_map << PAGE_SHIFT));
 678
 679 #ifdef CONFIG_ACPI_NUMA
 680         /*
 681          * Parse SRAT to discover nodes.
 682          */
 683         acpi_numa_init();
 684 #endif
 685
 686 #ifdef CONFIG_NUMA
 687         numa_initmem_init(0, end_pfn);
 688 #else
 689         contig_initmem_init(0, end_pfn);
 690 #endif
 691
 692         /* Reserve direct mapping */
 693         reserve_bootmem_generic(table_start << PAGE_SHIFT,
 694                                 (table_end - table_start) << PAGE_SHIFT);
 695
 696         /* reserve kernel */
 697         reserve_bootmem_generic(__pa_symbol(&_text),
 698                                 __pa_symbol(&_end) - __pa_symbol(&_text));
 699
 700 #ifdef CONFIG_XEN
 701         /* reserve physmap, start info and initial page tables */
 702         reserve_bootmem(__pa_symbol(&_end), (table_start<<PAGE_SHIFT)-__pa_symbol(&_end));
 703 #else
 704         /*
 705          * reserve physical page 0 - it's a special BIOS page on many boxes,
 706          * enabling clean reboots, SMP operation, laptop functions.
 707          */
 708         reserve_bootmem_generic(0, PAGE_SIZE);
 709
 710         /* reserve ebda region */
 711         if (ebda_addr)
 712                 reserve_bootmem_generic(ebda_addr, ebda_size);
 713 #endif
 714
 715 #ifdef CONFIG_SMP
 716         /*
 717          * But first pinch a few for the stack/trampoline stuff
 718          * FIXME: Don't need the extra page at 4K, but need to fix
 719          * trampoline before removing it. (see the GDT stuff)
 720          */
 721         reserve_bootmem_generic(PAGE_SIZE, PAGE_SIZE);
 722
 723         /* Reserve SMP trampoline */
 724         reserve_bootmem_generic(SMP_TRAMPOLINE_BASE, PAGE_SIZE);
 725 #endif
 726
 727 #ifdef CONFIG_ACPI_SLEEP
 728        /*
 729         * Reserve low memory region for sleep support.
 730         */
 731        acpi_reserve_bootmem();
 732 #endif
 733 #ifdef CONFIG_XEN
 734 #ifdef CONFIG_BLK_DEV_INITRD
 735         if (xen_start_info->mod_start) {
 736                 if (INITRD_START + INITRD_SIZE <= (end_pfn << PAGE_SHIFT)) {
 737                         /*reserve_bootmem_generic(INITRD_START, INITRD_SIZE);*/
 738                         initrd_start = INITRD_START + PAGE_OFFSET;
 739                         initrd_end = initrd_start+INITRD_SIZE;
 740                         initrd_below_start_ok = 1;
 741                 } else {
 742                         printk(KERN_ERR "initrd extends beyond end of memory "
 743                                 "(0x%08lx > 0x%08lx)\ndisabling initrd\n",
 744                                 (unsigned long)(INITRD_START + INITRD_SIZE),
 745                                 (unsigned long)(end_pfn << PAGE_SHIFT));
 746                         initrd_start = 0;
 747                 }
 748         }
 749 #endif
 750 #else   /* CONFIG_XEN */
 751 #ifdef CONFIG_BLK_DEV_INITRD
 752         if (LOADER_TYPE && INITRD_START) {
 753                 if (INITRD_START + INITRD_SIZE <= (end_pfn << PAGE_SHIFT)) {
 754                         reserve_bootmem_generic(INITRD_START, INITRD_SIZE);
 755                         initrd_start =
 756                                 INITRD_START ? INITRD_START + PAGE_OFFSET : 0;
 757                         initrd_end = initrd_start+INITRD_SIZE;
 758                 }
 759                 else {
 760                         printk(KERN_ERR "initrd extends beyond end of memory "
 761                             "(0x%08lx > 0x%08lx)\ndisabling initrd\n",
 762                             (unsigned long)(INITRD_START + INITRD_SIZE),
 763                             (unsigned long)(end_pfn << PAGE_SHIFT));
 764                         initrd_start = 0;
 765                 }
 766         }
 767 #endif
 768 #endif  /* !CONFIG_XEN */
 769 #ifdef CONFIG_KEXEC
 770         if (crashk_res.start != crashk_res.end) {
 771                 reserve_bootmem_generic(crashk_res.start,
 772                         crashk_res.end - crashk_res.start + 1);
 773         }
 774 #endif
 775
 776         paging_init();
 777 #ifdef CONFIG_X86_LOCAL_APIC
 778         /*
 779          * Find and reserve possible boot-time SMP configuration:
 780          */
 781         find_smp_config();
 782 #endif
 783 #ifdef CONFIG_XEN
 784         {
 785                 int i, j, k, fpp;
 786
 787                 if (!xen_feature(XENFEAT_auto_translated_physmap)) {
 788                         /* Make sure we have a large enough P->M table. */
 789                         phys_to_machine_mapping = alloc_bootmem_pages(
 790                                 end_pfn * sizeof(unsigned long));
 791                         memset(phys_to_machine_mapping, ~0,
 792                                end_pfn * sizeof(unsigned long));
 793                         memcpy(phys_to_machine_mapping,
 794                                (unsigned long *)xen_start_info->mfn_list,
 795                                xen_start_info->nr_pages * sizeof(unsigned long));
 796                         free_bootmem(
 797                                 __pa(xen_start_info->mfn_list),
 798                                 PFN_PHYS(PFN_UP(xen_start_info->nr_pages *
 799                                                 sizeof(unsigned long))));
 800
 801                         /*
 802                          * Initialise the list of the frames that specify the
 803                          * list of frames that make up the p2m table. Used by
 804                          * save/restore.
 805                          */
 806                         pfn_to_mfn_frame_list_list = alloc_bootmem_pages(PAGE_SIZE);
 807                         HYPERVISOR_shared_info->arch.pfn_to_mfn_frame_list_list =
 808                                 virt_to_mfn(pfn_to_mfn_frame_list_list);
 809
 810                         fpp = PAGE_SIZE/sizeof(unsigned long);
 811                         for (i=0, j=0, k=-1; i< end_pfn; i+=fpp, j++) {
 812                                 if ((j % fpp) == 0) {
 813                                         k++;
 814                                         BUG_ON(k>=fpp);
 815                                         pfn_to_mfn_frame_list[k] =
 816                                                 alloc_bootmem_pages(PAGE_SIZE);
 817                                         pfn_to_mfn_frame_list_list[k] =
 818                                                 virt_to_mfn(pfn_to_mfn_frame_list[k]);
 819                                         j=0;
 820                                 }
 821                                 pfn_to_mfn_frame_list[k][j] =
 822                                         virt_to_mfn(&phys_to_machine_mapping[i]);
 823                         }
 824                         HYPERVISOR_shared_info->arch.max_pfn = end_pfn;
 825                 }
 826
 827         }
 828
 829         if (is_initial_xendomain())
 830                 dmi_scan_machine();
 831
 832         if (!is_initial_xendomain()) {
 833                 acpi_disabled = 1;
 834 #ifdef  CONFIG_ACPI
 835                 acpi_ht = 0;
 836 #endif
 837         }
 838 #endif
 839
 840 #ifndef CONFIG_XEN
 841         check_ioapic();
 842 #endif
 843
 844         zap_low_mappings(0);
 845
 846         /*
 847          * set this early, so we dont allocate cpu0
 848          * if MADT list doesnt list BSP first
 849          * mpparse.c/MP_processor_info() allocates logical cpu numbers.
 850          */
 851         cpu_set(0, cpu_present_map);
 852 #ifdef CONFIG_ACPI
 853         /*
 854          * Initialize the ACPI boot-time table parser (gets the RSDP and SDT).
 855          * Call this early for SRAT node setup.
 856          */
 857         acpi_boot_table_init();
 858
 859         /*
 860          * Read APIC and some other early information from ACPI tables.
 861          */
 862         acpi_boot_init();
 863 #endif
 864
 865         init_cpu_to_node();
 866
 867 #ifdef CONFIG_X86_LOCAL_APIC
 868         /*
 869          * get boot-time SMP configuration:
 870          */
 871         if (smp_found_config)
 872                 get_smp_config();
 873 #ifndef CONFIG_XEN
 874         init_apic_mappings();
 875 #endif
 876 #endif
 877 #if defined(CONFIG_XEN) && defined(CONFIG_SMP) && !defined(CONFIG_HOTPLUG_CPU)
 878         prefill_possible_map();
 879 #endif
 880
 881         /*
 882          * Request address space for all standard RAM and ROM resources
 883          * and also for regions reported as reserved by the e820.
 884          */
 885         probe_roms();
 886 #ifdef CONFIG_XEN
 887         if (is_initial_xendomain()) {
 888                 memmap.nr_entries = E820MAX;
 889                 set_xen_guest_handle(memmap.buffer, machine_e820.map);
 890
 891                 if (HYPERVISOR_memory_op(XENMEM_machine_memory_map, &memmap))
 892                         BUG();
 893                 machine_e820.nr_map = memmap.nr_entries;
 894
 895                 e820_reserve_resources(machine_e820.map, machine_e820.nr_map);
 896         }
 897 #else
 898         e820_reserve_resources(e820.map, e820.nr_map);
 899 #endif
 900
 901         request_resource(&iomem_resource, &video_ram_resource);
 902
 903         {
 904         unsigned i;
 905         /* request I/O space for devices used on all i[345]86 PCs */
 906         for (i = 0; i < STANDARD_IO_RESOURCES; i++)
 907                 request_resource(&ioport_resource, &standard_io_resources[i]);
 908         }
 909
 910 #ifdef CONFIG_XEN
 911         if (is_initial_xendomain())
 912                 e820_setup_gap(machine_e820.map, machine_e820.nr_map);
 913 #else
 914         e820_setup_gap(e820.map, e820.nr_map);
 915 #endif
 916
 917 #ifdef CONFIG_XEN
 918         {
 919                 struct physdev_set_iopl set_iopl;
 920
 921                 set_iopl.iopl = 1;
 922                 HYPERVISOR_physdev_op(PHYSDEVOP_set_iopl, &set_iopl);
 923
 924                 if (is_initial_xendomain()) {
 925 #ifdef CONFIG_VT
 926 #if defined(CONFIG_VGA_CONSOLE)
 927                         conswitchp = &vga_con;
 928 #elif defined(CONFIG_DUMMY_CONSOLE)
 929                         conswitchp = &dummy_con;
 930 #endif
 931 #endif
 932                 } else {
 933 #if defined(CONFIG_VT) && defined(CONFIG_DUMMY_CONSOLE)
 934                     conswitchp = &dummy_con;
 935 #endif
 936                 }
 937         }
 938 #else   /* CONFIG_XEN */
 939
 940 #ifdef CONFIG_VT
 941 #if defined(CONFIG_VGA_CONSOLE)
 942         conswitchp = &vga_con;
 943 #elif defined(CONFIG_DUMMY_CONSOLE)
 944         conswitchp = &dummy_con;
 945 #endif
 946 #endif
 947
 948 #endif /* !CONFIG_XEN */
 949 }
 950
 951 #ifdef CONFIG_XEN
 952 static int
 953 xen_panic_event(struct notifier_block *this, unsigned long event, void *ptr)
 954 {
 955         HYPERVISOR_shutdown(SHUTDOWN_crash);
 956         /* we're never actually going to get here... */
 957         return NOTIFY_DONE;
 958 }
 959 #endif /* !CONFIG_XEN */
 960
 961
 962 static int __cpuinit get_model_name(struct cpuinfo_x86 *c)
 963 {
 964         unsigned int *v;
 965
 966         if (c->extended_cpuid_level < 0x80000004)
 967                 return 0;
 968
 969         v = (unsigned int *) c->x86_model_id;
 970         cpuid(0x80000002, &v[0], &v[1], &v[2], &v[3]);
 971         cpuid(0x80000003, &v[4], &v[5], &v[6], &v[7]);
 972         cpuid(0x80000004, &v[8], &v[9], &v[10], &v[11]);
 973         c->x86_model_id[48] = 0;
 974         return 1;
 975 }
 976
 977
 978 static void __cpuinit display_cacheinfo(struct cpuinfo_x86 *c)
 979 {
 980         unsigned int n, dummy, eax, ebx, ecx, edx;
 981
 982         n = c->extended_cpuid_level;
 983
 984         if (n >= 0x80000005) {
 985                 cpuid(0x80000005, &dummy, &ebx, &ecx, &edx);
 986                 printk(KERN_INFO "CPU: L1 I Cache: %dK (%d bytes/line), D cache %dK (%d bytes/line)\n",
 987                         edx>>24, edx&0xFF, ecx>>24, ecx&0xFF);
 988                 c->x86_cache_size=(ecx>>24)+(edx>>24);
 989                 /* On K8 L1 TLB is inclusive, so don't count it */
 990                 c->x86_tlbsize = 0;
 991         }
 992
 993         if (n >= 0x80000006) {
 994                 cpuid(0x80000006, &dummy, &ebx, &ecx, &edx);
 995                 ecx = cpuid_ecx(0x80000006);
 996                 c->x86_cache_size = ecx >> 16;
 997                 c->x86_tlbsize += ((ebx >> 16) & 0xfff) + (ebx & 0xfff);
 998
 999                 printk(KERN_INFO "CPU: L2 Cache: %dK (%d bytes/line)\n",
1000                 c->x86_cache_size, ecx & 0xFF);
1001         }
1002
1003         if (n >= 0x80000007)
1004                 cpuid(0x80000007, &dummy, &dummy, &dummy, &c->x86_power);
1005         if (n >= 0x80000008) {
1006                 cpuid(0x80000008, &eax, &dummy, &dummy, &dummy);
1007                 c->x86_virt_bits = (eax >> 8) & 0xff;
1008                 c->x86_phys_bits = eax & 0xff;
1009         }
1010 }
1011
1012 #ifdef CONFIG_NUMA
1013 static int nearby_node(int apicid)
1014 {
1015         int i;
1016         for (i = apicid - 1; i >= 0; i--) {
1017                 int node = apicid_to_node[i];
1018                 if (node != NUMA_NO_NODE && node_online(node))
1019                         return node;
1020         }
1021         for (i = apicid + 1; i < MAX_LOCAL_APIC; i++) {
1022                 int node = apicid_to_node[i];
1023                 if (node != NUMA_NO_NODE && node_online(node))
1024                         return node;
1025         }
1026         return first_node(node_online_map); /* Shouldn't happen */
1027 }
1028 #endif
1029
1030 /*
1031  * On a AMD dual core setup the lower bits of the APIC id distingush the cores.
1032  * Assumes number of cores is a power of two.
1033  */
1034 static void __init amd_detect_cmp(struct cpuinfo_x86 *c)
1035 {
1036 #ifdef CONFIG_SMP
1037         unsigned bits;
1038 #ifdef CONFIG_NUMA
1039         int cpu = smp_processor_id();
1040         int node = 0;
1041         unsigned apicid = hard_smp_processor_id();
1042 #endif
1043         unsigned ecx = cpuid_ecx(0x80000008);
1044
1045         c->x86_max_cores = (ecx & 0xff) + 1;
1046
1047         /* CPU telling us the core id bits shift? */
1048         bits = (ecx >> 12) & 0xF;
1049
1050         /* Otherwise recompute */
1051         if (bits == 0) {
1052                 while ((1 << bits) < c->x86_max_cores)
1053                         bits++;
1054         }
1055
1056         /* Low order bits define the core id (index of core in socket) */
1057         c->cpu_core_id = c->phys_proc_id & ((1 << bits)-1);
1058         /* Convert the APIC ID into the socket ID */
1059         c->phys_proc_id = phys_pkg_id(bits);
1060
1061 #ifdef CONFIG_NUMA
1062         node = c->phys_proc_id;
1063         if (apicid_to_node[apicid] != NUMA_NO_NODE)
1064                 node = apicid_to_node[apicid];
1065         if (!node_online(node)) {
1066                 /* Two possibilities here:
1067                    - The CPU is missing memory and no node was created.
1068                    In that case try picking one from a nearby CPU
1069                    - The APIC IDs differ from the HyperTransport node IDs
1070                    which the K8 northbridge parsing fills in.
1071                    Assume they are all increased by a constant offset,
1072                    but in the same order as the HT nodeids.
1073                    If that doesn't result in a usable node fall back to the
1074                    path for the previous case.  */
1075                 int ht_nodeid = apicid - (cpu_data[0].phys_proc_id << bits);
1076                 if (ht_nodeid >= 0 &&
1077                     apicid_to_node[ht_nodeid] != NUMA_NO_NODE)
1078                         node = apicid_to_node[ht_nodeid];
1079                 /* Pick a nearby node */
1080                 if (!node_online(node))
1081                         node = nearby_node(apicid);
1082         }
1083         numa_set_node(cpu, node);
1084
1085         printk(KERN_INFO "CPU %d/%x -> Node %d\n", cpu, apicid, node);
1086 #endif
1087 #endif
1088 }
1089
1090 static void __init init_amd(struct cpuinfo_x86 *c)
1091 {
1092         unsigned level;
1093
1094 #ifdef CONFIG_SMP
1095         unsigned long value;
1096
1097         /*
1098          * Disable TLB flush filter by setting HWCR.FFDIS on K8
1099          * bit 6 of msr C001_0015
1100          *
1101          * Errata 63 for SH-B3 steppings
1102          * Errata 122 for all steppings (F+ have it disabled by default)
1103          */
1104         if (c->x86 == 15) {
1105                 rdmsrl(MSR_K8_HWCR, value);
1106                 value |= 1 << 6;
1107                 wrmsrl(MSR_K8_HWCR, value);
1108         }
1109 #endif
1110
1111         /* Bit 31 in normal CPUID used for nonstandard 3DNow ID;
1112            3DNow is IDd by bit 31 in extended CPUID (1*32+31) anyway */
1113         clear_bit(0*32+31, &c->x86_capability);
1114
1115         /* On C+ stepping K8 rep microcode works well for copy/memset */
1116         level = cpuid_eax(1);
1117         if (c->x86 == 15 && ((level >= 0x0f48 && level < 0x0f50) || level >= 0x0f58))
1118                 set_bit(X86_FEATURE_REP_GOOD, &c->x86_capability);
1119
1120         /* Enable workaround for FXSAVE leak */
1121         if (c->x86 >= 6)
1122                 set_bit(X86_FEATURE_FXSAVE_LEAK, &c->x86_capability);
1123
1124         level = get_model_name(c);
1125         if (!level) {
1126                 switch (c->x86) {
1127                 case 15:
1128                         /* Should distinguish Models here, but this is only
1129                            a fallback anyways. */
1130                         strcpy(c->x86_model_id, "Hammer");
1131                         break;
1132                 }
1133         }
1134         display_cacheinfo(c);
1135
1136         /* c->x86_power is 8000_0007 edx. Bit 8 is constant TSC */
1137         if (c->x86_power & (1<<8))
1138                 set_bit(X86_FEATURE_CONSTANT_TSC, &c->x86_capability);
1139
1140         /* Multi core CPU? */
1141         if (c->extended_cpuid_level >= 0x80000008)
1142                 amd_detect_cmp(c);
1143
1144         /* Fix cpuid4 emulation for more */
1145         num_cache_leaves = 3;
1146 }
1147
1148 static void __cpuinit detect_ht(struct cpuinfo_x86 *c)
1149 {
1150 #ifdef CONFIG_SMP
1151         u32     eax, ebx, ecx, edx;
1152         int     index_msb, core_bits;
1153         int     cpu = smp_processor_id();
1154
1155         cpuid(1, &eax, &ebx, &ecx, &edx);
1156
1157
1158         if (!cpu_has(c, X86_FEATURE_HT))
1159                 return;
1160         if (cpu_has(c, X86_FEATURE_CMP_LEGACY))
1161                 goto out;
1162
1163         smp_num_siblings = (ebx & 0xff0000) >> 16;
1164
1165         if (smp_num_siblings == 1) {
1166                 printk(KERN_INFO  "CPU: Hyper-Threading is disabled\n");
1167         } else if (smp_num_siblings > 1 ) {
1168
1169                 if (smp_num_siblings > NR_CPUS) {
1170                         printk(KERN_WARNING "CPU: Unsupported number of the siblings %d", smp_num_siblings);
1171                         smp_num_siblings = 1;
1172                         return;
1173                 }
1174
1175                 index_msb = get_count_order(smp_num_siblings);
1176                 c->phys_proc_id = phys_pkg_id(index_msb);
1177
1178                 smp_num_siblings = smp_num_siblings / c->x86_max_cores;
1179
1180                 index_msb = get_count_order(smp_num_siblings) ;
1181
1182                 core_bits = get_count_order(c->x86_max_cores);
1183
1184                 c->cpu_core_id = phys_pkg_id(index_msb) &
1185                                                ((1 << core_bits) - 1);
1186         }
1187 out:
1188         if ((c->x86_max_cores * smp_num_siblings) > 1) {
1189                 printk(KERN_INFO  "CPU: Physical Processor ID: %d\n", c->phys_proc_id);
1190                 printk(KERN_INFO  "CPU: Processor Core ID: %d\n", c->cpu_core_id);
1191         }
1192 #endif
1193 }
1194
1195 /*
1196  * find out the number of processor cores on the die
1197  */
1198 static int __cpuinit intel_num_cpu_cores(struct cpuinfo_x86 *c)
1199 {
1200         unsigned int eax, t;
1201
1202         if (c->cpuid_level < 4)
1203                 return 1;
1204
1205         cpuid_count(4, 0, &eax, &t, &t, &t);
1206
1207         if (eax & 0x1f)
1208                 return ((eax >> 26) + 1);
1209         else
1210                 return 1;
1211 }
1212
1213 static void srat_detect_node(void)
1214 {
1215 #ifdef CONFIG_NUMA
1216         unsigned node;
1217         int cpu = smp_processor_id();
1218         int apicid = hard_smp_processor_id();
1219
1220         /* Don't do the funky fallback heuristics the AMD version employs
1221            for now. */
1222         node = apicid_to_node[apicid];
1223         if (node == NUMA_NO_NODE)
1224                 node = first_node(node_online_map);
1225         numa_set_node(cpu, node);
1226
1227         if (acpi_numa > 0)
1228                 printk(KERN_INFO "CPU %d/%x -> Node %d\n", cpu, apicid, node);
1229 #endif
1230 }
1231
1232 static void __cpuinit init_intel(struct cpuinfo_x86 *c)
1233 {
1234         /* Cache sizes */
1235         unsigned n;
1236
1237         init_intel_cacheinfo(c);
1238         if (c->cpuid_level > 9 ) {
1239                 unsigned eax = cpuid_eax(10);
1240                 /* Check for version and the number of counters */
1241                 if ((eax & 0xff) && (((eax>>8) & 0xff) > 1))
1242                         set_bit(X86_FEATURE_ARCH_PERFMON, &c->x86_capability);
1243         }
1244
1245         n = c->extended_cpuid_level;
1246         if (n >= 0x80000008) {
1247                 unsigned eax = cpuid_eax(0x80000008);
1248                 c->x86_virt_bits = (eax >> 8) & 0xff;
1249                 c->x86_phys_bits = eax & 0xff;
1250                 /* CPUID workaround for Intel 0F34 CPU */
1251                 if (c->x86_vendor == X86_VENDOR_INTEL &&
1252                     c->x86 == 0xF && c->x86_model == 0x3 &&
1253                     c->x86_mask == 0x4)
1254                         c->x86_phys_bits = 36;
1255         }
1256
1257         if (c->x86 == 15)
1258                 c->x86_cache_alignment = c->x86_clflush_size * 2;
1259         if ((c->x86 == 0xf && c->x86_model >= 0x03) ||
1260             (c->x86 == 0x6 && c->x86_model >= 0x0e))
1261                 set_bit(X86_FEATURE_CONSTANT_TSC, &c->x86_capability);
1262         set_bit(X86_FEATURE_SYNC_RDTSC, &c->x86_capability);
1263         c->x86_max_cores = intel_num_cpu_cores(c);
1264
1265         srat_detect_node();
1266 }
1267
1268 static void __cpuinit get_cpu_vendor(struct cpuinfo_x86 *c)
1269 {
1270         char *v = c->x86_vendor_id;
1271
1272         if (!strcmp(v, "AuthenticAMD"))
1273                 c->x86_vendor = X86_VENDOR_AMD;
1274         else if (!strcmp(v, "GenuineIntel"))
1275                 c->x86_vendor = X86_VENDOR_INTEL;
1276         else
1277                 c->x86_vendor = X86_VENDOR_UNKNOWN;
1278 }
1279
1280 struct cpu_model_info {
1281         int vendor;
1282         int family;
1283         char *model_names[16];
1284 };
1285
1286 /* Do some early cpuid on the boot CPU to get some parameter that are
1287    needed before check_bugs. Everything advanced is in identify_cpu
1288    below. */
1289 void __cpuinit early_identify_cpu(struct cpuinfo_x86 *c)
1290 {
1291         u32 tfms;
1292
1293         c->loops_per_jiffy = loops_per_jiffy;
1294         c->x86_cache_size = -1;
1295         c->x86_vendor = X86_VENDOR_UNKNOWN;
1296         c->x86_model = c->x86_mask = 0; /* So far unknown... */
1297         c->x86_vendor_id[0] = '\0'; /* Unset */
1298         c->x86_model_id[0] = '\0';  /* Unset */
1299         c->x86_clflush_size = 64;
1300         c->x86_cache_alignment = c->x86_clflush_size;
1301         c->x86_max_cores = 1;
1302         c->extended_cpuid_level = 0;
1303         memset(&c->x86_capability, 0, sizeof c->x86_capability);
1304
1305         /* Get vendor name */
1306         cpuid(0x00000000, (unsigned int *)&c->cpuid_level,
1307               (unsigned int *)&c->x86_vendor_id[0],
1308               (unsigned int *)&c->x86_vendor_id[8],
1309               (unsigned int *)&c->x86_vendor_id[4]);
1310
1311         get_cpu_vendor(c);
1312
1313         /* Initialize the standard set of capabilities */
1314         /* Note that the vendor-specific code below might override */
1315
1316         /* Intel-defined flags: level 0x00000001 */
1317         if (c->cpuid_level >= 0x00000001) {
1318                 __u32 misc;
1319                 cpuid(0x00000001, &tfms, &misc, &c->x86_capability[4],
1320                       &c->x86_capability[0]);
1321                 c->x86 = (tfms >> 8) & 0xf;
1322                 c->x86_model = (tfms >> 4) & 0xf;
1323                 c->x86_mask = tfms & 0xf;
1324                 if (c->x86 == 0xf)
1325                         c->x86 += (tfms >> 20) & 0xff;
1326                 if (c->x86 >= 0x6)
1327                         c->x86_model += ((tfms >> 16) & 0xF) << 4;
1328                 if (c->x86_capability[0] & (1<<19))
1329                         c->x86_clflush_size = ((misc >> 8) & 0xff) * 8;
1330         } else {
1331                 /* Have CPUID level 0 only - unheard of */
1332                 c->x86 = 4;
1333         }
1334
1335 #ifdef CONFIG_SMP
1336         c->phys_proc_id = (cpuid_ebx(1) >> 24) & 0xff;
1337 #endif
1338 }
1339
1340 /*
1341  * This does the hard work of actually picking apart the CPU stuff...
1342  */
1343 void __cpuinit identify_cpu(struct cpuinfo_x86 *c)
1344 {
1345         int i;
1346         u32 xlvl;
1347
1348         early_identify_cpu(c);
1349
1350         /* AMD-defined flags: level 0x80000001 */
1351         xlvl = cpuid_eax(0x80000000);
1352         c->extended_cpuid_level = xlvl;
1353         if ((xlvl & 0xffff0000) == 0x80000000) {
1354                 if (xlvl >= 0x80000001) {
1355                         c->x86_capability[1] = cpuid_edx(0x80000001);
1356                         c->x86_capability[6] = cpuid_ecx(0x80000001);
1357                 }
1358                 if (xlvl >= 0x80000004)
1359                         get_model_name(c); /* Default name */
1360         }
1361
1362         /* Transmeta-defined flags: level 0x80860001 */
1363         xlvl = cpuid_eax(0x80860000);
1364         if ((xlvl & 0xffff0000) == 0x80860000) {
1365                 /* Don't set x86_cpuid_level here for now to not confuse. */
1366                 if (xlvl >= 0x80860001)
1367                         c->x86_capability[2] = cpuid_edx(0x80860001);
1368         }
1369
1370         c->apicid = phys_pkg_id(0);
1371
1372         /*
1373          * Vendor-specific initialization.  In this section we
1374          * canonicalize the feature flags, meaning if there are
1375          * features a certain CPU supports which CPUID doesn't
1376          * tell us, CPUID claiming incorrect flags, or other bugs,
1377          * we handle them here.
1378          *
1379          * At the end of this section, c->x86_capability better
1380          * indicate the features this CPU genuinely supports!
1381          */
1382         switch (c->x86_vendor) {
1383         case X86_VENDOR_AMD:
1384                 init_amd(c);
1385                 break;
1386
1387         case X86_VENDOR_INTEL:
1388                 init_intel(c);
1389                 break;
1390
1391         case X86_VENDOR_UNKNOWN:
1392         default:
1393                 display_cacheinfo(c);
1394                 break;
1395         }
1396
1397         select_idle_routine(c);
1398         detect_ht(c);
1399
1400         /*
1401          * On SMP, boot_cpu_data holds the common feature set between
1402          * all CPUs; so make sure that we indicate which features are
1403          * common between the CPUs.  The first time this routine gets
1404          * executed, c == &boot_cpu_data.
1405          */
1406         if (c != &boot_cpu_data) {
1407                 /* AND the already accumulated flags with these */
1408                 for (i = 0 ; i < NCAPINTS ; i++)
1409                         boot_cpu_data.x86_capability[i] &= c->x86_capability[i];
1410         }
1411
1412 #ifdef CONFIG_X86_MCE
1413         mcheck_init(c);
1414 #endif
1415         if (c == &boot_cpu_data)
1416                 mtrr_bp_init();
1417         else
1418                 mtrr_ap_init();
1419 #ifdef CONFIG_NUMA
1420         numa_add_cpu(smp_processor_id());
1421 #endif
1422 }
1423
1424
1425 void __cpuinit print_cpu_info(struct cpuinfo_x86 *c)
1426 {
1427         if (c->x86_model_id[0])
1428                 printk("%s", c->x86_model_id);
1429
1430         if (c->x86_mask || c->cpuid_level >= 0)
1431                 printk(" stepping %02x\n", c->x86_mask);
1432         else
1433                 printk("\n");
1434 }
1435
1436 /*
1437  *      Get CPU information for use by the procfs.
1438  */
1439
1440 static int show_cpuinfo(struct seq_file *m, void *v)
1441 {
1442         struct cpuinfo_x86 *c = v;
1443
1444         /*
1445          * These flag bits must match the definitions in <asm/cpufeature.h>.
1446          * NULL means this bit is undefined or reserved; either way it doesn't
1447          * have meaning as far as Linux is concerned.  Note that it's important
1448          * to realize there is a difference between this table and CPUID -- if
1449          * applications want to get the raw CPUID data, they should access
1450          * /dev/cpu/<cpu_nr>/cpuid instead.
1451          */
1452         static char *x86_cap_flags[] = {
1453                 /* Intel-defined */
1454                 "fpu", "vme", "de", "pse", "tsc", "msr", "pae", "mce",
1455                 "cx8", "apic", NULL, "sep", "mtrr", "pge", "mca", "cmov",
1456                 "pat", "pse36", "pn", "clflush", NULL, "dts", "acpi", "mmx",
1457                 "fxsr", "sse", "sse2", "ss", "ht", "tm", "ia64", NULL,
1458
1459                 /* AMD-defined */
1460                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1461                 NULL, NULL, NULL, "syscall", NULL, NULL, NULL, NULL,
1462                 NULL, NULL, NULL, NULL, "nx", NULL, "mmxext", NULL,
1463                 NULL, "fxsr_opt", NULL, "rdtscp", NULL, "lm", "3dnowext", "3dnow",
1464
1465                 /* Transmeta-defined */
1466                 "recovery", "longrun", NULL, "lrti", NULL, NULL, NULL, NULL,
1467                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1468                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1469                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1470
1471                 /* Other (Linux-defined) */
1472                 "cxmmx", NULL, "cyrix_arr", "centaur_mcr", NULL,
1473                 "constant_tsc", NULL, NULL,
1474                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1475                 "up", NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1476                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1477
1478                 /* Intel-defined (#2) */
1479                 "pni", NULL, NULL, "monitor", "ds_cpl", "vmx", "smx", "est",
1480                 "tm2", NULL, "cid", NULL, NULL, "cx16", "xtpr", NULL,
1481                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1482                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1483
1484                 /* VIA/Cyrix/Centaur-defined */
1485                 NULL, NULL, "rng", "rng_en", NULL, NULL, "ace", "ace_en",
1486                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1487                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1488                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1489
1490                 /* AMD-defined (#2) */
1491                 "lahf_lm", "cmp_legacy", "svm", NULL, "cr8_legacy", NULL, NULL, NULL,
1492                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1493                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1494                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1495         };
1496         static char *x86_power_flags[] = {
1497                 "ts",   /* temperature sensor */
1498                 "fid",  /* frequency id control */
1499                 "vid",  /* voltage id control */
1500                 "ttp",  /* thermal trip */
1501                 "tm",
1502                 "stc",
1503                 NULL,
1504                 /* nothing */   /* constant_tsc - moved to flags */
1505         };
1506
1507
1508 #ifdef CONFIG_SMP
1509         if (!cpu_online(c-cpu_data))
1510                 return 0;
1511 #endif
1512
1513         seq_printf(m,"processor\t: %u\n"
1514                      "vendor_id\t: %s\n"
1515                      "cpu family\t: %d\n"
1516                      "model\t\t: %d\n"
1517                      "model name\t: %s\n",
1518                      (unsigned)(c-cpu_data),
1519                      c->x86_vendor_id[0] ? c->x86_vendor_id : "unknown",
1520                      c->x86,
1521                      (int)c->x86_model,
1522                      c->x86_model_id[0] ? c->x86_model_id : "unknown");
1523
1524         if (c->x86_mask || c->cpuid_level >= 0)
1525                 seq_printf(m, "stepping\t: %d\n", c->x86_mask);
1526         else
1527                 seq_printf(m, "stepping\t: unknown\n");
1528
1529         if (cpu_has(c,X86_FEATURE_TSC)) {
1530                 unsigned int freq = cpufreq_quick_get((unsigned)(c-cpu_data));
1531                 if (!freq)
1532                         freq = cpu_khz;
1533                 seq_printf(m, "cpu MHz\t\t: %u.%03u\n",
1534                              freq / 1000, (freq % 1000));
1535         }
1536
1537         /* Cache size */
1538         if (c->x86_cache_size >= 0)
1539                 seq_printf(m, "cache size\t: %d KB\n", c->x86_cache_size);
1540
1541 #ifdef CONFIG_SMP
1542         if (smp_num_siblings * c->x86_max_cores > 1) {
1543                 int cpu = c - cpu_data;
1544                 seq_printf(m, "physical id\t: %d\n", c->phys_proc_id);
1545                 seq_printf(m, "siblings\t: %d\n", cpus_weight(cpu_core_map[cpu]));
1546                 seq_printf(m, "core id\t\t: %d\n", c->cpu_core_id);
1547                 seq_printf(m, "cpu cores\t: %d\n", c->booted_cores);
1548         }
1549 #endif
1550
1551         seq_printf(m,
1552                 "fpu\t\t: yes\n"
1553                 "fpu_exception\t: yes\n"
1554                 "cpuid level\t: %d\n"
1555                 "wp\t\t: yes\n"
1556                 "flags\t\t:",
1557                    c->cpuid_level);
1558
1559         {
1560                 int i;
1561                 for ( i = 0 ; i < 32*NCAPINTS ; i++ )
1562                         if (cpu_has(c, i) && x86_cap_flags[i] != NULL)
1563                                 seq_printf(m, " %s", x86_cap_flags[i]);
1564         }
1565
1566         seq_printf(m, "\nbogomips\t: %lu.%02lu\n",
1567                    c->loops_per_jiffy/(500000/HZ),
1568                    (c->loops_per_jiffy/(5000/HZ)) % 100);
1569
1570         if (c->x86_tlbsize > 0)
1571                 seq_printf(m, "TLB size\t: %d 4K pages\n", c->x86_tlbsize);
1572         seq_printf(m, "clflush size\t: %d\n", c->x86_clflush_size);
1573         seq_printf(m, "cache_alignment\t: %d\n", c->x86_cache_alignment);
1574
1575         seq_printf(m, "address sizes\t: %u bits physical, %u bits virtual\n",
1576                    c->x86_phys_bits, c->x86_virt_bits);
1577
1578         seq_printf(m, "power management:");
1579         {
1580                 unsigned i;
1581                 for (i = 0; i < 32; i++)
1582                         if (c->x86_power & (1 << i)) {
1583                                 if (i < ARRAY_SIZE(x86_power_flags) &&
1584                                         x86_power_flags[i])
1585                                         seq_printf(m, "%s%s",
1586                                                 x86_power_flags[i][0]?" ":"",
1587                                                 x86_power_flags[i]);
1588                                 else
1589                                         seq_printf(m, " [%d]", i);
1590                         }
1591         }
1592
1593         seq_printf(m, "\n\n");
1594
1595         return 0;
1596 }
1597
1598 static void *c_start(struct seq_file *m, loff_t *pos)
1599 {
1600         return *pos < NR_CPUS ? cpu_data + *pos : NULL;
1601 }
1602
1603 static void *c_next(struct seq_file *m, void *v, loff_t *pos)
1604 {
1605         ++*pos;
1606         return c_start(m, pos);
1607 }
1608
1609 static void c_stop(struct seq_file *m, void *v)
1610 {
1611 }
1612
1613 struct seq_operations cpuinfo_op = {
1614         .start =c_start,
1615         .next = c_next,
1616         .stop = c_stop,
1617         .show = show_cpuinfo,
1618 };
1619
1620 #if defined(CONFIG_INPUT_PCSPKR) || defined(CONFIG_INPUT_PCSPKR_MODULE)
1621 #include <linux/platform_device.h>
1622 static __init int add_pcspkr(void)
1623 {
1624         struct platform_device *pd;
1625         int ret;
1626
1627         pd = platform_device_alloc("pcspkr", -1);
1628         if (!pd)
1629                 return -ENOMEM;
1630
1631         ret = platform_device_add(pd);
1632         if (ret)
1633                 platform_device_put(pd);
1634
1635         return ret;
1636 }
1637 device_initcall(add_pcspkr);
1638 #endif