linux/arch/i386/kernel/setup.c
<<
>>
Prefs
   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 <video/edid.h>
  44#include <asm/e820.h>
  45#include <asm/mpspec.h>
  46#include <asm/setup.h>
  47#include <asm/arch_hooks.h>
  48#include <asm/sections.h>
  49#include <asm/io_apic.h>
  50#include <asm/ist.h>
  51#include <asm/io.h>
  52#include "setup_arch_pre.h"
  53#include <bios_ebda.h>
  54
  55/* This value is set up by the early boot code to point to the value
  56   immediately after the boot time page tables.  It contains a *physical*
  57   address, and must not be in the .bss segment! */
  58unsigned long init_pg_tables_end __initdata = ~0UL;
  59
  60int disable_pse __initdata = 0;
  61
  62/*
  63 * Machine setup..
  64 */
  65
  66#ifdef CONFIG_EFI
  67int efi_enabled = 0;
  68EXPORT_SYMBOL(efi_enabled);
  69#endif
  70
  71/* cpu data as detected by the assembly code in head.S */
  72struct cpuinfo_x86 new_cpu_data __initdata = { 0, 0, 0, 0, -1, 1, 0, 0, -1 };
  73/* common cpu data for all cpus */
  74struct cpuinfo_x86 boot_cpu_data = { 0, 0, 0, 0, -1, 1, 0, 0, -1 };
  75
  76unsigned long mmu_cr4_features;
  77EXPORT_SYMBOL_GPL(mmu_cr4_features);
  78
  79#ifdef  CONFIG_ACPI_INTERPRETER
  80        int acpi_disabled = 0;
  81#else
  82        int acpi_disabled = 1;
  83#endif
  84EXPORT_SYMBOL(acpi_disabled);
  85
  86#ifdef  CONFIG_ACPI_BOOT
  87int __initdata acpi_force = 0;
  88extern acpi_interrupt_flags     acpi_sci_flags;
  89#endif
  90
  91/* for MCA, but anyone else can use it if they want */
  92unsigned int machine_id;
  93unsigned int machine_submodel_id;
  94unsigned int BIOS_revision;
  95unsigned int mca_pentium_flag;
  96
  97/* For PCI or other memory-mapped resources */
  98unsigned long pci_mem_start = 0x10000000;
  99
 100/* Boot loader ID as an integer, for the benefit of proc_dointvec */
 101int bootloader_type;
 102
 103/* user-defined highmem size */
 104static unsigned int highmem_pages = -1;
 105
 106/*
 107 * Setup options
 108 */
 109struct drive_info_struct { char dummy[32]; } drive_info;
 110struct screen_info screen_info;
 111struct apm_info apm_info;
 112struct sys_desc_table_struct {
 113        unsigned short length;
 114        unsigned char table[0];
 115};
 116struct edid_info edid_info;
 117struct ist_info ist_info;
 118struct e820map e820;
 119
 120unsigned char aux_device_present;
 121
 122extern void early_cpu_init(void);
 123extern void dmi_scan_machine(void);
 124extern void generic_apic_probe(char *);
 125extern int root_mountflags;
 126
 127unsigned long saved_videomode;
 128
 129#define RAMDISK_IMAGE_START_MASK        0x07FF
 130#define RAMDISK_PROMPT_FLAG             0x8000
 131#define RAMDISK_LOAD_FLAG               0x4000  
 132
 133static char command_line[COMMAND_LINE_SIZE];
 134
 135unsigned char __initdata boot_params[PARAM_SIZE];
 136
 137static struct resource data_resource = {
 138        .name   = "Kernel data",
 139        .start  = 0,
 140        .end    = 0,
 141        .flags  = IORESOURCE_BUSY | IORESOURCE_MEM
 142};
 143
 144static struct resource code_resource = {
 145        .name   = "Kernel code",
 146        .start  = 0,
 147        .end    = 0,
 148        .flags  = IORESOURCE_BUSY | IORESOURCE_MEM
 149};
 150
 151static 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
 158static 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
 165static 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
 200static 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
 207static struct resource video_ram_resource = {
 208        .name   = "Video RAM area",
 209        .start  = 0xa0000,
 210        .end    = 0xbffff,
 211        .flags  = IORESOURCE_BUSY | IORESOURCE_MEM
 212};
 213
 214static 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
 266static 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
 275static 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
 340static 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
 371static 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
 393static 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 */
 426struct change_member {
 427        struct e820entry *pbios; /* pointer to original bios entry */
 428        unsigned long long addr; /* address for this change point */
 429};
 430struct change_member change_point_list[2*E820MAX] __initdata;
 431struct change_member *change_point[2*E820MAX] __initdata;
 432struct e820entry *overlap_list[E820MAX] __initdata;
 433struct e820entry new_bios[E820MAX] __initdata;
 434
 435static 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 */
 604static 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)
 640struct edd edd;
 641#ifdef CONFIG_EDD_MODULE
 642EXPORT_SYMBOL(edd);
 643#endif
 644/**
 645 * copy_edd() - Copy the BIOS EDD information
 646 *              from boot_params into a safe place.
 647 *
 648 */
 649static 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
 657static 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
 668static 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                                from += 8+7;
 717                                e820.nr_map = 0;
 718                                userdef = 1;
 719                        } else {
 720                                /* If the user specifies memory size, we
 721                                 * limit the BIOS-provided memory map to
 722                                 * that size. exactmap can be used to specify
 723                                 * the exact map. mem=number can be used to
 724                                 * trim the existing memory map.
 725                                 */
 726                                unsigned long long start_at, mem_size;
 727 
 728                                mem_size = memparse(from+7, &from);
 729                                if (*from == '@') {
 730                                        start_at = memparse(from+1, &from);
 731                                        add_memory_region(start_at, mem_size, E820_RAM);
 732                                } else if (*from == '#') {
 733                                        start_at = memparse(from+1, &from);
 734                                        add_memory_region(start_at, mem_size, E820_ACPI);
 735                                } else if (*from == '$') {
 736                                        start_at = memparse(from+1, &from);
 737                                        add_memory_region(start_at, mem_size, E820_RESERVED);
 738                                } else {
 739                                        limit_regions(mem_size);
 740                                        userdef=1;
 741                                }
 742                        }
 743                }
 744
 745                else if (!memcmp(from, "noexec=", 7))
 746                        noexec_setup(from + 7);
 747
 748
 749#ifdef  CONFIG_X86_SMP
 750                /*
 751                 * If the BIOS enumerates physical processors before logical,
 752                 * maxcpus=N at enumeration-time can be used to disable HT.
 753                 */
 754                else if (!memcmp(from, "maxcpus=", 8)) {
 755                        extern unsigned int maxcpus;
 756
 757                        maxcpus = simple_strtoul(from + 8, NULL, 0);
 758                }
 759#endif
 760
 761#ifdef CONFIG_ACPI_BOOT
 762                /* "acpi=off" disables both ACPI table parsing and interpreter */
 763                else if (!memcmp(from, "acpi=off", 8)) {
 764                        disable_acpi();
 765                }
 766
 767                /* acpi=force to over-ride black-list */
 768                else if (!memcmp(from, "acpi=force", 10)) {
 769                        acpi_force = 1;
 770                        acpi_ht = 1;
 771                        acpi_disabled = 0;
 772                }
 773
 774                /* acpi=strict disables out-of-spec workarounds */
 775                else if (!memcmp(from, "acpi=strict", 11)) {
 776                        acpi_strict = 1;
 777                }
 778
 779                /* Limit ACPI just to boot-time to enable HT */
 780                else if (!memcmp(from, "acpi=ht", 7)) {
 781                        if (!acpi_force)
 782                                disable_acpi();
 783                        acpi_ht = 1;
 784                }
 785                
 786                /* "pci=noacpi" disable ACPI IRQ routing and PCI scan */
 787                else if (!memcmp(from, "pci=noacpi", 10)) {
 788                        acpi_disable_pci();
 789                }
 790                /* "acpi=noirq" disables ACPI interrupt routing */
 791                else if (!memcmp(from, "acpi=noirq", 10)) {
 792                        acpi_noirq_set();
 793                }
 794
 795                else if (!memcmp(from, "acpi_sci=edge", 13))
 796                        acpi_sci_flags.trigger =  1;
 797
 798                else if (!memcmp(from, "acpi_sci=level", 14))
 799                        acpi_sci_flags.trigger = 3;
 800
 801                else if (!memcmp(from, "acpi_sci=high", 13))
 802                        acpi_sci_flags.polarity = 1;
 803
 804                else if (!memcmp(from, "acpi_sci=low", 12))
 805                        acpi_sci_flags.polarity = 3;
 806
 807#ifdef CONFIG_X86_IO_APIC
 808                else if (!memcmp(from, "acpi_skip_timer_override", 24))
 809                        acpi_skip_timer_override = 1;
 810#endif
 811
 812#ifdef CONFIG_X86_LOCAL_APIC
 813                /* disable IO-APIC */
 814                else if (!memcmp(from, "noapic", 6))
 815                        disable_ioapic_setup();
 816#endif /* CONFIG_X86_LOCAL_APIC */
 817#endif /* CONFIG_ACPI_BOOT */
 818
 819                /*
 820                 * highmem=size forces highmem to be exactly 'size' bytes.
 821                 * This works even on boxes that have no highmem otherwise.
 822                 * This also works to reduce highmem size on bigger boxes.
 823                 */
 824                else if (!memcmp(from, "highmem=", 8))
 825                        highmem_pages = memparse(from+8, &from) >> PAGE_SHIFT;
 826        
 827                /*
 828                 * vmalloc=size forces the vmalloc area to be exactly 'size'
 829                 * bytes. This can be used to increase (or decrease) the
 830                 * vmalloc area - the default is 128m.
 831                 */
 832                else if (!memcmp(from, "vmalloc=", 8))
 833                        __VMALLOC_RESERVE = memparse(from+8, &from);
 834
 835        next_char:
 836                c = *(from++);
 837                if (!c)
 838                        break;
 839                if (COMMAND_LINE_SIZE <= ++len)
 840                        break;
 841                *(to++) = c;
 842        }
 843        *to = '\0';
 844        *cmdline_p = command_line;
 845        if (userdef) {
 846                printk(KERN_INFO "user-defined physical RAM map:\n");
 847                print_memory_map("user");
 848        }
 849}
 850
 851/*
 852 * Callback for efi_memory_walk.
 853 */
 854static int __init
 855efi_find_max_pfn(unsigned long start, unsigned long end, void *arg)
 856{
 857        unsigned long *max_pfn = arg, pfn;
 858
 859        if (start < end) {
 860                pfn = PFN_UP(end -1);
 861                if (pfn > *max_pfn)
 862                        *max_pfn = pfn;
 863        }
 864        return 0;
 865}
 866
 867
 868/*
 869 * Find the highest page frame number we have available
 870 */
 871void __init find_max_pfn(void)
 872{
 873        int i;
 874
 875        max_pfn = 0;
 876        if (efi_enabled) {
 877                efi_memmap_walk(efi_find_max_pfn, &max_pfn);
 878                return;
 879        }
 880
 881        for (i = 0; i < e820.nr_map; i++) {
 882                unsigned long start, end;
 883                /* RAM? */
 884                if (e820.map[i].type != E820_RAM)
 885                        continue;
 886                start = PFN_UP(e820.map[i].addr);
 887                end = PFN_DOWN(e820.map[i].addr + e820.map[i].size);
 888                if (start >= end)
 889                        continue;
 890                if (end > max_pfn)
 891                        max_pfn = end;
 892        }
 893}
 894
 895/*
 896 * Determine low and high memory ranges:
 897 */
 898unsigned long __init find_max_low_pfn(void)
 899{
 900        unsigned long max_low_pfn;
 901
 902        max_low_pfn = max_pfn;
 903        if (max_low_pfn > MAXMEM_PFN) {
 904                if (highmem_pages == -1)
 905                        highmem_pages = max_pfn - MAXMEM_PFN;
 906                if (highmem_pages + MAXMEM_PFN < max_pfn)
 907                        max_pfn = MAXMEM_PFN + highmem_pages;
 908                if (highmem_pages + MAXMEM_PFN > max_pfn) {
 909                        printk("only %luMB highmem pages available, ignoring highmem size of %uMB.\n", pages_to_mb(max_pfn - MAXMEM_PFN), pages_to_mb(highmem_pages));
 910                        highmem_pages = 0;
 911                }
 912                max_low_pfn = MAXMEM_PFN;
 913#ifndef CONFIG_HIGHMEM
 914                /* Maximum memory usable is what is directly addressable */
 915                printk(KERN_WARNING "Warning only %ldMB will be used.\n",
 916                                        MAXMEM>>20);
 917                if (max_pfn > MAX_NONPAE_PFN)
 918                        printk(KERN_WARNING "Use a PAE enabled kernel.\n");
 919                else
 920                        printk(KERN_WARNING "Use a HIGHMEM enabled kernel.\n");
 921                max_pfn = MAXMEM_PFN;
 922#else /* !CONFIG_HIGHMEM */
 923#ifndef CONFIG_X86_PAE
 924                if (max_pfn > MAX_NONPAE_PFN) {
 925                        max_pfn = MAX_NONPAE_PFN;
 926                        printk(KERN_WARNING "Warning only 4GB will be used.\n");
 927                        printk(KERN_WARNING "Use a PAE enabled kernel.\n");
 928                }
 929#endif /* !CONFIG_X86_PAE */
 930#endif /* !CONFIG_HIGHMEM */
 931        } else {
 932                if (highmem_pages == -1)
 933                        highmem_pages = 0;
 934#ifdef CONFIG_HIGHMEM
 935                if (highmem_pages >= max_pfn) {
 936                        printk(KERN_ERR "highmem size specified (%uMB) is bigger than pages available (%luMB)!.\n", pages_to_mb(highmem_pages), pages_to_mb(max_pfn));
 937                        highmem_pages = 0;
 938                }
 939                if (highmem_pages) {
 940                        if (max_low_pfn-highmem_pages < 64*1024*1024/PAGE_SIZE){
 941                                printk(KERN_ERR "highmem size %uMB results in smaller than 64MB lowmem, ignoring it.\n", pages_to_mb(highmem_pages));
 942                                highmem_pages = 0;
 943                        }
 944                        max_low_pfn -= highmem_pages;
 945                }
 946#else
 947                if (highmem_pages)
 948                        printk(KERN_ERR "ignoring highmem size on non-highmem kernel!\n");
 949#endif
 950        }
 951        return max_low_pfn;
 952}
 953
 954#ifndef CONFIG_DISCONTIGMEM
 955
 956/*
 957 * Free all available memory for boot time allocation.  Used
 958 * as a callback function by efi_memory_walk()
 959 */
 960
 961static int __init
 962free_available_memory(unsigned long start, unsigned long end, void *arg)
 963{
 964        /* check max_low_pfn */
 965        if (start >= ((max_low_pfn + 1) << PAGE_SHIFT))
 966                return 0;
 967        if (end >= ((max_low_pfn + 1) << PAGE_SHIFT))
 968                end = (max_low_pfn + 1) << PAGE_SHIFT;
 969        if (start < end)
 970                free_bootmem(start, end - start);
 971
 972        return 0;
 973}
 974/*
 975 * Register fully available low RAM pages with the bootmem allocator.
 976 */
 977static void __init register_bootmem_low_pages(unsigned long max_low_pfn)
 978{
 979        int i;
 980
 981        if (efi_enabled) {
 982                efi_memmap_walk(free_available_memory, NULL);
 983                return;
 984        }
 985        for (i = 0; i < e820.nr_map; i++) {
 986                unsigned long curr_pfn, last_pfn, size;
 987                /*
 988                 * Reserve usable low memory
 989                 */
 990                if (e820.map[i].type != E820_RAM)
 991                        continue;
 992                /*
 993                 * We are rounding up the start address of usable memory:
 994                 */
 995                curr_pfn = PFN_UP(e820.map[i].addr);
 996                if (curr_pfn >= max_low_pfn)
 997                        continue;
 998                /*
 999                 * ... and at the end of the usable range downwards:
1000                 */
1001                last_pfn = PFN_DOWN(e820.map[i].addr + e820.map[i].size);
1002
1003                if (last_pfn > max_low_pfn)
1004                        last_pfn = max_low_pfn;
1005
1006                /*
1007                 * .. finally, did all the rounding and playing
1008                 * around just make the area go away?
1009                 */
1010                if (last_pfn <= curr_pfn)
1011                        continue;
1012
1013                size = last_pfn - curr_pfn;
1014                free_bootmem(PFN_PHYS(curr_pfn), PFN_PHYS(size));
1015        }
1016}
1017
1018/*
1019 * workaround for Dell systems that neglect to reserve EBDA
1020 */
1021static void __init reserve_ebda_region(void)
1022{
1023        unsigned int addr;
1024        addr = get_bios_ebda();
1025        if (addr)
1026                reserve_bootmem(addr, PAGE_SIZE);       
1027}
1028
1029static unsigned long __init setup_memory(void)
1030{
1031        unsigned long bootmap_size, start_pfn, max_low_pfn;
1032
1033        /*
1034         * partially used pages are not usable - thus
1035         * we are rounding upwards:
1036         */
1037        start_pfn = PFN_UP(init_pg_tables_end);
1038
1039        find_max_pfn();
1040
1041        max_low_pfn = find_max_low_pfn();
1042
1043#ifdef CONFIG_HIGHMEM
1044        highstart_pfn = highend_pfn = max_pfn;
1045        if (max_pfn > max_low_pfn) {
1046                highstart_pfn = max_low_pfn;
1047        }
1048        printk(KERN_NOTICE "%ldMB HIGHMEM available.\n",
1049                pages_to_mb(highend_pfn - highstart_pfn));
1050#endif
1051        printk(KERN_NOTICE "%ldMB LOWMEM available.\n",
1052                        pages_to_mb(max_low_pfn));
1053        /*
1054         * Initialize the boot-time allocator (with low memory only):
1055         */
1056        bootmap_size = init_bootmem(start_pfn, max_low_pfn);
1057
1058        register_bootmem_low_pages(max_low_pfn);
1059
1060        /*
1061         * Reserve the bootmem bitmap itself as well. We do this in two
1062         * steps (first step was init_bootmem()) because this catches
1063         * the (very unlikely) case of us accidentally initializing the
1064         * bootmem allocator with an invalid RAM area.
1065         */
1066        reserve_bootmem(HIGH_MEMORY, (PFN_PHYS(start_pfn) +
1067                         bootmap_size + PAGE_SIZE-1) - (HIGH_MEMORY));
1068
1069        /*
1070         * reserve physical page 0 - it's a special BIOS page on many boxes,
1071         * enabling clean reboots, SMP operation, laptop functions.
1072         */
1073        reserve_bootmem(0, PAGE_SIZE);
1074
1075        /* reserve EBDA region, it's a 4K region */
1076        reserve_ebda_region();
1077
1078    /* could be an AMD 768MPX chipset. Reserve a page  before VGA to prevent
1079       PCI prefetch into it (errata #56). Usually the page is reserved anyways,
1080       unless you have no PS/2 mouse plugged in. */
1081        if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD &&
1082            boot_cpu_data.x86 == 6)
1083             reserve_bootmem(0xa0000 - 4096, 4096);
1084
1085#ifdef CONFIG_SMP
1086        /*
1087         * But first pinch a few for the stack/trampoline stuff
1088         * FIXME: Don't need the extra page at 4K, but need to fix
1089         * trampoline before removing it. (see the GDT stuff)
1090         */
1091        reserve_bootmem(PAGE_SIZE, PAGE_SIZE);
1092#endif
1093#ifdef CONFIG_ACPI_SLEEP
1094        /*
1095         * Reserve low memory region for sleep support.
1096         */
1097        acpi_reserve_bootmem();
1098#endif
1099#ifdef CONFIG_X86_FIND_SMP_CONFIG
1100        /*
1101         * Find and reserve possible boot-time SMP configuration:
1102         */
1103        find_smp_config();
1104#endif
1105
1106#ifdef CONFIG_BLK_DEV_INITRD
1107        if (LOADER_TYPE && INITRD_START) {
1108                if (INITRD_START + INITRD_SIZE <= (max_low_pfn << PAGE_SHIFT)) {
1109                        reserve_bootmem(INITRD_START, INITRD_SIZE);
1110                        initrd_start =
1111                                INITRD_START ? INITRD_START + PAGE_OFFSET : 0;
1112                        initrd_end = initrd_start+INITRD_SIZE;
1113                }
1114                else {
1115                        printk(KERN_ERR "initrd extends beyond end of memory "
1116                            "(0x%08lx > 0x%08lx)\ndisabling initrd\n",
1117                            INITRD_START + INITRD_SIZE,
1118                            max_low_pfn << PAGE_SHIFT);
1119                        initrd_start = 0;
1120                }
1121        }
1122#endif
1123        return max_low_pfn;
1124}
1125#else
1126extern unsigned long setup_memory(void);
1127#endif /* !CONFIG_DISCONTIGMEM */
1128
1129/*
1130 * Request address space for all standard RAM and ROM resources
1131 * and also for regions reported as reserved by the e820.
1132 */
1133static void __init
1134legacy_init_iomem_resources(struct resource *code_resource, struct resource *data_resource)
1135{
1136        int i;
1137
1138        probe_roms();
1139        for (i = 0; i < e820.nr_map; i++) {
1140                struct resource *res;
1141                if (e820.map[i].addr + e820.map[i].size > 0x100000000ULL)
1142                        continue;
1143                res = alloc_bootmem_low(sizeof(struct resource));
1144                switch (e820.map[i].type) {
1145                case E820_RAM:  res->name = "System RAM"; break;
1146                case E820_ACPI: res->name = "ACPI Tables"; break;
1147                case E820_NVS:  res->name = "ACPI Non-volatile Storage"; break;
1148                default:        res->name = "reserved";
1149                }
1150                res->start = e820.map[i].addr;
1151                res->end = res->start + e820.map[i].size - 1;
1152                res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
1153                request_resource(&iomem_resource, res);
1154                if (e820.map[i].type == E820_RAM) {
1155                        /*
1156                         *  We don't know which RAM region contains kernel data,
1157                         *  so we try it repeatedly and let the resource manager
1158                         *  test it.
1159                         */
1160                        request_resource(res, code_resource);
1161                        request_resource(res, data_resource);
1162                }
1163        }
1164}
1165
1166/*
1167 * Request address space for all standard resources
1168 */
1169static void __init register_memory(void)
1170{
1171        unsigned long gapstart, gapsize;
1172        unsigned long long last;
1173        int           i;
1174
1175        if (efi_enabled)
1176                efi_initialize_iomem_resources(&code_resource, &data_resource);
1177        else
1178                legacy_init_iomem_resources(&code_resource, &data_resource);
1179
1180        /* EFI systems may still have VGA */
1181        request_resource(&iomem_resource, &video_ram_resource);
1182
1183        /* request I/O space for devices used on all i[345]86 PCs */
1184        for (i = 0; i < STANDARD_IO_RESOURCES; i++)
1185                request_resource(&ioport_resource, &standard_io_resources[i]);
1186
1187        /*
1188         * Search for the bigest gap in the low 32 bits of the e820
1189         * memory space.
1190         */
1191        last = 0x100000000ull;
1192        gapstart = 0x10000000;
1193        gapsize = 0x400000;
1194        i = e820.nr_map;
1195        while (--i >= 0) {
1196                unsigned long long start = e820.map[i].addr;
1197                unsigned long long end = start + e820.map[i].size;
1198
1199                /*
1200                 * Since "last" is at most 4GB, we know we'll
1201                 * fit in 32 bits if this condition is true
1202                 */
1203                if (last > end) {
1204                        unsigned long gap = last - end;
1205
1206                        if (gap > gapsize) {
1207                                gapsize = gap;
1208                                gapstart = end;
1209                        }
1210                }
1211                if (start < last)
1212                        last = start;
1213        }
1214
1215        /*
1216         * Start allocating dynamic PCI memory a bit into the gap,
1217         * aligned up to the nearest megabyte.
1218         *
1219         * Question: should we try to pad it up a bit (do something
1220         * like " + (gapsize >> 3)" in there too?). We now have the
1221         * technology.
1222         */
1223        pci_mem_start = (gapstart + 0xfffff) & ~0xfffff;
1224
1225        printk("Allocating PCI resources starting at %08lx (gap: %08lx:%08lx)\n",
1226                pci_mem_start, gapstart, gapsize);
1227}
1228
1229/* Use inline assembly to define this because the nops are defined 
1230   as inline assembly strings in the include files and we cannot 
1231   get them easily into strings. */
1232asm("\t.data\nintelnops: " 
1233    GENERIC_NOP1 GENERIC_NOP2 GENERIC_NOP3 GENERIC_NOP4 GENERIC_NOP5 GENERIC_NOP6
1234    GENERIC_NOP7 GENERIC_NOP8); 
1235asm("\t.data\nk8nops: " 
1236    K8_NOP1 K8_NOP2 K8_NOP3 K8_NOP4 K8_NOP5 K8_NOP6
1237    K8_NOP7 K8_NOP8); 
1238asm("\t.data\nk7nops: " 
1239    K7_NOP1 K7_NOP2 K7_NOP3 K7_NOP4 K7_NOP5 K7_NOP6
1240    K7_NOP7 K7_NOP8); 
1241    
1242extern unsigned char intelnops[], k8nops[], k7nops[];
1243static unsigned char *intel_nops[ASM_NOP_MAX+1] = { 
1244     NULL,
1245     intelnops,
1246     intelnops + 1,
1247     intelnops + 1 + 2,
1248     intelnops + 1 + 2 + 3,
1249     intelnops + 1 + 2 + 3 + 4,
1250     intelnops + 1 + 2 + 3 + 4 + 5,
1251     intelnops + 1 + 2 + 3 + 4 + 5 + 6,
1252     intelnops + 1 + 2 + 3 + 4 + 5 + 6 + 7,
1253}; 
1254static unsigned char *k8_nops[ASM_NOP_MAX+1] = { 
1255     NULL,
1256     k8nops,
1257     k8nops + 1,
1258     k8nops + 1 + 2,
1259     k8nops + 1 + 2 + 3,
1260     k8nops + 1 + 2 + 3 + 4,
1261     k8nops + 1 + 2 + 3 + 4 + 5,
1262     k8nops + 1 + 2 + 3 + 4 + 5 + 6,
1263     k8nops + 1 + 2 + 3 + 4 + 5 + 6 + 7,
1264}; 
1265static unsigned char *k7_nops[ASM_NOP_MAX+1] = { 
1266     NULL,
1267     k7nops,
1268     k7nops + 1,
1269     k7nops + 1 + 2,
1270     k7nops + 1 + 2 + 3,
1271     k7nops + 1 + 2 + 3 + 4,
1272     k7nops + 1 + 2 + 3 + 4 + 5,
1273     k7nops + 1 + 2 + 3 + 4 + 5 + 6,
1274     k7nops + 1 + 2 + 3 + 4 + 5 + 6 + 7,
1275}; 
1276static struct nop { 
1277     int cpuid; 
1278     unsigned char **noptable; 
1279} noptypes[] = { 
1280     { X86_FEATURE_K8, k8_nops }, 
1281     { X86_FEATURE_K7, k7_nops }, 
1282     { -1, NULL }
1283}; 
1284
1285/* Replace instructions with better alternatives for this CPU type.
1286
1287   This runs before SMP is initialized to avoid SMP problems with
1288   self modifying code. This implies that assymetric systems where
1289   APs have less capabilities than the boot processor are not handled. 
1290   In this case boot with "noreplacement". */ 
1291void apply_alternatives(void *start, void *end) 
1292{ 
1293        struct alt_instr *a; 
1294        int diff, i, k;
1295        unsigned char **noptable = intel_nops; 
1296        for (i = 0; noptypes[i].cpuid >= 0; i++) { 
1297                if (boot_cpu_has(noptypes[i].cpuid)) { 
1298                        noptable = noptypes[i].noptable;
1299                        break;
1300                }
1301        } 
1302        for (a = start; (void *)a < end; a++) { 
1303                if (!boot_cpu_has(a->cpuid))
1304                        continue;
1305                BUG_ON(a->replacementlen > a->instrlen); 
1306                memcpy(a->instr, a->replacement, a->replacementlen); 
1307                diff = a->instrlen - a->replacementlen; 
1308                /* Pad the rest with nops */
1309                for (i = a->replacementlen; diff > 0; diff -= k, i += k) {
1310                        k = diff;
1311                        if (k > ASM_NOP_MAX)
1312                                k = ASM_NOP_MAX;
1313                        memcpy(a->instr + i, noptable[k], k); 
1314                } 
1315        }
1316} 
1317
1318static int no_replacement __initdata = 0; 
1319 
1320void __init alternative_instructions(void)
1321{
1322        extern struct alt_instr __alt_instructions[], __alt_instructions_end[];
1323        if (no_replacement) 
1324                return;
1325        apply_alternatives(__alt_instructions, __alt_instructions_end);
1326}
1327
1328static int __init noreplacement_setup(char *s)
1329{ 
1330     no_replacement = 1; 
1331     return 0; 
1332} 
1333
1334__setup("noreplacement", noreplacement_setup); 
1335
1336static char * __init machine_specific_memory_setup(void);
1337
1338#ifdef CONFIG_MCA
1339static void set_mca_bus(int x)
1340{
1341        MCA_bus = x;
1342}
1343#else
1344static void set_mca_bus(int x) { }
1345#endif
1346
1347/*
1348 * Determine if we were loaded by an EFI loader.  If so, then we have also been
1349 * passed the efi memmap, systab, etc., so we should use these data structures
1350 * for initialization.  Note, the efi init code path is determined by the
1351 * global efi_enabled. This allows the same kernel image to be used on existing
1352 * systems (with a traditional BIOS) as well as on EFI systems.
1353 */
1354void __init setup_arch(char **cmdline_p)
1355{
1356        unsigned long max_low_pfn;
1357
1358        memcpy(&boot_cpu_data, &new_cpu_data, sizeof(new_cpu_data));
1359        pre_setup_arch_hook();
1360        early_cpu_init();
1361
1362        /*
1363         * FIXME: This isn't an official loader_type right
1364         * now but does currently work with elilo.
1365         * If we were configured as an EFI kernel, check to make
1366         * sure that we were loaded correctly from elilo and that
1367         * the system table is valid.  If not, then initialize normally.
1368         */
1369#ifdef CONFIG_EFI
1370        if ((LOADER_TYPE == 0x50) && EFI_SYSTAB)
1371                efi_enabled = 1;
1372#endif
1373
1374        ROOT_DEV = old_decode_dev(ORIG_ROOT_DEV);
1375        drive_info = DRIVE_INFO;
1376        screen_info = SCREEN_INFO;
1377        edid_info = EDID_INFO;
1378        apm_info.bios = APM_BIOS_INFO;
1379        ist_info = IST_INFO;
1380        saved_videomode = VIDEO_MODE;
1381        if( SYS_DESC_TABLE.length != 0 ) {
1382                set_mca_bus(SYS_DESC_TABLE.table[3] & 0x2);
1383                machine_id = SYS_DESC_TABLE.table[0];
1384                machine_submodel_id = SYS_DESC_TABLE.table[1];
1385                BIOS_revision = SYS_DESC_TABLE.table[2];
1386        }
1387        aux_device_present = AUX_DEVICE_INFO;
1388        bootloader_type = LOADER_TYPE;
1389
1390#ifdef CONFIG_BLK_DEV_RAM
1391        rd_image_start = RAMDISK_FLAGS & RAMDISK_IMAGE_START_MASK;
1392        rd_prompt = ((RAMDISK_FLAGS & RAMDISK_PROMPT_FLAG) != 0);
1393        rd_doload = ((RAMDISK_FLAGS & RAMDISK_LOAD_FLAG) != 0);
1394#endif
1395        ARCH_SETUP
1396        if (efi_enabled)
1397                efi_init();
1398        else {
1399                printk(KERN_INFO "BIOS-provided physical RAM map:\n");
1400                print_memory_map(machine_specific_memory_setup());
1401        }
1402
1403        copy_edd();
1404
1405        if (!MOUNT_ROOT_RDONLY)
1406                root_mountflags &= ~MS_RDONLY;
1407        init_mm.start_code = (unsigned long) _text;
1408        init_mm.end_code = (unsigned long) _etext;
1409        init_mm.end_data = (unsigned long) _edata;
1410        init_mm.brk = init_pg_tables_end + PAGE_OFFSET;
1411
1412        code_resource.start = virt_to_phys(_text);
1413        code_resource.end = virt_to_phys(_etext)-1;
1414        data_resource.start = virt_to_phys(_etext);
1415        data_resource.end = virt_to_phys(_edata)-1;
1416
1417        parse_cmdline_early(cmdline_p);
1418
1419        max_low_pfn = setup_memory();
1420
1421        /*
1422         * NOTE: before this point _nobody_ is allowed to allocate
1423         * any memory using the bootmem allocator.  Although the
1424         * alloctor is now initialised only the first 8Mb of the kernel
1425         * virtual address space has been mapped.  All allocations before
1426         * paging_init() has completed must use the alloc_bootmem_low_pages()
1427         * variant (which allocates DMA'able memory) and care must be taken
1428         * not to exceed the 8Mb limit.
1429         */
1430
1431#ifdef CONFIG_SMP
1432        smp_alloc_memory(); /* AP processor realmode stacks in low memory*/
1433#endif
1434        paging_init();
1435
1436        /*
1437         * NOTE: at this point the bootmem allocator is fully available.
1438         */
1439
1440#ifdef CONFIG_EARLY_PRINTK
1441        {
1442                char *s = strstr(*cmdline_p, "earlyprintk=");
1443                if (s) {
1444                        extern void setup_early_printk(char *);
1445
1446                        setup_early_printk(s);
1447                        printk("early console enabled\n");
1448                }
1449        }
1450#endif
1451
1452
1453        dmi_scan_machine();
1454
1455#ifdef CONFIG_X86_GENERICARCH
1456        generic_apic_probe(*cmdline_p);
1457#endif  
1458        if (efi_enabled)
1459                efi_map_memmap();
1460
1461        /*
1462         * Parse the ACPI tables for possible boot-time SMP configuration.
1463         */
1464        acpi_boot_table_init();
1465        acpi_boot_init();
1466
1467#ifdef CONFIG_X86_LOCAL_APIC
1468        if (smp_found_config)
1469                get_smp_config();
1470#endif
1471
1472        register_memory();
1473
1474#ifdef CONFIG_VT
1475#if defined(CONFIG_VGA_CONSOLE)
1476        if (!efi_enabled || (efi_mem_type(0xa0000) != EFI_CONVENTIONAL_MEMORY))
1477                conswitchp = &vga_con;
1478#elif defined(CONFIG_DUMMY_CONSOLE)
1479        conswitchp = &dummy_con;
1480#endif
1481#endif
1482}
1483
1484#include "setup_arch_post.h"
1485/*
1486 * Local Variables:
1487 * mode:c
1488 * c-file-style:"k&r"
1489 * c-basic-offset:8
1490 * End:
1491 */
1492
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.