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