arch/i386/kernel/setup.c

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