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 static void __init parse_cmdline_early (char ** cmdline_p)
 669 {
 670         char c = ' ', *to = command_line, *from = saved_command_line;
 671         int len = 0;
 672         int userdef = 0;
 673
 674         /* Save unparsed command line copy for /proc/cmdline */
 675         saved_command_line[COMMAND_LINE_SIZE-1] = '\0';
 676
 677         for (;;) {
 678                 if (c != ' ')
 679                         goto next_char;
 680                 /*
 681                  * "mem=nopentium" disables the 4MB page tables.
 682                  * "mem=XXX[kKmM]" defines a memory region from HIGH_MEM
 683                  * to <mem>, overriding the bios size.
 684                  * "memmap=XXX[KkmM]@XXX[KkmM]" defines a memory region from
 685                  * <start> to <start>+<mem>, overriding the bios size.
 686                  *
 687                  * HPA tells me bootloaders need to parse mem=, so no new
 688                  * option should be mem=  [also see Documentation/i386/boot.txt]
 689                  */
 690                 if (!memcmp(from, "mem=", 4)) {
 691                         if (to != command_line)
 692                                 to--;
 693                         if (!memcmp(from+4, "nopentium", 9)) {
 694                                 from += 9+4;
 695                                 clear_bit(X86_FEATURE_PSE, boot_cpu_data.x86_capability);
 696                                 disable_pse = 1;
 697                         } else {
 698                                 /* If the user specifies memory size, we
 699                                  * limit the BIOS-provided memory map to
 700                                  * that size. exactmap can be used to specify
 701                                  * the exact map. mem=number can be used to
 702                                  * trim the existing memory map.
 703                                  */
 704                                 unsigned long long mem_size;
 705
 706                                 mem_size = memparse(from+4, &from);
 707                                 limit_regions(mem_size);
 708                                 userdef=1;
 709                         }
 710                 }
 711
 712                 else if (!memcmp(from, "memmap=", 7)) {
 713                         if (to != command_line)
 714                                 to--;
 715                         if (!memcmp(from+7, "exactmap", 8)) {
 716                                 /* If we are doing a crash dump, we
 717                                  * still need to know the real mem
 718                                  * size.
 719                                  */
 720                                 set_saved_max_pfn();
 721                                 from += 8+7;
 722                                 e820.nr_map = 0;
 723                                 userdef = 1;
 724                         } else {
 725                                 /* If the user specifies memory size, we
 726                                  * limit the BIOS-provided memory map to
 727                                  * that size. exactmap can be used to specify
 728                                  * the exact map. mem=number can be used to
 729                                  * trim the existing memory map.
 730                                  */
 731                                 unsigned long long start_at, mem_size;
 732
 733                                 mem_size = memparse(from+7, &from);
 734                                 if (*from == '@') {
 735                                         start_at = memparse(from+1, &from);
 736                                         add_memory_region(start_at, mem_size, E820_RAM);
 737                                 } else if (*from == '#') {
 738                                         start_at = memparse(from+1, &from);
 739                                         add_memory_region(start_at, mem_size, E820_ACPI);
 740                                 } else if (*from == '$') {
 741                                         start_at = memparse(from+1, &from);
 742                                         add_memory_region(start_at, mem_size, E820_RESERVED);
 743                                 } else {
 744                                         limit_regions(mem_size);
 745                                         userdef=1;
 746                                 }
 747                         }
 748                 }
 749
 750                 else if (!memcmp(from, "noexec=", 7))
 751                         noexec_setup(from + 7);
 752
 753
 754 #ifdef  CONFIG_X86_SMP
 755                 /*
 756                  * If the BIOS enumerates physical processors before logical,
 757                  * maxcpus=N at enumeration-time can be used to disable HT.
 758                  */
 759                 else if (!memcmp(from, "maxcpus=", 8)) {
 760                         extern unsigned int maxcpus;
 761
 762                         maxcpus = simple_strtoul(from + 8, NULL, 0);
 763                 }
 764 #endif
 765
 766 #ifdef CONFIG_ACPI_BOOT
 767                 /* "acpi=off" disables both ACPI table parsing and interpreter */
 768                 else if (!memcmp(from, "acpi=off", 8)) {
 769                         disable_acpi();
 770                 }
 771
 772                 /* acpi=force to over-ride black-list */
 773                 else if (!memcmp(from, "acpi=force", 10)) {
 774                         acpi_force = 1;
 775                         acpi_ht = 1;
 776                         acpi_disabled = 0;
 777                 }
 778
 779                 /* acpi=strict disables out-of-spec workarounds */
 780                 else if (!memcmp(from, "acpi=strict", 11)) {
 781                         acpi_strict = 1;
 782                 }
 783
 784                 /* Limit ACPI just to boot-time to enable HT */
 785                 else if (!memcmp(from, "acpi=ht", 7)) {
 786                         if (!acpi_force)
 787                                 disable_acpi();
 788                         acpi_ht = 1;
 789                 }
 790
 791                 /* "pci=noacpi" disable ACPI IRQ routing and PCI scan */
 792                 else if (!memcmp(from, "pci=noacpi", 10)) {
 793                         acpi_disable_pci();
 794                 }
 795                 /* "acpi=noirq" disables ACPI interrupt routing */
 796                 else if (!memcmp(from, "acpi=noirq", 10)) {
 797                         acpi_noirq_set();
 798                 }
 799
 800                 else if (!memcmp(from, "acpi_sci=edge", 13))
 801                         acpi_sci_flags.trigger =  1;
 802
 803                 else if (!memcmp(from, "acpi_sci=level", 14))
 804                         acpi_sci_flags.trigger = 3;
 805
 806                 else if (!memcmp(from, "acpi_sci=high", 13))
 807                         acpi_sci_flags.polarity = 1;
 808
 809                 else if (!memcmp(from, "acpi_sci=low", 12))
 810                         acpi_sci_flags.polarity = 3;
 811
 812 #ifdef CONFIG_X86_IO_APIC
 813                 else if (!memcmp(from, "acpi_skip_timer_override", 24))
 814                         acpi_skip_timer_override = 1;
 815 #endif
 816
 817 #ifdef CONFIG_X86_LOCAL_APIC
 818                 /* disable IO-APIC */
 819                 else if (!memcmp(from, "noapic", 6))
 820                         disable_ioapic_setup();
 821 #endif /* CONFIG_X86_LOCAL_APIC */
 822 #endif /* CONFIG_ACPI_BOOT */
 823
 824                 /*
 825                  * highmem=size forces highmem to be exactly 'size' bytes.
 826                  * This works even on boxes that have no highmem otherwise.
 827                  * This also works to reduce highmem size on bigger boxes.
 828                  */
 829                 else if (!memcmp(from, "highmem=", 8))
 830                         highmem_pages = memparse(from+8, &from) >> PAGE_SHIFT;
 831
 832                 if (!memcmp(from, "dump", 4))
 833                         dump_enabled = 1;
 834
 835                 /*
 836                  * vmalloc=size forces the vmalloc area to be exactly 'size'
 837                  * bytes. This can be used to increase (or decrease) the
 838                  * vmalloc area - the default is 128m.
 839                  */
 840                 else if (!memcmp(from, "vmalloc=", 8))
 841                         __VMALLOC_RESERVE = memparse(from+8, &from);
 842
 843         next_char:
 844                 c = *(from++);
 845                 if (!c)
 846                         break;
 847                 if (COMMAND_LINE_SIZE <= ++len)
 848                         break;
 849                 *(to++) = c;
 850         }
 851         *to = '\0';
 852         *cmdline_p = command_line;
 853         if (userdef) {
 854                 printk(KERN_INFO "user-defined physical RAM map:\n");
 855                 print_memory_map("user");
 856         }
 857 }
 858
 859 /*
 860  * Callback for efi_memory_walk.
 861  */
 862 static int __init
 863 efi_find_max_pfn(unsigned long start, unsigned long end, void *arg)
 864 {
 865         unsigned long *max_pfn = arg, pfn;
 866
 867         if (start < end) {
 868                 pfn = PFN_UP(end -1);
 869                 if (pfn > *max_pfn)
 870                         *max_pfn = pfn;
 871         }
 872         return 0;
 873 }
 874
 875
 876 /*
 877  * Find the highest page frame number we have available
 878  */
 879 void __init find_max_pfn(void)
 880 {
 881         int i;
 882
 883         max_pfn = 0;
 884         if (efi_enabled) {
 885                 efi_memmap_walk(efi_find_max_pfn, &max_pfn);
 886                 return;
 887         }
 888
 889         for (i = 0; i < e820.nr_map; i++) {
 890                 unsigned long start, end;
 891                 /* RAM? */
 892                 if (e820.map[i].type != E820_RAM)
 893                         continue;
 894                 start = PFN_UP(e820.map[i].addr);
 895                 end = PFN_DOWN(e820.map[i].addr + e820.map[i].size);
 896                 if (start >= end)
 897                         continue;
 898                 if (end > max_pfn)
 899                         max_pfn = end;
 900         }
 901 }
 902
 903 /*
 904  * Determine low and high memory ranges:
 905  */
 906 unsigned long __init find_max_low_pfn(void)
 907 {
 908         unsigned long max_low_pfn;
 909
 910         max_low_pfn = max_pfn;
 911         if (max_low_pfn > MAXMEM_PFN) {
 912                 if (highmem_pages == -1)
 913                         highmem_pages = max_pfn - MAXMEM_PFN;
 914                 if (highmem_pages + MAXMEM_PFN < max_pfn)
 915                         max_pfn = MAXMEM_PFN + highmem_pages;
 916                 if (highmem_pages + MAXMEM_PFN > max_pfn) {
 917                         printk("only %luMB highmem pages available, ignoring highmem size of %uMB.\n", pages_to_mb(max_pfn - MAXMEM_PFN), pages_to_mb(highmem_pages));
 918                         highmem_pages = 0;
 919                 }
 920                 max_low_pfn = MAXMEM_PFN;
 921 #ifndef CONFIG_HIGHMEM
 922                 /* Maximum memory usable is what is directly addressable */
 923                 printk(KERN_WARNING "Warning only %ldMB will be used.\n",
 924                                         MAXMEM>>20);
 925                 if (max_pfn > MAX_NONPAE_PFN)
 926                         printk(KERN_WARNING "Use a PAE enabled kernel.\n");
 927                 else
 928                         printk(KERN_WARNING "Use a HIGHMEM enabled kernel.\n");
 929                 max_pfn = MAXMEM_PFN;
 930 #else /* !CONFIG_HIGHMEM */
 931 #ifndef CONFIG_X86_PAE
 932                 if (max_pfn > MAX_NONPAE_PFN) {
 933                         max_pfn = MAX_NONPAE_PFN;
 934                         printk(KERN_WARNING "Warning only 4GB will be used.\n");
 935                         printk(KERN_WARNING "Use a PAE enabled kernel.\n");
 936                 }
 937 #endif /* !CONFIG_X86_PAE */
 938 #endif /* !CONFIG_HIGHMEM */
 939         } else {
 940                 if (highmem_pages == -1)
 941                         highmem_pages = 0;
 942 #ifdef CONFIG_HIGHMEM
 943                 if (highmem_pages >= max_pfn) {
 944                         printk(KERN_ERR "highmem size specified (%uMB) is bigger than pages available (%luMB)!.\n", pages_to_mb(highmem_pages), pages_to_mb(max_pfn));
 945                         highmem_pages = 0;
 946                 }
 947                 if (highmem_pages) {
 948                         if (max_low_pfn-highmem_pages < 64*1024*1024/PAGE_SIZE){
 949                                 printk(KERN_ERR "highmem size %uMB results in smaller than 64MB lowmem, ignoring it.\n", pages_to_mb(highmem_pages));
 950                                 highmem_pages = 0;
 951                         }
 952                         max_low_pfn -= highmem_pages;
 953                 }
 954 #else
 955                 if (highmem_pages)
 956                         printk(KERN_ERR "ignoring highmem size on non-highmem kernel!\n");
 957 #endif
 958         }
 959         return max_low_pfn;
 960 }
 961
 962 /*
 963  * Free all available memory for boot time allocation.  Used
 964  * as a callback function by efi_memory_walk()
 965  */
 966
 967 static int __init
 968 free_available_memory(unsigned long start, unsigned long end, void *arg)
 969 {
 970         /* check max_low_pfn */
 971         if (start >= ((max_low_pfn + 1) << PAGE_SHIFT))
 972                 return 0;
 973         if (end >= ((max_low_pfn + 1) << PAGE_SHIFT))
 974                 end = (max_low_pfn + 1) << PAGE_SHIFT;
 975         if (start < end)
 976                 free_bootmem(start, end - start);
 977
 978         return 0;
 979 }
 980 /*
 981  * Register fully available low RAM pages with the bootmem allocator.
 982  */
 983 static void __init register_bootmem_low_pages(unsigned long max_low_pfn)
 984 {
 985         int i;
 986
 987         if (efi_enabled) {
 988                 efi_memmap_walk(free_available_memory, NULL);
 989                 return;
 990         }
 991         for (i = 0; i < e820.nr_map; i++) {
 992                 unsigned long curr_pfn, last_pfn, size;
 993                 /*
 994                  * Reserve usable low memory
 995                  */
 996                 if (e820.map[i].type != E820_RAM)
 997                         continue;
 998                 /*
 999                  * We are rounding up the start address of usable memory:
1000                  */
1001                 curr_pfn = PFN_UP(e820.map[i].addr);
1002                 if (curr_pfn >= max_low_pfn)
1003                         continue;
1004                 /*
1005                  * ... and at the end of the usable range downwards:
1006                  */
1007                 last_pfn = PFN_DOWN(e820.map[i].addr + e820.map[i].size);
1008
1009                 if (last_pfn > max_low_pfn)
1010                         last_pfn = max_low_pfn;
1011
1012                 /*
1013                  * .. finally, did all the rounding and playing
1014                  * around just make the area go away?
1015                  */
1016                 if (last_pfn <= curr_pfn)
1017                         continue;
1018
1019                 size = last_pfn - curr_pfn;
1020                 free_bootmem(PFN_PHYS(curr_pfn), PFN_PHYS(size));
1021         }
1022 }
1023
1024 /*
1025  * workaround for Dell systems that neglect to reserve EBDA
1026  */
1027 static void __init reserve_ebda_region(void)
1028 {
1029         unsigned int addr;
1030         addr = get_bios_ebda();
1031         if (addr)
1032                 reserve_bootmem(addr, PAGE_SIZE);
1033 }
1034
1035 #ifndef CONFIG_DISCONTIGMEM
1036 void __init setup_bootmem_allocator(void);
1037 static unsigned long __init setup_memory(void)
1038 {
1039         /*
1040          * partially used pages are not usable - thus
1041          * we are rounding upwards:
1042          */
1043         min_low_pfn = PFN_UP(init_pg_tables_end);
1044
1045         find_max_pfn();
1046
1047         max_low_pfn = find_max_low_pfn();
1048
1049 #ifdef CONFIG_HIGHMEM
1050         highstart_pfn = highend_pfn = max_pfn;
1051         if (max_pfn > max_low_pfn) {
1052                 highstart_pfn = max_low_pfn;
1053         }
1054         printk(KERN_NOTICE "%ldMB HIGHMEM available.\n",
1055                 pages_to_mb(highend_pfn - highstart_pfn));
1056 #endif
1057         printk(KERN_NOTICE "%ldMB LOWMEM available.\n",
1058                         pages_to_mb(max_low_pfn));
1059
1060         setup_bootmem_allocator();
1061
1062         return max_low_pfn;
1063 }
1064
1065 void __init zone_sizes_init(void)
1066 {
1067         unsigned long zones_size[MAX_NR_ZONES] = {0, 0, 0};
1068         unsigned int max_dma, low;
1069
1070         max_dma = virt_to_phys((char *)MAX_DMA_ADDRESS) >> PAGE_SHIFT;
1071         low = max_low_pfn;
1072
1073         if (low < max_dma)
1074                 zones_size[ZONE_DMA] = low;
1075         else {
1076                 zones_size[ZONE_DMA] = max_dma;
1077                 zones_size[ZONE_NORMAL] = low - max_dma;
1078 #ifdef CONFIG_HIGHMEM
1079                 zones_size[ZONE_HIGHMEM] = highend_pfn - low;
1080 #endif
1081         }
1082         free_area_init(zones_size);
1083 }
1084 #else
1085 extern unsigned long setup_memory(void);
1086 extern void zone_sizes_init(void);
1087 #endif /* !CONFIG_DISCONTIGMEM */
1088
1089 void __init setup_bootmem_allocator(void)
1090 {
1091         unsigned long bootmap_size;
1092         /*
1093          * Initialize the boot-time allocator (with low memory only):
1094          */
1095         bootmap_size = init_bootmem(min_low_pfn, max_low_pfn);
1096
1097         register_bootmem_low_pages(max_low_pfn);
1098
1099         /*
1100          * Reserve the bootmem bitmap itself as well. We do this in two
1101          * steps (first step was init_bootmem()) because this catches
1102          * the (very unlikely) case of us accidentally initializing the
1103          * bootmem allocator with an invalid RAM area.
1104          */
1105         reserve_bootmem(HIGH_MEMORY, (PFN_PHYS(min_low_pfn) +
1106                          bootmap_size + PAGE_SIZE-1) - (HIGH_MEMORY));
1107
1108         /*
1109          * reserve physical page 0 - it's a special BIOS page on many boxes,
1110          * enabling clean reboots, SMP operation, laptop functions.
1111          */
1112         reserve_bootmem(0, PAGE_SIZE);
1113
1114         /* reserve EBDA region, it's a 4K region */
1115         reserve_ebda_region();
1116
1117     /* could be an AMD 768MPX chipset. Reserve a page  before VGA to prevent
1118        PCI prefetch into it (errata #56). Usually the page is reserved anyways,
1119        unless you have no PS/2 mouse plugged in. */
1120         if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD &&
1121             boot_cpu_data.x86 == 6)
1122              reserve_bootmem(0xa0000 - 4096, 4096);
1123
1124 #ifdef CONFIG_SMP
1125         /*
1126          * But first pinch a few for the stack/trampoline stuff
1127          * FIXME: Don't need the extra page at 4K, but need to fix
1128          * trampoline before removing it. (see the GDT stuff)
1129          */
1130         reserve_bootmem(PAGE_SIZE, PAGE_SIZE);
1131 #endif
1132 #ifdef CONFIG_ACPI_SLEEP
1133         /*
1134          * Reserve low memory region for sleep support.
1135          */
1136         acpi_reserve_bootmem();
1137 #endif
1138 #ifdef CONFIG_X86_FIND_SMP_CONFIG
1139         /*
1140          * Find and reserve possible boot-time SMP configuration:
1141          */
1142         find_smp_config();
1143 #endif
1144
1145 #ifdef CONFIG_BLK_DEV_INITRD
1146         if (LOADER_TYPE && INITRD_START) {
1147                 if (INITRD_START + INITRD_SIZE <= (max_low_pfn << PAGE_SHIFT)) {
1148                         reserve_bootmem(INITRD_START, INITRD_SIZE);
1149                         initrd_start =
1150                                 INITRD_START ? INITRD_START + PAGE_OFFSET : 0;
1151                         initrd_end = initrd_start+INITRD_SIZE;
1152                 }
1153                 else {
1154                         printk(KERN_ERR "initrd extends beyond end of memory "
1155                             "(0x%08lx > 0x%08lx)\ndisabling initrd\n",
1156                             INITRD_START + INITRD_SIZE,
1157                             max_low_pfn << PAGE_SHIFT);
1158                         initrd_start = 0;
1159                 }
1160         }
1161 #endif
1162 }
1163
1164 /*
1165  * The node 0 pgdat is initialized before all of these because
1166  * it's needed for bootmem.  node>0 pgdats have their virtual
1167  * space allocated before the pagetables are in place to access
1168  * them, so they can't be cleared then.
1169  *
1170  * This should all compile down to nothing when NUMA is off.
1171  */
1172 void __init remapped_pgdat_init(void)
1173 {
1174         int nid;
1175
1176         for_each_online_node(nid) {
1177                 if (nid != 0)
1178                         memset(NODE_DATA(nid), 0, sizeof(struct pglist_data));
1179         }
1180 }
1181
1182 /*
1183  * Request address space for all standard RAM and ROM resources
1184  * and also for regions reported as reserved by the e820.
1185  */
1186 static void __init
1187 legacy_init_iomem_resources(struct resource *code_resource, struct resource *data_resource)
1188 {
1189         int i;
1190
1191         probe_roms();
1192         for (i = 0; i < e820.nr_map; i++) {
1193                 struct resource *res;
1194                 if (e820.map[i].addr + e820.map[i].size > 0x100000000ULL)
1195                         continue;
1196                 res = alloc_bootmem_low(sizeof(struct resource));
1197                 switch (e820.map[i].type) {
1198                 case E820_RAM:  res->name = "System RAM"; break;
1199                 case E820_ACPI: res->name = "ACPI Tables"; break;
1200                 case E820_NVS:  res->name = "ACPI Non-volatile Storage"; break;
1201                 default:        res->name = "reserved";
1202                 }
1203                 res->start = e820.map[i].addr;
1204                 res->end = res->start + e820.map[i].size - 1;
1205                 res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
1206                 request_resource(&iomem_resource, res);
1207                 if (e820.map[i].type == E820_RAM) {
1208                         /*
1209                          *  We don't know which RAM region contains kernel data,
1210                          *  so we try it repeatedly and let the resource manager
1211                          *  test it.
1212                          */
1213                         request_resource(res, code_resource);
1214                         request_resource(res, data_resource);
1215                 }
1216         }
1217 }
1218
1219 /*
1220  * Request address space for all standard resources
1221  */
1222 static void __init register_memory(void)
1223 {
1224         unsigned long gapstart, gapsize;
1225         unsigned long long last;
1226         int           i;
1227
1228         if (efi_enabled)
1229                 efi_initialize_iomem_resources(&code_resource, &data_resource);
1230         else
1231                 legacy_init_iomem_resources(&code_resource, &data_resource);
1232
1233         /* EFI systems may still have VGA */
1234         request_resource(&iomem_resource, &video_ram_resource);
1235
1236         /* request I/O space for devices used on all i[345]86 PCs */
1237         for (i = 0; i < STANDARD_IO_RESOURCES; i++)
1238                 request_resource(&ioport_resource, &standard_io_resources[i]);
1239
1240         /*
1241          * Search for the bigest gap in the low 32 bits of the e820
1242          * memory space.
1243          */
1244         last = 0x100000000ull;
1245         gapstart = 0x10000000;
1246         gapsize = 0x400000;
1247         i = e820.nr_map;
1248         while (--i >= 0) {
1249                 unsigned long long start = e820.map[i].addr;
1250                 unsigned long long end = start + e820.map[i].size;
1251
1252                 /*
1253                  * Since "last" is at most 4GB, we know we'll
1254                  * fit in 32 bits if this condition is true
1255                  */
1256                 if (last > end) {
1257                         unsigned long gap = last - end;
1258
1259                         if (gap > gapsize) {
1260                                 gapsize = gap;
1261                                 gapstart = end;
1262                         }
1263                 }
1264                 if (start < last)
1265                         last = start;
1266         }
1267
1268         /*
1269          * Start allocating dynamic PCI memory a bit into the gap,
1270          * aligned up to the nearest megabyte.
1271          *
1272          * Question: should we try to pad it up a bit (do something
1273          * like " + (gapsize >> 3)" in there too?). We now have the
1274          * technology.
1275          */
1276         pci_mem_start = (gapstart + 0xfffff) & ~0xfffff;
1277
1278         printk("Allocating PCI resources starting at %08lx (gap: %08lx:%08lx)\n",
1279                 pci_mem_start, gapstart, gapsize);
1280 }
1281
1282 /* Use inline assembly to define this because the nops are defined
1283    as inline assembly strings in the include files and we cannot
1284    get them easily into strings. */
1285 asm("\t.data\nintelnops: "
1286     GENERIC_NOP1 GENERIC_NOP2 GENERIC_NOP3 GENERIC_NOP4 GENERIC_NOP5 GENERIC_NOP6
1287     GENERIC_NOP7 GENERIC_NOP8);
1288 asm("\t.data\nk8nops: "
1289     K8_NOP1 K8_NOP2 K8_NOP3 K8_NOP4 K8_NOP5 K8_NOP6
1290     K8_NOP7 K8_NOP8);
1291 asm("\t.data\nk7nops: "
1292     K7_NOP1 K7_NOP2 K7_NOP3 K7_NOP4 K7_NOP5 K7_NOP6
1293     K7_NOP7 K7_NOP8);
1294
1295 extern unsigned char intelnops[], k8nops[], k7nops[];
1296 static unsigned char *intel_nops[ASM_NOP_MAX+1] = {
1297      NULL,
1298      intelnops,
1299      intelnops + 1,
1300      intelnops + 1 + 2,
1301      intelnops + 1 + 2 + 3,
1302      intelnops + 1 + 2 + 3 + 4,
1303      intelnops + 1 + 2 + 3 + 4 + 5,
1304      intelnops + 1 + 2 + 3 + 4 + 5 + 6,
1305      intelnops + 1 + 2 + 3 + 4 + 5 + 6 + 7,
1306 };
1307 static unsigned char *k8_nops[ASM_NOP_MAX+1] = {
1308      NULL,
1309      k8nops,
1310      k8nops + 1,
1311      k8nops + 1 + 2,
1312      k8nops + 1 + 2 + 3,
1313      k8nops + 1 + 2 + 3 + 4,
1314      k8nops + 1 + 2 + 3 + 4 + 5,
1315      k8nops + 1 + 2 + 3 + 4 + 5 + 6,
1316      k8nops + 1 + 2 + 3 + 4 + 5 + 6 + 7,
1317 };
1318 static unsigned char *k7_nops[ASM_NOP_MAX+1] = {
1319      NULL,
1320      k7nops,
1321      k7nops + 1,
1322      k7nops + 1 + 2,
1323      k7nops + 1 + 2 + 3,
1324      k7nops + 1 + 2 + 3 + 4,
1325      k7nops + 1 + 2 + 3 + 4 + 5,
1326      k7nops + 1 + 2 + 3 + 4 + 5 + 6,
1327      k7nops + 1 + 2 + 3 + 4 + 5 + 6 + 7,
1328 };
1329 static struct nop {
1330      int cpuid;
1331      unsigned char **noptable;
1332 } noptypes[] = {
1333      { X86_FEATURE_K8, k8_nops },
1334      { X86_FEATURE_K7, k7_nops },
1335      { -1, NULL }
1336 };
1337
1338 /* Replace instructions with better alternatives for this CPU type.
1339
1340    This runs before SMP is initialized to avoid SMP problems with
1341    self modifying code. This implies that assymetric systems where
1342    APs have less capabilities than the boot processor are not handled.
1343    In this case boot with "noreplacement". */
1344 void apply_alternatives(void *start, void *end)
1345 {
1346         struct alt_instr *a;
1347         int diff, i, k;
1348         unsigned char **noptable = intel_nops;
1349         for (i = 0; noptypes[i].cpuid >= 0; i++) {
1350                 if (boot_cpu_has(noptypes[i].cpuid)) {
1351                         noptable = noptypes[i].noptable;
1352                         break;
1353                 }
1354         }
1355         for (a = start; (void *)a < end; a++) {
1356                 if (!boot_cpu_has(a->cpuid))
1357                         continue;
1358                 BUG_ON(a->replacementlen > a->instrlen);
1359                 memcpy(a->instr, a->replacement, a->replacementlen);
1360                 diff = a->instrlen - a->replacementlen;
1361                 /* Pad the rest with nops */
1362                 for (i = a->replacementlen; diff > 0; diff -= k, i += k) {
1363                         k = diff;
1364                         if (k > ASM_NOP_MAX)
1365                                 k = ASM_NOP_MAX;
1366                         memcpy(a->instr + i, noptable[k], k);
1367                 }
1368         }
1369 }
1370
1371 static int no_replacement __initdata = 0;
1372
1373 void __init alternative_instructions(void)
1374 {
1375         extern struct alt_instr __alt_instructions[], __alt_instructions_end[];
1376         if (no_replacement)
1377                 return;
1378         apply_alternatives(__alt_instructions, __alt_instructions_end);
1379 }
1380
1381 static int __init noreplacement_setup(char *s)
1382 {
1383      no_replacement = 1;
1384      return 0;
1385 }
1386
1387 __setup("noreplacement", noreplacement_setup);
1388
1389 static char * __init machine_specific_memory_setup(void);
1390
1391 #ifdef CONFIG_MCA
1392 static void set_mca_bus(int x)
1393 {
1394         MCA_bus = x;
1395 }
1396 #else
1397 static void set_mca_bus(int x) { }
1398 #endif
1399
1400 /*
1401  * Determine if we were loaded by an EFI loader.  If so, then we have also been
1402  * passed the efi memmap, systab, etc., so we should use these data structures
1403  * for initialization.  Note, the efi init code path is determined by the
1404  * global efi_enabled. This allows the same kernel image to be used on existing
1405  * systems (with a traditional BIOS) as well as on EFI systems.
1406  */
1407 void __init setup_arch(char **cmdline_p)
1408 {
1409         unsigned long max_low_pfn;
1410
1411         memcpy(&boot_cpu_data, &new_cpu_data, sizeof(new_cpu_data));
1412         pre_setup_arch_hook();
1413         early_cpu_init();
1414
1415         /*
1416          * FIXME: This isn't an official loader_type right
1417          * now but does currently work with elilo.
1418          * If we were configured as an EFI kernel, check to make
1419          * sure that we were loaded correctly from elilo and that
1420          * the system table is valid.  If not, then initialize normally.
1421          */
1422 #ifdef CONFIG_EFI
1423         if ((LOADER_TYPE == 0x50) && EFI_SYSTAB)
1424                 efi_enabled = 1;
1425 #endif
1426
1427         ROOT_DEV = old_decode_dev(ORIG_ROOT_DEV);
1428         drive_info = DRIVE_INFO;
1429         screen_info = SCREEN_INFO;
1430         edid_info = EDID_INFO;
1431         apm_info.bios = APM_BIOS_INFO;
1432         ist_info = IST_INFO;
1433         saved_videomode = VIDEO_MODE;
1434         if( SYS_DESC_TABLE.length != 0 ) {
1435                 set_mca_bus(SYS_DESC_TABLE.table[3] & 0x2);
1436                 machine_id = SYS_DESC_TABLE.table[0];
1437                 machine_submodel_id = SYS_DESC_TABLE.table[1];
1438                 BIOS_revision = SYS_DESC_TABLE.table[2];
1439         }
1440         bootloader_type = LOADER_TYPE;
1441
1442 #ifdef CONFIG_BLK_DEV_RAM
1443         rd_image_start = RAMDISK_FLAGS & RAMDISK_IMAGE_START_MASK;
1444         rd_prompt = ((RAMDISK_FLAGS & RAMDISK_PROMPT_FLAG) != 0);
1445         rd_doload = ((RAMDISK_FLAGS & RAMDISK_LOAD_FLAG) != 0);
1446 #endif
1447         ARCH_SETUP
1448         if (efi_enabled)
1449                 efi_init();
1450         else {
1451                 printk(KERN_INFO "BIOS-provided physical RAM map:\n");
1452                 print_memory_map(machine_specific_memory_setup());
1453         }
1454
1455         copy_edd();
1456
1457         if (!MOUNT_ROOT_RDONLY)
1458                 root_mountflags &= ~MS_RDONLY;
1459         init_mm.start_code = (unsigned long) _text;
1460         init_mm.end_code = (unsigned long) _etext;
1461         init_mm.end_data = (unsigned long) _edata;
1462         init_mm.brk = init_pg_tables_end + PAGE_OFFSET;
1463
1464         code_resource.start = virt_to_phys(_text);
1465         code_resource.end = virt_to_phys(_etext)-1;
1466         data_resource.start = virt_to_phys(_etext);
1467         data_resource.end = virt_to_phys(_edata)-1;
1468
1469         parse_cmdline_early(cmdline_p);
1470
1471         max_low_pfn = setup_memory();
1472
1473         /*
1474          * NOTE: before this point _nobody_ is allowed to allocate
1475          * any memory using the bootmem allocator.  Although the
1476          * alloctor is now initialised only the first 8Mb of the kernel
1477          * virtual address space has been mapped.  All allocations before
1478          * paging_init() has completed must use the alloc_bootmem_low_pages()
1479          * variant (which allocates DMA'able memory) and care must be taken
1480          * not to exceed the 8Mb limit.
1481          */
1482
1483 #ifdef CONFIG_SMP
1484         smp_alloc_memory(); /* AP processor realmode stacks in low memory*/
1485 #endif
1486         paging_init();
1487         remapped_pgdat_init();
1488         zone_sizes_init();
1489
1490         /*
1491          * NOTE: at this point the bootmem allocator is fully available.
1492          */
1493
1494 #ifdef CONFIG_EARLY_PRINTK
1495         {
1496                 char *s = strstr(*cmdline_p, "earlyprintk=");
1497                 if (s) {
1498                         extern void setup_early_printk(char *);
1499
1500                         setup_early_printk(s);
1501                         printk("early console enabled\n");
1502                 }
1503         }
1504 #endif
1505
1506
1507         dmi_scan_machine();
1508
1509 #ifdef CONFIG_X86_GENERICARCH
1510         generic_apic_probe(*cmdline_p);
1511 #endif
1512         if (efi_enabled)
1513                 efi_map_memmap();
1514
1515 #ifdef CONFIG_ACPI_BOOT
1516         /*
1517          * Parse the ACPI tables for possible boot-time SMP configuration.
1518          */
1519         acpi_boot_table_init();
1520         acpi_boot_init();
1521 #endif
1522
1523 #ifdef CONFIG_X86_LOCAL_APIC
1524         if (smp_found_config)
1525                 get_smp_config();
1526 #endif
1527
1528         register_memory();
1529
1530 #ifdef CONFIG_VT
1531 #if defined(CONFIG_VGA_CONSOLE)
1532         if (!efi_enabled || (efi_mem_type(0xa0000) != EFI_CONVENTIONAL_MEMORY))
1533                 conswitchp = &vga_con;
1534 #elif defined(CONFIG_DUMMY_CONSOLE)
1535         conswitchp = &dummy_con;
1536 #endif
1537 #endif
1538 }
1539
1540 #include "setup_arch_post.h"
1541 /*
1542  * Local Variables:
1543  * mode:c
1544  * c-file-style:"k&r"
1545  * c-basic-offset:8
1546  * End:
1547  */