arch/i386/kernel/setup.c

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