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