arch/i386/kernel/setup.c

   1 /*
   2  *  linux/arch/i386/kernel/setup.c
   3  *
   4  *  Copyright (C) 1995  Linus Torvalds
   5  *
   6  *  Support of BIGMEM added by Gerhard Wichert, Siemens AG, July 1999
   7  *
   8  *  Memory region support
   9  *      David Parsons <orc@pell.chi.il.us>, July-August 1999
  10  *
  11  *  Added E820 sanitization routine (removes overlapping memory regions);
  12  *  Brian Moyle <bmoyle@mvista.com>, February 2001
  13  *
  14  * Moved CPU detection code to cpu/${cpu}.c
  15  *    Patrick Mochel <mochel@osdl.org>, March 2002
  16  *
  17  *  Provisions for empty E820 memory regions (reported by certain BIOSes).
  18  *  Alex Achenbach <xela@slit.de>, December 2002.
  19  *
  20  */
  21
  22 /*
  23  * This file handles the architecture-dependent parts of initialization
  24  */
  25
  26 #include <linux/sched.h>
  27 #include <linux/mm.h>
  28 #include <linux/mmzone.h>
  29 #include <linux/tty.h>
  30 #include <linux/ioport.h>
  31 #include <linux/acpi.h>
  32 #include <linux/apm_bios.h>
  33 #include <linux/initrd.h>
  34 #include <linux/bootmem.h>
  35 #include <linux/seq_file.h>
  36 #include <linux/console.h>
  37 #include <linux/mca.h>
  38 #include <linux/root_dev.h>
  39 #include <linux/highmem.h>
  40 #include <linux/module.h>
  41 #include <linux/efi.h>
  42 #include <linux/init.h>
  43 #include <linux/edd.h>
  44 #include <linux/nodemask.h>
  45 #include <video/edid.h>
  46 #include <asm/e820.h>
  47 #include <asm/mpspec.h>
  48 #include <asm/setup.h>
  49 #include <asm/arch_hooks.h>
  50 #include <asm/sections.h>
  51 #include <asm/io_apic.h>
  52 #include <asm/ist.h>
  53 #include <asm/io.h>
  54 #include "setup_arch_pre.h"
  55 #include <bios_ebda.h>
  56
  57 /* This value is set up by the early boot code to point to the value
  58    immediately after the boot time page tables.  It contains a *physical*
  59    address, and must not be in the .bss segment! */
  60 unsigned long init_pg_tables_end __initdata = ~0UL;
  61
  62 int disable_pse __initdata = 0;
  63
  64 /*
  65  * Machine setup..
  66  */
  67
  68 #ifdef CONFIG_EFI
  69 int efi_enabled = 0;
  70 EXPORT_SYMBOL(efi_enabled);
  71 #endif
  72
  73 /* cpu data as detected by the assembly code in head.S */
  74 struct cpuinfo_x86 new_cpu_data __initdata = { 0, 0, 0, 0, -1, 1, 0, 0, -1 };
  75 /* common cpu data for all cpus */
  76 struct cpuinfo_x86 boot_cpu_data = { 0, 0, 0, 0, -1, 1, 0, 0, -1 };
  77
  78 unsigned long mmu_cr4_features;
  79
  80 #ifdef  CONFIG_ACPI_INTERPRETER
  81         int acpi_disabled = 0;
  82 #else
  83         int acpi_disabled = 1;
  84 #endif
  85 EXPORT_SYMBOL(acpi_disabled);
  86
  87 #ifdef  CONFIG_ACPI_BOOT
  88 int __initdata acpi_force = 0;
  89 extern acpi_interrupt_flags     acpi_sci_flags;
  90 #endif
  91
  92 /* for MCA, but anyone else can use it if they want */
  93 unsigned int machine_id;
  94 unsigned int machine_submodel_id;
  95 unsigned int BIOS_revision;
  96 unsigned int mca_pentium_flag;
  97
  98 /* For PCI or other memory-mapped resources */
  99 unsigned long pci_mem_start = 0x10000000;
 100
 101 /* Boot loader ID as an integer, for the benefit of proc_dointvec */
 102 int bootloader_type;
 103
 104 /* user-defined highmem size */
 105 static unsigned int highmem_pages = -1;
 106
 107 /*
 108  * Setup options
 109  */
 110 struct drive_info_struct { char dummy[32]; } drive_info;
 111 struct screen_info screen_info;
 112 struct apm_info apm_info;
 113 struct sys_desc_table_struct {
 114         unsigned short length;
 115         unsigned char table[0];
 116 };
 117 struct edid_info edid_info;
 118 struct ist_info ist_info;
 119 struct e820map e820;
 120
 121 extern void early_cpu_init(void);
 122 extern void dmi_scan_machine(void);
 123 extern void generic_apic_probe(char *);
 124 extern int root_mountflags;
 125
 126 unsigned long saved_videomode;
 127
 128 #define RAMDISK_IMAGE_START_MASK        0x07FF
 129 #define RAMDISK_PROMPT_FLAG             0x8000
 130 #define RAMDISK_LOAD_FLAG               0x4000
 131
 132 static char command_line[COMMAND_LINE_SIZE];
 133
 134 unsigned char __initdata boot_params[PARAM_SIZE];
 135
 136 static struct resource data_resource = {
 137         .name   = "Kernel data",
 138         .start  = 0,
 139         .end    = 0,
 140         .flags  = IORESOURCE_BUSY | IORESOURCE_MEM
 141 };
 142
 143 static struct resource code_resource = {
 144         .name   = "Kernel code",
 145         .start  = 0,
 146         .end    = 0,
 147         .flags  = IORESOURCE_BUSY | IORESOURCE_MEM
 148 };
 149
 150 static struct resource system_rom_resource = {
 151         .name   = "System ROM",
 152         .start  = 0xf0000,
 153         .end    = 0xfffff,
 154         .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
 155 };
 156
 157 static struct resource extension_rom_resource = {
 158         .name   = "Extension ROM",
 159         .start  = 0xe0000,
 160         .end    = 0xeffff,
 161         .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
 162 };
 163
 164 static struct resource adapter_rom_resources[] = { {
 165         .name   = "Adapter ROM",
 166         .start  = 0xc8000,
 167         .end    = 0,
 168         .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
 169 }, {
 170         .name   = "Adapter ROM",
 171         .start  = 0,
 172         .end    = 0,
 173         .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
 174 }, {
 175         .name   = "Adapter ROM",
 176         .start  = 0,
 177         .end    = 0,
 178         .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
 179 }, {
 180         .name   = "Adapter ROM",
 181         .start  = 0,
 182         .end    = 0,
 183         .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
 184 }, {
 185         .name   = "Adapter ROM",
 186         .start  = 0,
 187         .end    = 0,
 188         .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
 189 }, {
 190         .name   = "Adapter ROM",
 191         .start  = 0,
 192         .end    = 0,
 193         .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
 194 } };
 195
 196 #define ADAPTER_ROM_RESOURCES \
 197         (sizeof adapter_rom_resources / sizeof adapter_rom_resources[0])
 198
 199 static struct resource video_rom_resource = {
 200         .name   = "Video ROM",
 201         .start  = 0xc0000,
 202         .end    = 0xc7fff,
 203         .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
 204 };
 205
 206 static struct resource video_ram_resource = {
 207         .name   = "Video RAM area",
 208         .start  = 0xa0000,
 209         .end    = 0xbffff,
 210         .flags  = IORESOURCE_BUSY | IORESOURCE_MEM
 211 };
 212
 213 static struct resource standard_io_resources[] = { {
 214         .name   = "dma1",
 215         .start  = 0x0000,
 216         .end    = 0x001f,
 217         .flags  = IORESOURCE_BUSY | IORESOURCE_IO
 218 }, {
 219         .name   = "pic1",
 220         .start  = 0x0020,
 221         .end    = 0x0021,
 222         .flags  = IORESOURCE_BUSY | IORESOURCE_IO
 223 }, {
 224         .name   = "timer0",
 225         .start  = 0x0040,
 226         .end    = 0x0043,
 227         .flags  = IORESOURCE_BUSY | IORESOURCE_IO
 228 }, {
 229         .name   = "timer1",
 230         .start  = 0x0050,
 231         .end    = 0x0053,
 232         .flags  = IORESOURCE_BUSY | IORESOURCE_IO
 233 }, {
 234         .name   = "keyboard",
 235         .start  = 0x0060,
 236         .end    = 0x006f,
 237         .flags  = IORESOURCE_BUSY | IORESOURCE_IO
 238 }, {
 239         .name   = "dma page reg",
 240         .start  = 0x0080,
 241         .end    = 0x008f,
 242         .flags  = IORESOURCE_BUSY | IORESOURCE_IO
 243 }, {
 244         .name   = "pic2",
 245         .start  = 0x00a0,
 246         .end    = 0x00a1,
 247         .flags  = IORESOURCE_BUSY | IORESOURCE_IO
 248 }, {
 249         .name   = "dma2",
 250         .start  = 0x00c0,
 251         .end    = 0x00df,
 252         .flags  = IORESOURCE_BUSY | IORESOURCE_IO
 253 }, {
 254         .name   = "fpu",
 255         .start  = 0x00f0,
 256         .end    = 0x00ff,
 257         .flags  = IORESOURCE_BUSY | IORESOURCE_IO
 258 } };
 259
 260 #define STANDARD_IO_RESOURCES \
 261         (sizeof standard_io_resources / sizeof standard_io_resources[0])
 262
 263 #define romsignature(x) (*(unsigned short *)(x) == 0xaa55)
 264
 265 static int __init romchecksum(unsigned char *rom, unsigned long length)
 266 {
 267         unsigned char *p, sum = 0;
 268
 269         for (p = rom; p < rom + length; p++)
 270                 sum += *p;
 271         return sum == 0;
 272 }
 273
 274 static void __init probe_roms(void)
 275 {
 276         unsigned long start, length, upper;
 277         unsigned char *rom;
 278         int           i;
 279
 280         /* video rom */
 281         upper = adapter_rom_resources[0].start;
 282         for (start = video_rom_resource.start; start < upper; start += 2048) {
 283                 rom = isa_bus_to_virt(start);
 284                 if (!romsignature(rom))
 285                         continue;
 286
 287                 video_rom_resource.start = start;
 288
 289                 /* 0 < length <= 0x7f * 512, historically */
 290                 length = rom[2] * 512;
 291
 292                 /* if checksum okay, trust length byte */
 293                 if (length && romchecksum(rom, length))
 294                         video_rom_resource.end = start + length - 1;
 295
 296                 request_resource(&iomem_resource, &video_rom_resource);
 297                 break;
 298         }
 299
 300         start = (video_rom_resource.end + 1 + 2047) & ~2047UL;
 301         if (start < upper)
 302                 start = upper;
 303
 304         /* system rom */
 305         request_resource(&iomem_resource, &system_rom_resource);
 306         upper = system_rom_resource.start;
 307
 308         /* check for extension rom (ignore length byte!) */
 309         rom = isa_bus_to_virt(extension_rom_resource.start);
 310         if (romsignature(rom)) {
 311                 length = extension_rom_resource.end - extension_rom_resource.start + 1;
 312                 if (romchecksum(rom, length)) {
 313                         request_resource(&iomem_resource, &extension_rom_resource);
 314                         upper = extension_rom_resource.start;
 315                 }
 316         }
 317
 318         /* check for adapter roms on 2k boundaries */
 319         for (i = 0; i < ADAPTER_ROM_RESOURCES && start < upper; start += 2048) {
 320                 rom = isa_bus_to_virt(start);
 321                 if (!romsignature(rom))
 322                         continue;
 323
 324                 /* 0 < length <= 0x7f * 512, historically */
 325                 length = rom[2] * 512;
 326
 327                 /* but accept any length that fits if checksum okay */
 328                 if (!length || start + length > upper || !romchecksum(rom, length))
 329                         continue;
 330
 331                 adapter_rom_resources[i].start = start;
 332                 adapter_rom_resources[i].end = start + length - 1;
 333                 request_resource(&iomem_resource, &adapter_rom_resources[i]);
 334
 335                 start = adapter_rom_resources[i++].end & ~2047UL;
 336         }
 337 }
 338
 339 static void __init limit_regions(unsigned long long size)
 340 {
 341         unsigned long long current_addr = 0;
 342         int i;
 343
 344         if (efi_enabled) {
 345                 for (i = 0; i < memmap.nr_map; i++) {
 346                         current_addr = memmap.map[i].phys_addr +
 347                                        (memmap.map[i].num_pages << 12);
 348                         if (memmap.map[i].type == EFI_CONVENTIONAL_MEMORY) {
 349                                 if (current_addr >= size) {
 350                                         memmap.map[i].num_pages -=
 351                                                 (((current_addr-size) + PAGE_SIZE-1) >> PAGE_SHIFT);
 352                                         memmap.nr_map = i + 1;
 353                                         return;
 354                                 }
 355                         }
 356                 }
 357         }
 358         for (i = 0; i < e820.nr_map; i++) {
 359                 if (e820.map[i].type == E820_RAM) {
 360                         current_addr = e820.map[i].addr + e820.map[i].size;
 361                         if (current_addr >= size) {
 362                                 e820.map[i].size -= current_addr-size;
 363                                 e820.nr_map = i + 1;
 364                                 return;
 365                         }
 366                 }
 367         }
 368 }
 369
 370 static void __init add_memory_region(unsigned long long start,
 371                                   unsigned long long size, int type)
 372 {
 373         int x;
 374
 375         if (!efi_enabled) {
 376                 x = e820.nr_map;
 377
 378                 if (x == E820MAX) {
 379                     printk(KERN_ERR "Ooops! Too many entries in the memory map!\n");
 380                     return;
 381                 }
 382
 383                 e820.map[x].addr = start;
 384                 e820.map[x].size = size;
 385                 e820.map[x].type = type;
 386                 e820.nr_map++;
 387         }
 388 } /* add_memory_region */
 389
 390 #define E820_DEBUG      1
 391
 392 static void __init print_memory_map(char *who)
 393 {
 394         int i;
 395
 396         for (i = 0; i < e820.nr_map; i++) {
 397                 printk(" %s: %016Lx - %016Lx ", who,
 398                         e820.map[i].addr,
 399                         e820.map[i].addr + e820.map[i].size);
 400                 switch (e820.map[i].type) {
 401                 case E820_RAM:  printk("(usable)\n");
 402                                 break;
 403                 case E820_RESERVED:
 404                                 printk("(reserved)\n");
 405                                 break;
 406                 case E820_ACPI:
 407                                 printk("(ACPI data)\n");
 408                                 break;
 409                 case E820_NVS:
 410                                 printk("(ACPI NVS)\n");
 411                                 break;
 412                 default:        printk("type %lu\n", e820.map[i].type);
 413                                 break;
 414                 }
 415         }
 416 }
 417
 418 /*
 419  * Sanitize the BIOS e820 map.
 420  *
 421  * Some e820 responses include overlapping entries.  The following
 422  * replaces the original e820 map with a new one, removing overlaps.
 423  *
 424  */
 425 struct change_member {
 426         struct e820entry *pbios; /* pointer to original bios entry */
 427         unsigned long long addr; /* address for this change point */
 428 };
 429 static struct change_member change_point_list[2*E820MAX] __initdata;
 430 static struct change_member *change_point[2*E820MAX] __initdata;
 431 static struct e820entry *overlap_list[E820MAX] __initdata;
 432 static struct e820entry new_bios[E820MAX] __initdata;
 433
 434 static int __init sanitize_e820_map(struct e820entry * biosmap, char * pnr_map)
 435 {
 436         struct change_member *change_tmp;
 437         unsigned long current_type, last_type;
 438         unsigned long long last_addr;
 439         int chgidx, still_changing;
 440         int overlap_entries;
 441         int new_bios_entry;
 442         int old_nr, new_nr, chg_nr;
 443         int i;
 444
 445         /*
 446                 Visually we're performing the following (1,2,3,4 = memory types)...
 447
 448                 Sample memory map (w/overlaps):
 449                    ____22__________________
 450                    ______________________4_
 451                    ____1111________________
 452                    _44_____________________
 453                    11111111________________
 454                    ____________________33__
 455                    ___________44___________
 456                    __________33333_________
 457                    ______________22________
 458                    ___________________2222_
 459                    _________111111111______
 460                    _____________________11_
 461                    _________________4______
 462
 463                 Sanitized equivalent (no overlap):
 464                    1_______________________
 465                    _44_____________________
 466                    ___1____________________
 467                    ____22__________________
 468                    ______11________________
 469                    _________1______________
 470                    __________3_____________
 471                    ___________44___________
 472                    _____________33_________
 473                    _______________2________
 474                    ________________1_______
 475                    _________________4______
 476                    ___________________2____
 477                    ____________________33__
 478                    ______________________4_
 479         */
 480
 481         /* if there's only one memory region, don't bother */
 482         if (*pnr_map < 2)
 483                 return -1;
 484
 485         old_nr = *pnr_map;
 486
 487         /* bail out if we find any unreasonable addresses in bios map */
 488         for (i=0; i<old_nr; i++)
 489                 if (biosmap[i].addr + biosmap[i].size < biosmap[i].addr)
 490                         return -1;
 491
 492         /* create pointers for initial change-point information (for sorting) */
 493         for (i=0; i < 2*old_nr; i++)
 494                 change_point[i] = &change_point_list[i];
 495
 496         /* record all known change-points (starting and ending addresses),
 497            omitting those that are for empty memory regions */
 498         chgidx = 0;
 499         for (i=0; i < old_nr; i++)      {
 500                 if (biosmap[i].size != 0) {
 501                         change_point[chgidx]->addr = biosmap[i].addr;
 502                         change_point[chgidx++]->pbios = &biosmap[i];
 503                         change_point[chgidx]->addr = biosmap[i].addr + biosmap[i].size;
 504                         change_point[chgidx++]->pbios = &biosmap[i];
 505                 }
 506         }
 507         chg_nr = chgidx;        /* true number of change-points */
 508
 509         /* sort change-point list by memory addresses (low -> high) */
 510         still_changing = 1;
 511         while (still_changing)  {
 512                 still_changing = 0;
 513                 for (i=1; i < chg_nr; i++)  {
 514                         /* if <current_addr> > <last_addr>, swap */
 515                         /* or, if current=<start_addr> & last=<end_addr>, swap */
 516                         if ((change_point[i]->addr < change_point[i-1]->addr) ||
 517                                 ((change_point[i]->addr == change_point[i-1]->addr) &&
 518                                  (change_point[i]->addr == change_point[i]->pbios->addr) &&
 519                                  (change_point[i-1]->addr != change_point[i-1]->pbios->addr))
 520                            )
 521                         {
 522                                 change_tmp = change_point[i];
 523                                 change_point[i] = change_point[i-1];
 524                                 change_point[i-1] = change_tmp;
 525                                 still_changing=1;
 526                         }
 527                 }
 528         }
 529
 530         /* create a new bios memory map, removing overlaps */
 531         overlap_entries=0;       /* number of entries in the overlap table */
 532         new_bios_entry=0;        /* index for creating new bios map entries */
 533         last_type = 0;           /* start with undefined memory type */
 534         last_addr = 0;           /* start with 0 as last starting address */
 535         /* loop through change-points, determining affect on the new bios map */
 536         for (chgidx=0; chgidx < chg_nr; chgidx++)
 537         {
 538                 /* keep track of all overlapping bios entries */
 539                 if (change_point[chgidx]->addr == change_point[chgidx]->pbios->addr)
 540                 {
 541                         /* add map entry to overlap list (> 1 entry implies an overlap) */
 542                         overlap_list[overlap_entries++]=change_point[chgidx]->pbios;
 543                 }
 544                 else
 545                 {
 546                         /* remove entry from list (order independent, so swap with last) */
 547                         for (i=0; i<overlap_entries; i++)
 548                         {
 549                                 if (overlap_list[i] == change_point[chgidx]->pbios)
 550                                         overlap_list[i] = overlap_list[overlap_entries-1];
 551                         }
 552                         overlap_entries--;
 553                 }
 554                 /* if there are overlapping entries, decide which "type" to use */
 555                 /* (larger value takes precedence -- 1=usable, 2,3,4,4+=unusable) */
 556                 current_type = 0;
 557                 for (i=0; i<overlap_entries; i++)
 558                         if (overlap_list[i]->type > current_type)
 559                                 current_type = overlap_list[i]->type;
 560                 /* continue building up new bios map based on this information */
 561                 if (current_type != last_type)  {
 562                         if (last_type != 0)      {
 563                                 new_bios[new_bios_entry].size =
 564                                         change_point[chgidx]->addr - last_addr;
 565                                 /* move forward only if the new size was non-zero */
 566                                 if (new_bios[new_bios_entry].size != 0)
 567                                         if (++new_bios_entry >= E820MAX)
 568                                                 break;  /* no more space left for new bios entries */
 569                         }
 570                         if (current_type != 0)  {
 571                                 new_bios[new_bios_entry].addr = change_point[chgidx]->addr;
 572                                 new_bios[new_bios_entry].type = current_type;
 573                                 last_addr=change_point[chgidx]->addr;
 574                         }
 575                         last_type = current_type;
 576                 }
 577         }
 578         new_nr = new_bios_entry;   /* retain count for new bios entries */
 579
 580         /* copy new bios mapping into original location */
 581         memcpy(biosmap, new_bios, new_nr*sizeof(struct e820entry));
 582         *pnr_map = new_nr;
 583
 584         return 0;
 585 }
 586
 587 /*
 588  * Copy the BIOS e820 map into a safe place.
 589  *
 590  * Sanity-check it while we're at it..
 591  *
 592  * If we're lucky and live on a modern system, the setup code
 593  * will have given us a memory map that we can use to properly
 594  * set up memory.  If we aren't, we'll fake a memory map.
 595  *
 596  * We check to see that the memory map contains at least 2 elements
 597  * before we'll use it, because the detection code in setup.S may
 598  * not be perfect and most every PC known to man has two memory
 599  * regions: one from 0 to 640k, and one from 1mb up.  (The IBM
 600  * thinkpad 560x, for example, does not cooperate with the memory
 601  * detection code.)
 602  */
 603 static int __init copy_e820_map(struct e820entry * biosmap, int nr_map)
 604 {
 605         /* Only one memory region (or negative)? Ignore it */
 606         if (nr_map < 2)
 607                 return -1;
 608
 609         do {
 610                 unsigned long long start = biosmap->addr;
 611                 unsigned long long size = biosmap->size;
 612                 unsigned long long end = start + size;
 613                 unsigned long type = biosmap->type;
 614
 615                 /* Overflow in 64 bits? Ignore the memory map. */
 616                 if (start > end)
 617                         return -1;
 618
 619                 /*
 620                  * Some BIOSes claim RAM in the 640k - 1M region.
 621                  * Not right. Fix it up.
 622                  */
 623                 if (type == E820_RAM) {
 624                         if (start < 0x100000ULL && end > 0xA0000ULL) {
 625                                 if (start < 0xA0000ULL)
 626                                         add_memory_region(start, 0xA0000ULL-start, type);
 627                                 if (end <= 0x100000ULL)
 628                                         continue;
 629                                 start = 0x100000ULL;
 630                                 size = end - start;
 631                         }
 632                 }
 633                 add_memory_region(start, size, type);
 634         } while (biosmap++,--nr_map);
 635         return 0;
 636 }
 637
 638 #if defined(CONFIG_EDD) || defined(CONFIG_EDD_MODULE)
 639 struct edd edd;
 640 #ifdef CONFIG_EDD_MODULE
 641 EXPORT_SYMBOL(edd);
 642 #endif
 643 /**
 644  * copy_edd() - Copy the BIOS EDD information
 645  *              from boot_params into a safe place.
 646  *
 647  */
 648 static inline void copy_edd(void)
 649 {
 650      memcpy(edd.mbr_signature, EDD_MBR_SIGNATURE, sizeof(edd.mbr_signature));
 651      memcpy(edd.edd_info, EDD_BUF, sizeof(edd.edd_info));
 652      edd.mbr_signature_nr = EDD_MBR_SIG_NR;
 653      edd.edd_info_nr = EDD_NR;
 654 }
 655 #else
 656 static inline void copy_edd(void)
 657 {
 658 }
 659 #endif
 660
 661 /*
 662  * Do NOT EVER look at the BIOS memory size location.
 663  * It does not work on many machines.
 664  */
 665 #define LOWMEMSIZE()    (0x9f000)
 666
 667 static void __init parse_cmdline_early (char ** cmdline_p)
 668 {
 669         char c = ' ', *to = command_line, *from = saved_command_line;
 670         int len = 0;
 671         int userdef = 0;
 672
 673         /* Save unparsed command line copy for /proc/cmdline */
 674         saved_command_line[COMMAND_LINE_SIZE-1] = '\0';
 675
 676         for (;;) {
 677                 if (c != ' ')
 678                         goto next_char;
 679                 /*
 680                  * "mem=nopentium" disables the 4MB page tables.
 681                  * "mem=XXX[kKmM]" defines a memory region from HIGH_MEM
 682                  * to <mem>, overriding the bios size.
 683                  * "memmap=XXX[KkmM]@XXX[KkmM]" defines a memory region from
 684                  * <start> to <start>+<mem>, overriding the bios size.
 685                  *
 686                  * HPA tells me bootloaders need to parse mem=, so no new
 687                  * option should be mem=  [also see Documentation/i386/boot.txt]
 688                  */
 689                 if (!memcmp(from, "mem=", 4)) {
 690                         if (to != command_line)
 691                                 to--;
 692                         if (!memcmp(from+4, "nopentium", 9)) {
 693                                 from += 9+4;
 694                                 clear_bit(X86_FEATURE_PSE, boot_cpu_data.x86_capability);
 695                                 disable_pse = 1;
 696                         } else {
 697                                 /* If the user specifies memory size, we
 698                                  * limit the BIOS-provided memory map to
 699                                  * that size. exactmap can be used to specify
 700                                  * the exact map. mem=number can be used to
 701                                  * trim the existing memory map.
 702                                  */
 703                                 unsigned long long mem_size;
 704
 705                                 mem_size = memparse(from+4, &from);
 706                                 limit_regions(mem_size);
 707                                 userdef=1;
 708                         }
 709                 }
 710
 711                 else if (!memcmp(from, "memmap=", 7)) {
 712                         if (to != command_line)
 713                                 to--;
 714                         if (!memcmp(from+7, "exactmap", 8)) {
 715                                 from += 8+7;
 716                                 e820.nr_map = 0;
 717                                 userdef = 1;
 718                         } else {
 719                                 /* If the user specifies memory size, we
 720                                  * limit the BIOS-provided memory map to
 721                                  * that size. exactmap can be used to specify
 722                                  * the exact map. mem=number can be used to
 723                                  * trim the existing memory map.
 724                                  */
 725                                 unsigned long long start_at, mem_size;
 726
 727                                 mem_size = memparse(from+7, &from);
 728                                 if (*from == '@') {
 729                                         start_at = memparse(from+1, &from);
 730                                         add_memory_region(start_at, mem_size, E820_RAM);
 731                                 } else if (*from == '#') {
 732                                         start_at = memparse(from+1, &from);
 733                                         add_memory_region(start_at, mem_size, E820_ACPI);
 734                                 } else if (*from == '$') {
 735                                         start_at = memparse(from+1, &from);
 736                                         add_memory_region(start_at, mem_size, E820_RESERVED);
 737                                 } else {
 738                                         limit_regions(mem_size);
 739                                         userdef=1;
 740                                 }
 741                         }
 742                 }
 743
 744                 else if (!memcmp(from, "noexec=", 7))
 745                         noexec_setup(from + 7);
 746
 747
 748 #ifdef  CONFIG_X86_SMP
 749                 /*
 750                  * If the BIOS enumerates physical processors before logical,
 751                  * maxcpus=N at enumeration-time can be used to disable HT.
 752                  */
 753                 else if (!memcmp(from, "maxcpus=", 8)) {
 754                         extern unsigned int maxcpus;
 755
 756                         maxcpus = simple_strtoul(from + 8, NULL, 0);
 757                 }
 758 #endif
 759
 760 #ifdef CONFIG_ACPI_BOOT
 761                 /* "acpi=off" disables both ACPI table parsing and interpreter */
 762                 else if (!memcmp(from, "acpi=off", 8)) {
 763                         disable_acpi();
 764                 }
 765
 766                 /* acpi=force to over-ride black-list */
 767                 else if (!memcmp(from, "acpi=force", 10)) {
 768                         acpi_force = 1;
 769                         acpi_ht = 1;
 770                         acpi_disabled = 0;
 771                 }
 772
 773                 /* acpi=strict disables out-of-spec workarounds */
 774                 else if (!memcmp(from, "acpi=strict", 11)) {
 775                         acpi_strict = 1;
 776                 }
 777
 778                 /* Limit ACPI just to boot-time to enable HT */
 779                 else if (!memcmp(from, "acpi=ht", 7)) {
 780                         if (!acpi_force)
 781                                 disable_acpi();
 782                         acpi_ht = 1;
 783                 }
 784
 785                 /* "pci=noacpi" disable ACPI IRQ routing and PCI scan */
 786                 else if (!memcmp(from, "pci=noacpi", 10)) {
 787                         acpi_disable_pci();
 788                 }
 789                 /* "acpi=noirq" disables ACPI interrupt routing */
 790                 else if (!memcmp(from, "acpi=noirq", 10)) {
 791                         acpi_noirq_set();
 792                 }
 793
 794                 else if (!memcmp(from, "acpi_sci=edge", 13))
 795                         acpi_sci_flags.trigger =  1;
 796
 797                 else if (!memcmp(from, "acpi_sci=level", 14))
 798                         acpi_sci_flags.trigger = 3;
 799
 800                 else if (!memcmp(from, "acpi_sci=high", 13))
 801                         acpi_sci_flags.polarity = 1;
 802
 803                 else if (!memcmp(from, "acpi_sci=low", 12))
 804                         acpi_sci_flags.polarity = 3;
 805
 806 #ifdef CONFIG_X86_IO_APIC
 807                 else if (!memcmp(from, "acpi_skip_timer_override", 24))
 808                         acpi_skip_timer_override = 1;
 809 #endif
 810
 811 #ifdef CONFIG_X86_LOCAL_APIC
 812                 /* disable IO-APIC */
 813                 else if (!memcmp(from, "noapic", 6))
 814                         disable_ioapic_setup();
 815 #endif /* CONFIG_X86_LOCAL_APIC */
 816 #endif /* CONFIG_ACPI_BOOT */
 817
 818                 /*
 819                  * highmem=size forces highmem to be exactly 'size' bytes.
 820                  * This works even on boxes that have no highmem otherwise.
 821                  * This also works to reduce highmem size on bigger boxes.
 822                  */
 823                 else if (!memcmp(from, "highmem=", 8))
 824                         highmem_pages = memparse(from+8, &from) >> PAGE_SHIFT;
 825
 826                 /*
 827                  * vmalloc=size forces the vmalloc area to be exactly 'size'
 828                  * bytes. This can be used to increase (or decrease) the
 829                  * vmalloc area - the default is 128m.
 830                  */
 831                 else if (!memcmp(from, "vmalloc=", 8))
 832                         __VMALLOC_RESERVE = memparse(from+8, &from);
 833
 834         next_char:
 835                 c = *(from++);
 836                 if (!c)
 837                         break;
 838                 if (COMMAND_LINE_SIZE <= ++len)
 839                         break;
 840                 *(to++) = c;
 841         }
 842         *to = '\0';
 843         *cmdline_p = command_line;
 844         if (userdef) {
 845                 printk(KERN_INFO "user-defined physical RAM map:\n");
 846                 print_memory_map("user");
 847         }
 848 }
 849
 850 /*
 851  * Callback for efi_memory_walk.
 852  */
 853 static int __init
 854 efi_find_max_pfn(unsigned long start, unsigned long end, void *arg)
 855 {
 856         unsigned long *max_pfn = arg, pfn;
 857
 858         if (start < end) {
 859                 pfn = PFN_UP(end -1);
 860                 if (pfn > *max_pfn)
 861                         *max_pfn = pfn;
 862         }
 863         return 0;
 864 }
 865
 866
 867 /*
 868  * Find the highest page frame number we have available
 869  */
 870 void __init find_max_pfn(void)
 871 {
 872         int i;
 873
 874         max_pfn = 0;
 875         if (efi_enabled) {
 876                 efi_memmap_walk(efi_find_max_pfn, &max_pfn);
 877                 return;
 878         }
 879
 880         for (i = 0; i < e820.nr_map; i++) {
 881                 unsigned long start, end;
 882                 /* RAM? */
 883                 if (e820.map[i].type != E820_RAM)
 884                         continue;
 885                 start = PFN_UP(e820.map[i].addr);
 886                 end = PFN_DOWN(e820.map[i].addr + e820.map[i].size);
 887                 if (start >= end)
 888                         continue;
 889                 if (end > max_pfn)
 890                         max_pfn = end;
 891         }
 892 }
 893
 894 /*
 895  * Determine low and high memory ranges:
 896  */
 897 unsigned long __init find_max_low_pfn(void)
 898 {
 899         unsigned long max_low_pfn;
 900
 901         max_low_pfn = max_pfn;
 902         if (max_low_pfn > MAXMEM_PFN) {
 903                 if (highmem_pages == -1)
 904                         highmem_pages = max_pfn - MAXMEM_PFN;
 905                 if (highmem_pages + MAXMEM_PFN < max_pfn)
 906                         max_pfn = MAXMEM_PFN + highmem_pages;
 907                 if (highmem_pages + MAXMEM_PFN > max_pfn) {
 908                         printk("only %luMB highmem pages available, ignoring highmem size of %uMB.\n", pages_to_mb(max_pfn - MAXMEM_PFN), pages_to_mb(highmem_pages));
 909                         highmem_pages = 0;
 910                 }
 911                 max_low_pfn = MAXMEM_PFN;
 912 #ifndef CONFIG_HIGHMEM
 913                 /* Maximum memory usable is what is directly addressable */
 914                 printk(KERN_WARNING "Warning only %ldMB will be used.\n",
 915                                         MAXMEM>>20);
 916                 if (max_pfn > MAX_NONPAE_PFN)
 917                         printk(KERN_WARNING "Use a PAE enabled kernel.\n");
 918                 else
 919                         printk(KERN_WARNING "Use a HIGHMEM enabled kernel.\n");
 920                 max_pfn = MAXMEM_PFN;
 921 #else /* !CONFIG_HIGHMEM */
 922 #ifndef CONFIG_X86_PAE
 923                 if (max_pfn > MAX_NONPAE_PFN) {
 924                         max_pfn = MAX_NONPAE_PFN;
 925                         printk(KERN_WARNING "Warning only 4GB will be used.\n");
 926                         printk(KERN_WARNING "Use a PAE enabled kernel.\n");
 927                 }
 928 #endif /* !CONFIG_X86_PAE */
 929 #endif /* !CONFIG_HIGHMEM */
 930         } else {
 931                 if (highmem_pages == -1)
 932                         highmem_pages = 0;
 933 #ifdef CONFIG_HIGHMEM
 934                 if (highmem_pages >= max_pfn) {
 935                         printk(KERN_ERR "highmem size specified (%uMB) is bigger than pages available (%luMB)!.\n", pages_to_mb(highmem_pages), pages_to_mb(max_pfn));
 936                         highmem_pages = 0;
 937                 }
 938                 if (highmem_pages) {
 939                         if (max_low_pfn-highmem_pages < 64*1024*1024/PAGE_SIZE){
 940                                 printk(KERN_ERR "highmem size %uMB results in smaller than 64MB lowmem, ignoring it.\n", pages_to_mb(highmem_pages));
 941                                 highmem_pages = 0;
 942                         }
 943                         max_low_pfn -= highmem_pages;
 944                 }
 945 #else
 946                 if (highmem_pages)
 947                         printk(KERN_ERR "ignoring highmem size on non-highmem kernel!\n");
 948 #endif
 949         }
 950         return max_low_pfn;
 951 }
 952
 953 /*
 954  * Free all available memory for boot time allocation.  Used
 955  * as a callback function by efi_memory_walk()
 956  */
 957
 958 static int __init
 959 free_available_memory(unsigned long start, unsigned long end, void *arg)
 960 {
 961         /* check max_low_pfn */
 962         if (start >= ((max_low_pfn + 1) << PAGE_SHIFT))
 963                 return 0;
 964         if (end >= ((max_low_pfn + 1) << PAGE_SHIFT))
 965                 end = (max_low_pfn + 1) << PAGE_SHIFT;
 966         if (start < end)
 967                 free_bootmem(start, end - start);
 968
 969         return 0;
 970 }
 971 /*
 972  * Register fully available low RAM pages with the bootmem allocator.
 973  */
 974 static void __init register_bootmem_low_pages(unsigned long max_low_pfn)
 975 {
 976         int i;
 977
 978         if (efi_enabled) {
 979                 efi_memmap_walk(free_available_memory, NULL);
 980                 return;
 981         }
 982         for (i = 0; i < e820.nr_map; i++) {
 983                 unsigned long curr_pfn, last_pfn, size;
 984                 /*
 985                  * Reserve usable low memory
 986                  */
 987                 if (e820.map[i].type != E820_RAM)
 988                         continue;
 989                 /*
 990                  * We are rounding up the start address of usable memory:
 991                  */
 992                 curr_pfn = PFN_UP(e820.map[i].addr);
 993                 if (curr_pfn >= max_low_pfn)
 994                         continue;
 995                 /*
 996                  * ... and at the end of the usable range downwards:
 997                  */
 998                 last_pfn = PFN_DOWN(e820.map[i].addr + e820.map[i].size);
 999
1000                 if (last_pfn > max_low_pfn)
1001                         last_pfn = max_low_pfn;
1002
1003                 /*
1004                  * .. finally, did all the rounding and playing
1005                  * around just make the area go away?
1006                  */
1007                 if (last_pfn <= curr_pfn)
1008                         continue;
1009
1010                 size = last_pfn - curr_pfn;
1011                 free_bootmem(PFN_PHYS(curr_pfn), PFN_PHYS(size));
1012         }
1013 }
1014
1015 /*
1016  * workaround for Dell systems that neglect to reserve EBDA
1017  */
1018 static void __init reserve_ebda_region(void)
1019 {
1020         unsigned int addr;
1021         addr = get_bios_ebda();
1022         if (addr)
1023                 reserve_bootmem(addr, PAGE_SIZE);
1024 }
1025
1026 #ifndef CONFIG_NEED_MULTIPLE_NODES
1027 void __init setup_bootmem_allocator(void);
1028 static unsigned long __init setup_memory(void)
1029 {
1030         /*
1031          * partially used pages are not usable - thus
1032          * we are rounding upwards:
1033          */
1034         min_low_pfn = PFN_UP(init_pg_tables_end);
1035
1036         find_max_pfn();
1037
1038         max_low_pfn = find_max_low_pfn();
1039
1040 #ifdef CONFIG_HIGHMEM
1041         highstart_pfn = highend_pfn = max_pfn;
1042         if (max_pfn > max_low_pfn) {
1043                 highstart_pfn = max_low_pfn;
1044         }
1045         printk(KERN_NOTICE "%ldMB HIGHMEM available.\n",
1046                 pages_to_mb(highend_pfn - highstart_pfn));
1047 #endif
1048         printk(KERN_NOTICE "%ldMB LOWMEM available.\n",
1049                         pages_to_mb(max_low_pfn));
1050
1051         setup_bootmem_allocator();
1052
1053         return max_low_pfn;
1054 }
1055
1056 void __init zone_sizes_init(void)
1057 {
1058         unsigned long zones_size[MAX_NR_ZONES] = {0, 0, 0};
1059         unsigned int max_dma, low;
1060
1061         max_dma = virt_to_phys((char *)MAX_DMA_ADDRESS) >> PAGE_SHIFT;
1062         low = max_low_pfn;
1063
1064         if (low < max_dma)
1065                 zones_size[ZONE_DMA] = low;
1066         else {
1067                 zones_size[ZONE_DMA] = max_dma;
1068                 zones_size[ZONE_NORMAL] = low - max_dma;
1069 #ifdef CONFIG_HIGHMEM
1070                 zones_size[ZONE_HIGHMEM] = highend_pfn - low;
1071 #endif
1072         }
1073         free_area_init(zones_size);
1074 }
1075 #else
1076 extern unsigned long __init setup_memory(void);
1077 extern void zone_sizes_init(void);
1078 #endif /* !CONFIG_NEED_MULTIPLE_NODES */
1079
1080 void __init setup_bootmem_allocator(void)
1081 {
1082         unsigned long bootmap_size;
1083         /*
1084          * Initialize the boot-time allocator (with low memory only):
1085          */
1086         bootmap_size = init_bootmem(min_low_pfn, max_low_pfn);
1087
1088         register_bootmem_low_pages(max_low_pfn);
1089
1090         /*
1091          * Reserve the bootmem bitmap itself as well. We do this in two
1092          * steps (first step was init_bootmem()) because this catches
1093          * the (very unlikely) case of us accidentally initializing the
1094          * bootmem allocator with an invalid RAM area.
1095          */
1096         reserve_bootmem(HIGH_MEMORY, (PFN_PHYS(min_low_pfn) +
1097                          bootmap_size + PAGE_SIZE-1) - (HIGH_MEMORY));
1098
1099         /*
1100          * reserve physical page 0 - it's a special BIOS page on many boxes,
1101          * enabling clean reboots, SMP operation, laptop functions.
1102          */
1103         reserve_bootmem(0, PAGE_SIZE);
1104
1105         /* reserve EBDA region, it's a 4K region */
1106         reserve_ebda_region();
1107
1108     /* could be an AMD 768MPX chipset. Reserve a page  before VGA to prevent
1109        PCI prefetch into it (errata #56). Usually the page is reserved anyways,
1110        unless you have no PS/2 mouse plugged in. */
1111         if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD &&
1112             boot_cpu_data.x86 == 6)
1113              reserve_bootmem(0xa0000 - 4096, 4096);
1114
1115 #ifdef CONFIG_SMP
1116         /*
1117          * But first pinch a few for the stack/trampoline stuff
1118          * FIXME: Don't need the extra page at 4K, but need to fix
1119          * trampoline before removing it. (see the GDT stuff)
1120          */
1121         reserve_bootmem(PAGE_SIZE, PAGE_SIZE);
1122 #endif
1123 #ifdef CONFIG_ACPI_SLEEP
1124         /*
1125          * Reserve low memory region for sleep support.
1126          */
1127         acpi_reserve_bootmem();
1128 #endif
1129 #ifdef CONFIG_X86_FIND_SMP_CONFIG
1130         /*
1131          * Find and reserve possible boot-time SMP configuration:
1132          */
1133         find_smp_config();
1134 #endif
1135
1136 #ifdef CONFIG_BLK_DEV_INITRD
1137         if (LOADER_TYPE && INITRD_START) {
1138                 if (INITRD_START + INITRD_SIZE <= (max_low_pfn << PAGE_SHIFT)) {
1139                         reserve_bootmem(INITRD_START, INITRD_SIZE);
1140                         initrd_start =
1141                                 INITRD_START ? INITRD_START + PAGE_OFFSET : 0;
1142                         initrd_end = initrd_start+INITRD_SIZE;
1143                 }
1144                 else {
1145                         printk(KERN_ERR "initrd extends beyond end of memory "
1146                             "(0x%08lx > 0x%08lx)\ndisabling initrd\n",
1147                             INITRD_START + INITRD_SIZE,
1148                             max_low_pfn << PAGE_SHIFT);
1149                         initrd_start = 0;
1150                 }
1151         }
1152 #endif
1153 }
1154
1155 /*
1156  * The node 0 pgdat is initialized before all of these because
1157  * it's needed for bootmem.  node>0 pgdats have their virtual
1158  * space allocated before the pagetables are in place to access
1159  * them, so they can't be cleared then.
1160  *
1161  * This should all compile down to nothing when NUMA is off.
1162  */
1163 void __init remapped_pgdat_init(void)
1164 {
1165         int nid;
1166
1167         for_each_online_node(nid) {
1168                 if (nid != 0)
1169                         memset(NODE_DATA(nid), 0, sizeof(struct pglist_data));
1170         }
1171 }
1172
1173 /*
1174  * Request address space for all standard RAM and ROM resources
1175  * and also for regions reported as reserved by the e820.
1176  */
1177 static void __init
1178 legacy_init_iomem_resources(struct resource *code_resource, struct resource *data_resource)
1179 {
1180         int i;
1181
1182         probe_roms();
1183         for (i = 0; i < e820.nr_map; i++) {
1184                 struct resource *res;
1185                 if (e820.map[i].addr + e820.map[i].size > 0x100000000ULL)
1186                         continue;
1187                 res = alloc_bootmem_low(sizeof(struct resource));
1188                 switch (e820.map[i].type) {
1189                 case E820_RAM:  res->name = "System RAM"; break;
1190                 case E820_ACPI: res->name = "ACPI Tables"; break;
1191                 case E820_NVS:  res->name = "ACPI Non-volatile Storage"; break;
1192                 default:        res->name = "reserved";
1193                 }
1194                 res->start = e820.map[i].addr;
1195                 res->end = res->start + e820.map[i].size - 1;
1196                 res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
1197                 request_resource(&iomem_resource, res);
1198                 if (e820.map[i].type == E820_RAM) {
1199                         /*
1200                          *  We don't know which RAM region contains kernel data,
1201                          *  so we try it repeatedly and let the resource manager
1202                          *  test it.
1203                          */
1204                         request_resource(res, code_resource);
1205                         request_resource(res, data_resource);
1206                 }
1207         }
1208 }
1209
1210 /*
1211  * Request address space for all standard resources
1212  */
1213 static void __init register_memory(void)
1214 {
1215         unsigned long gapstart, gapsize;
1216         unsigned long long last;
1217         int           i;
1218
1219         if (efi_enabled)
1220                 efi_initialize_iomem_resources(&code_resource, &data_resource);
1221         else
1222                 legacy_init_iomem_resources(&code_resource, &data_resource);
1223
1224         /* EFI systems may still have VGA */
1225         request_resource(&iomem_resource, &video_ram_resource);
1226
1227         /* request I/O space for devices used on all i[345]86 PCs */
1228         for (i = 0; i < STANDARD_IO_RESOURCES; i++)
1229                 request_resource(&ioport_resource, &standard_io_resources[i]);
1230
1231         /*
1232          * Search for the bigest gap in the low 32 bits of the e820
1233          * memory space.
1234          */
1235         last = 0x100000000ull;
1236         gapstart = 0x10000000;
1237         gapsize = 0x400000;
1238         i = e820.nr_map;
1239         while (--i >= 0) {
1240                 unsigned long long start = e820.map[i].addr;
1241                 unsigned long long end = start + e820.map[i].size;
1242
1243                 /*
1244                  * Since "last" is at most 4GB, we know we'll
1245                  * fit in 32 bits if this condition is true
1246                  */
1247                 if (last > end) {
1248                         unsigned long gap = last - end;
1249
1250                         if (gap > gapsize) {
1251                                 gapsize = gap;
1252                                 gapstart = end;
1253                         }
1254                 }
1255                 if (start < last)
1256                         last = start;
1257         }
1258
1259         /*
1260          * Start allocating dynamic PCI memory a bit into the gap,
1261          * aligned up to the nearest megabyte.
1262          *
1263          * Question: should we try to pad it up a bit (do something
1264          * like " + (gapsize >> 3)" in there too?). We now have the
1265          * technology.
1266          */
1267         pci_mem_start = (gapstart + 0xfffff) & ~0xfffff;
1268
1269         printk("Allocating PCI resources starting at %08lx (gap: %08lx:%08lx)\n",
1270                 pci_mem_start, gapstart, gapsize);
1271 }
1272
1273 /* Use inline assembly to define this because the nops are defined
1274    as inline assembly strings in the include files and we cannot
1275    get them easily into strings. */
1276 asm("\t.data\nintelnops: "
1277     GENERIC_NOP1 GENERIC_NOP2 GENERIC_NOP3 GENERIC_NOP4 GENERIC_NOP5 GENERIC_NOP6
1278     GENERIC_NOP7 GENERIC_NOP8);
1279 asm("\t.data\nk8nops: "
1280     K8_NOP1 K8_NOP2 K8_NOP3 K8_NOP4 K8_NOP5 K8_NOP6
1281     K8_NOP7 K8_NOP8);
1282 asm("\t.data\nk7nops: "
1283     K7_NOP1 K7_NOP2 K7_NOP3 K7_NOP4 K7_NOP5 K7_NOP6
1284     K7_NOP7 K7_NOP8);
1285
1286 extern unsigned char intelnops[], k8nops[], k7nops[];
1287 static unsigned char *intel_nops[ASM_NOP_MAX+1] = {
1288      NULL,
1289      intelnops,
1290      intelnops + 1,
1291      intelnops + 1 + 2,
1292      intelnops + 1 + 2 + 3,
1293      intelnops + 1 + 2 + 3 + 4,
1294      intelnops + 1 + 2 + 3 + 4 + 5,
1295      intelnops + 1 + 2 + 3 + 4 + 5 + 6,
1296      intelnops + 1 + 2 + 3 + 4 + 5 + 6 + 7,
1297 };
1298 static unsigned char *k8_nops[ASM_NOP_MAX+1] = {
1299      NULL,
1300      k8nops,
1301      k8nops + 1,
1302      k8nops + 1 + 2,
1303      k8nops + 1 + 2 + 3,
1304      k8nops + 1 + 2 + 3 + 4,
1305      k8nops + 1 + 2 + 3 + 4 + 5,
1306      k8nops + 1 + 2 + 3 + 4 + 5 + 6,
1307      k8nops + 1 + 2 + 3 + 4 + 5 + 6 + 7,
1308 };
1309 static unsigned char *k7_nops[ASM_NOP_MAX+1] = {
1310      NULL,
1311      k7nops,
1312      k7nops + 1,
1313      k7nops + 1 + 2,
1314      k7nops + 1 + 2 + 3,
1315      k7nops + 1 + 2 + 3 + 4,
1316      k7nops + 1 + 2 + 3 + 4 + 5,
1317      k7nops + 1 + 2 + 3 + 4 + 5 + 6,
1318      k7nops + 1 + 2 + 3 + 4 + 5 + 6 + 7,
1319 };
1320 static struct nop {
1321      int cpuid;
1322      unsigned char **noptable;
1323 } noptypes[] = {
1324      { X86_FEATURE_K8, k8_nops },
1325      { X86_FEATURE_K7, k7_nops },
1326      { -1, NULL }
1327 };
1328
1329 /* Replace instructions with better alternatives for this CPU type.
1330
1331    This runs before SMP is initialized to avoid SMP problems with
1332    self modifying code. This implies that assymetric systems where
1333    APs have less capabilities than the boot processor are not handled.
1334    In this case boot with "noreplacement". */
1335 void apply_alternatives(void *start, void *end)
1336 {
1337         struct alt_instr *a;
1338         int diff, i, k;
1339         unsigned char **noptable = intel_nops;
1340         for (i = 0; noptypes[i].cpuid >= 0; i++) {
1341                 if (boot_cpu_has(noptypes[i].cpuid)) {
1342                         noptable = noptypes[i].noptable;
1343                         break;
1344                 }
1345         }
1346         for (a = start; (void *)a < end; a++) {
1347                 if (!boot_cpu_has(a->cpuid))
1348                         continue;
1349                 BUG_ON(a->replacementlen > a->instrlen);
1350                 memcpy(a->instr, a->replacement, a->replacementlen);
1351                 diff = a->instrlen - a->replacementlen;
1352                 /* Pad the rest with nops */
1353                 for (i = a->replacementlen; diff > 0; diff -= k, i += k) {
1354                         k = diff;
1355                         if (k > ASM_NOP_MAX)
1356                                 k = ASM_NOP_MAX;
1357                         memcpy(a->instr + i, noptable[k], k);
1358                 }
1359         }
1360 }
1361
1362 static int no_replacement __initdata = 0;
1363
1364 void __init alternative_instructions(void)
1365 {
1366         extern struct alt_instr __alt_instructions[], __alt_instructions_end[];
1367         if (no_replacement)
1368                 return;
1369         apply_alternatives(__alt_instructions, __alt_instructions_end);
1370 }
1371
1372 static int __init noreplacement_setup(char *s)
1373 {
1374      no_replacement = 1;
1375      return 0;
1376 }
1377
1378 __setup("noreplacement", noreplacement_setup);
1379
1380 static char * __init machine_specific_memory_setup(void);
1381
1382 #ifdef CONFIG_MCA
1383 static void set_mca_bus(int x)
1384 {
1385         MCA_bus = x;
1386 }
1387 #else
1388 static void set_mca_bus(int x) { }
1389 #endif
1390
1391 /*
1392  * Determine if we were loaded by an EFI loader.  If so, then we have also been
1393  * passed the efi memmap, systab, etc., so we should use these data structures
1394  * for initialization.  Note, the efi init code path is determined by the
1395  * global efi_enabled. This allows the same kernel image to be used on existing
1396  * systems (with a traditional BIOS) as well as on EFI systems.
1397  */
1398 void __init setup_arch(char **cmdline_p)
1399 {
1400         unsigned long max_low_pfn;
1401
1402         memcpy(&boot_cpu_data, &new_cpu_data, sizeof(new_cpu_data));
1403         pre_setup_arch_hook();
1404         early_cpu_init();
1405
1406         /*
1407          * FIXME: This isn't an official loader_type right
1408          * now but does currently work with elilo.
1409          * If we were configured as an EFI kernel, check to make
1410          * sure that we were loaded correctly from elilo and that
1411          * the system table is valid.  If not, then initialize normally.
1412          */
1413 #ifdef CONFIG_EFI
1414         if ((LOADER_TYPE == 0x50) && EFI_SYSTAB)
1415                 efi_enabled = 1;
1416 #endif
1417
1418         ROOT_DEV = old_decode_dev(ORIG_ROOT_DEV);
1419         drive_info = DRIVE_INFO;
1420         screen_info = SCREEN_INFO;
1421         edid_info = EDID_INFO;
1422         apm_info.bios = APM_BIOS_INFO;
1423         ist_info = IST_INFO;
1424         saved_videomode = VIDEO_MODE;
1425         if( SYS_DESC_TABLE.length != 0 ) {
1426                 set_mca_bus(SYS_DESC_TABLE.table[3] & 0x2);
1427                 machine_id = SYS_DESC_TABLE.table[0];
1428                 machine_submodel_id = SYS_DESC_TABLE.table[1];
1429                 BIOS_revision = SYS_DESC_TABLE.table[2];
1430         }
1431         bootloader_type = LOADER_TYPE;
1432
1433 #ifdef CONFIG_BLK_DEV_RAM
1434         rd_image_start = RAMDISK_FLAGS & RAMDISK_IMAGE_START_MASK;
1435         rd_prompt = ((RAMDISK_FLAGS & RAMDISK_PROMPT_FLAG) != 0);
1436         rd_doload = ((RAMDISK_FLAGS & RAMDISK_LOAD_FLAG) != 0);
1437 #endif
1438         ARCH_SETUP
1439         if (efi_enabled)
1440                 efi_init();
1441         else {
1442                 printk(KERN_INFO "BIOS-provided physical RAM map:\n");
1443                 print_memory_map(machine_specific_memory_setup());
1444         }
1445
1446         copy_edd();
1447
1448         if (!MOUNT_ROOT_RDONLY)
1449                 root_mountflags &= ~MS_RDONLY;
1450         init_mm.start_code = (unsigned long) _text;
1451         init_mm.end_code = (unsigned long) _etext;
1452         init_mm.end_data = (unsigned long) _edata;
1453         init_mm.brk = init_pg_tables_end + PAGE_OFFSET;
1454
1455         code_resource.start = virt_to_phys(_text);
1456         code_resource.end = virt_to_phys(_etext)-1;
1457         data_resource.start = virt_to_phys(_etext);
1458         data_resource.end = virt_to_phys(_edata)-1;
1459
1460         parse_cmdline_early(cmdline_p);
1461
1462         max_low_pfn = setup_memory();
1463
1464         /*
1465          * NOTE: before this point _nobody_ is allowed to allocate
1466          * any memory using the bootmem allocator.  Although the
1467          * alloctor is now initialised only the first 8Mb of the kernel
1468          * virtual address space has been mapped.  All allocations before
1469          * paging_init() has completed must use the alloc_bootmem_low_pages()
1470          * variant (which allocates DMA'able memory) and care must be taken
1471          * not to exceed the 8Mb limit.
1472          */
1473
1474 #ifdef CONFIG_SMP
1475         smp_alloc_memory(); /* AP processor realmode stacks in low memory*/
1476 #endif
1477         paging_init();
1478         remapped_pgdat_init();
1479         sparse_init();
1480         zone_sizes_init();
1481
1482         /*
1483          * NOTE: at this point the bootmem allocator is fully available.
1484          */
1485
1486 #ifdef CONFIG_EARLY_PRINTK
1487         {
1488                 char *s = strstr(*cmdline_p, "earlyprintk=");
1489                 if (s) {
1490                         extern void setup_early_printk(char *);
1491
1492                         setup_early_printk(s);
1493                         printk("early console enabled\n");
1494                 }
1495         }
1496 #endif
1497
1498
1499         dmi_scan_machine();
1500
1501 #ifdef CONFIG_X86_GENERICARCH
1502         generic_apic_probe(*cmdline_p);
1503 #endif
1504         if (efi_enabled)
1505                 efi_map_memmap();
1506
1507 #ifdef CONFIG_ACPI_BOOT
1508         /*
1509          * Parse the ACPI tables for possible boot-time SMP configuration.
1510          */
1511         acpi_boot_table_init();
1512         acpi_boot_init();
1513 #endif
1514
1515 #ifdef CONFIG_X86_LOCAL_APIC
1516         if (smp_found_config)
1517                 get_smp_config();
1518 #endif
1519
1520         register_memory();
1521
1522 #ifdef CONFIG_VT
1523 #if defined(CONFIG_VGA_CONSOLE)
1524         if (!efi_enabled || (efi_mem_type(0xa0000) != EFI_CONVENTIONAL_MEMORY))
1525                 conswitchp = &vga_con;
1526 #elif defined(CONFIG_DUMMY_CONSOLE)
1527         conswitchp = &dummy_con;
1528 #endif
1529 #endif
1530 }
1531
1532 #include "setup_arch_post.h"
1533 /*
1534  * Local Variables:
1535  * mode:c
1536  * c-file-style:"k&r"
1537  * c-basic-offset:8
1538  * End:
1539  */