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