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