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