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