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