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