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 extern struct e820map e820;
  80 extern struct resource code_resource;
  81 extern struct resource data_resource;
  82
  83 /* cpu data as detected by the assembly code in head.S */
  84 struct cpuinfo_x86 new_cpu_data __initdata = { 0, 0, 0, 0, -1, 1, 0, 0, -1 };
  85 /* common cpu data for all cpus */
  86 struct cpuinfo_x86 boot_cpu_data __read_mostly = { 0, 0, 0, 0, -1, 1, 0, 0, -1 };
  87 EXPORT_SYMBOL(boot_cpu_data);
  88
  89 unsigned long mmu_cr4_features;
  90
  91 /* for MCA, but anyone else can use it if they want */
  92 unsigned int machine_id;
  93 #ifdef CONFIG_MCA
  94 EXPORT_SYMBOL(machine_id);
  95 #endif
  96 unsigned int machine_submodel_id;
  97 unsigned int BIOS_revision;
  98 unsigned int mca_pentium_flag;
  99
 100 /* For PCI or other memory-mapped resources */
 101 unsigned long pci_mem_start = 0x10000000;
 102 #ifdef CONFIG_PCI
 103 EXPORT_SYMBOL(pci_mem_start);
 104 #endif
 105
 106 /* Boot loader ID as an integer, for the benefit of proc_dointvec */
 107 int bootloader_type;
 108
 109 /* user-defined highmem size */
 110 static unsigned int highmem_pages = -1;
 111
 112 /*
 113  * Setup options
 114  */
 115 struct drive_info_struct { char dummy[32]; } drive_info;
 116 #if defined(CONFIG_BLK_DEV_IDE) || defined(CONFIG_BLK_DEV_HD) || \
 117     defined(CONFIG_BLK_DEV_IDE_MODULE) || defined(CONFIG_BLK_DEV_HD_MODULE)
 118 EXPORT_SYMBOL(drive_info);
 119 #endif
 120 struct screen_info screen_info;
 121 EXPORT_SYMBOL(screen_info);
 122 struct apm_info apm_info;
 123 EXPORT_SYMBOL(apm_info);
 124 struct sys_desc_table_struct {
 125         unsigned short length;
 126         unsigned char table[0];
 127 };
 128 struct edid_info edid_info;
 129 EXPORT_SYMBOL_GPL(edid_info);
 130 struct ist_info ist_info;
 131 #if defined(CONFIG_X86_SPEEDSTEP_SMI) || \
 132         defined(CONFIG_X86_SPEEDSTEP_SMI_MODULE)
 133 EXPORT_SYMBOL(ist_info);
 134 #endif
 135
 136 extern void early_cpu_init(void);
 137 extern int root_mountflags;
 138
 139 unsigned long saved_videomode;
 140
 141 #define RAMDISK_IMAGE_START_MASK        0x07FF
 142 #define RAMDISK_PROMPT_FLAG             0x8000
 143 #define RAMDISK_LOAD_FLAG               0x4000
 144
 145 static char command_line[COMMAND_LINE_SIZE];
 146
 147 unsigned char __initdata boot_params[PARAM_SIZE];
 148
 149 static void __init limit_regions(unsigned long long size)
 150 {
 151         unsigned long long current_addr = 0;
 152         int i;
 153
 154         if (efi_enabled) {
 155                 efi_memory_desc_t *md;
 156                 void *p;
 157
 158                 for (p = memmap.map, i = 0; p < memmap.map_end;
 159                         p += memmap.desc_size, i++) {
 160                         md = p;
 161                         current_addr = md->phys_addr + (md->num_pages << 12);
 162                         if (md->type == EFI_CONVENTIONAL_MEMORY) {
 163                                 if (current_addr >= size) {
 164                                         md->num_pages -=
 165                                                 (((current_addr-size) + PAGE_SIZE-1) >> PAGE_SHIFT);
 166                                         memmap.nr_map = i + 1;
 167                                         return;
 168                                 }
 169                         }
 170                 }
 171         }
 172         for (i = 0; i < e820.nr_map; i++) {
 173                 current_addr = e820.map[i].addr + e820.map[i].size;
 174                 if (current_addr < size)
 175                         continue;
 176
 177                 if (e820.map[i].type != E820_RAM)
 178                         continue;
 179
 180                 if (e820.map[i].addr >= size) {
 181                         /*
 182                          * This region starts past the end of the
 183                          * requested size, skip it completely.
 184                          */
 185                         e820.nr_map = i;
 186                 } else {
 187                         e820.nr_map = i + 1;
 188                         e820.map[i].size -= current_addr - size;
 189                 }
 190                 return;
 191         }
 192 }
 193
 194 #define E820_DEBUG      1
 195
 196 static void __init print_memory_map(char *who)
 197 {
 198         int i;
 199
 200         for (i = 0; i < e820.nr_map; i++) {
 201                 printk(" %s: %016Lx - %016Lx ", who,
 202                         e820.map[i].addr,
 203                         e820.map[i].addr + e820.map[i].size);
 204                 switch (e820.map[i].type) {
 205                 case E820_RAM:  printk("(usable)\n");
 206                                 break;
 207                 case E820_RESERVED:
 208                                 printk("(reserved)\n");
 209                                 break;
 210                 case E820_ACPI:
 211                                 printk("(ACPI data)\n");
 212                                 break;
 213                 case E820_NVS:
 214                                 printk("(ACPI NVS)\n");
 215                                 break;
 216                 default:        printk("type %lu\n", e820.map[i].type);
 217                                 break;
 218                 }
 219         }
 220 }
 221
 222 #if defined(CONFIG_EDD) || defined(CONFIG_EDD_MODULE)
 223 struct edd edd;
 224 #ifdef CONFIG_EDD_MODULE
 225 EXPORT_SYMBOL(edd);
 226 #endif
 227 /**
 228  * copy_edd() - Copy the BIOS EDD information
 229  *              from boot_params into a safe place.
 230  *
 231  */
 232 static inline void copy_edd(void)
 233 {
 234      memcpy(edd.mbr_signature, EDD_MBR_SIGNATURE, sizeof(edd.mbr_signature));
 235      memcpy(edd.edd_info, EDD_BUF, sizeof(edd.edd_info));
 236      edd.mbr_signature_nr = EDD_MBR_SIG_NR;
 237      edd.edd_info_nr = EDD_NR;
 238 }
 239 #else
 240 static inline void copy_edd(void)
 241 {
 242 }
 243 #endif
 244
 245 static int __initdata user_defined_memmap = 0;
 246
 247 /*
 248  * "mem=nopentium" disables the 4MB page tables.
 249  * "mem=XXX[kKmM]" defines a memory region from HIGH_MEM
 250  * to <mem>, overriding the bios size.
 251  * "memmap=XXX[KkmM]@XXX[KkmM]" defines a memory region from
 252  * <start> to <start>+<mem>, overriding the bios size.
 253  *
 254  * HPA tells me bootloaders need to parse mem=, so no new
 255  * option should be mem=  [also see Documentation/i386/boot.txt]
 256  */
 257 static int __init parse_mem(char *arg)
 258 {
 259         if (!arg)
 260                 return -EINVAL;
 261
 262         if (strcmp(arg, "nopentium") == 0) {
 263                 clear_bit(X86_FEATURE_PSE, boot_cpu_data.x86_capability);
 264                 disable_pse = 1;
 265         } else {
 266                 /* If the user specifies memory size, we
 267                  * limit the BIOS-provided memory map to
 268                  * that size. exactmap can be used to specify
 269                  * the exact map. mem=number can be used to
 270                  * trim the existing memory map.
 271                  */
 272                 unsigned long long mem_size;
 273
 274                 mem_size = memparse(arg, &arg);
 275                 limit_regions(mem_size);
 276                 user_defined_memmap = 1;
 277         }
 278         return 0;
 279 }
 280 early_param("mem", parse_mem);
 281
 282 static int __init parse_memmap(char *arg)
 283 {
 284         if (!arg)
 285                 return -EINVAL;
 286
 287         if (strcmp(arg, "exactmap") == 0) {
 288 #ifdef CONFIG_CRASH_DUMP
 289                 /* If we are doing a crash dump, we
 290                  * still need to know the real mem
 291                  * size before original memory map is
 292                  * reset.
 293                  */
 294                 find_max_pfn();
 295                 saved_max_pfn = max_pfn;
 296 #endif
 297                 e820.nr_map = 0;
 298                 user_defined_memmap = 1;
 299         } else {
 300                 /* If the user specifies memory size, we
 301                  * limit the BIOS-provided memory map to
 302                  * that size. exactmap can be used to specify
 303                  * the exact map. mem=number can be used to
 304                  * trim the existing memory map.
 305                  */
 306                 unsigned long long start_at, mem_size;
 307
 308                 mem_size = memparse(arg, &arg);
 309                 if (*arg == '@') {
 310                         start_at = memparse(arg+1, &arg);
 311                         add_memory_region(start_at, mem_size, E820_RAM);
 312                 } else if (*arg == '#') {
 313                         start_at = memparse(arg+1, &arg);
 314                         add_memory_region(start_at, mem_size, E820_ACPI);
 315                 } else if (*arg == '$') {
 316                         start_at = memparse(arg+1, &arg);
 317                         add_memory_region(start_at, mem_size, E820_RESERVED);
 318                 } else {
 319                         limit_regions(mem_size);
 320                         user_defined_memmap = 1;
 321                 }
 322         }
 323         return 0;
 324 }
 325 early_param("memmap", parse_memmap);
 326
 327 #ifdef CONFIG_PROC_VMCORE
 328 /* elfcorehdr= specifies the location of elf core header
 329  * stored by the crashed kernel.
 330  */
 331 static int __init parse_elfcorehdr(char *arg)
 332 {
 333         if (!arg)
 334                 return -EINVAL;
 335
 336         elfcorehdr_addr = memparse(arg, &arg);
 337         return 0;
 338 }
 339 early_param("elfcorehdr", parse_elfcorehdr);
 340 #endif /* CONFIG_PROC_VMCORE */
 341
 342 /*
 343  * highmem=size forces highmem to be exactly 'size' bytes.
 344  * This works even on boxes that have no highmem otherwise.
 345  * This also works to reduce highmem size on bigger boxes.
 346  */
 347 static int __init parse_highmem(char *arg)
 348 {
 349         if (!arg)
 350                 return -EINVAL;
 351
 352         highmem_pages = memparse(arg, &arg) >> PAGE_SHIFT;
 353         return 0;
 354 }
 355 early_param("highmem", parse_highmem);
 356
 357 /*
 358  * vmalloc=size forces the vmalloc area to be exactly 'size'
 359  * bytes. This can be used to increase (or decrease) the
 360  * vmalloc area - the default is 128m.
 361  */
 362 static int __init parse_vmalloc(char *arg)
 363 {
 364         if (!arg)
 365                 return -EINVAL;
 366
 367         __VMALLOC_RESERVE = memparse(arg, &arg);
 368         return 0;
 369 }
 370 early_param("vmalloc", parse_vmalloc);
 371
 372 /*
 373  * reservetop=size reserves a hole at the top of the kernel address space which
 374  * a hypervisor can load into later.  Needed for dynamically loaded hypervisors,
 375  * so relocating the fixmap can be done before paging initialization.
 376  */
 377 static int __init parse_reservetop(char *arg)
 378 {
 379         unsigned long address;
 380
 381         if (!arg)
 382                 return -EINVAL;
 383
 384         address = memparse(arg, &arg);
 385         reserve_top_address(address);
 386         return 0;
 387 }
 388 early_param("reservetop", parse_reservetop);
 389
 390 /*
 391  * Callback for efi_memory_walk.
 392  */
 393 static int __init
 394 efi_find_max_pfn(unsigned long start, unsigned long end, void *arg)
 395 {
 396         unsigned long *max_pfn = arg, pfn;
 397
 398         if (start < end) {
 399                 pfn = PFN_UP(end -1);
 400                 if (pfn > *max_pfn)
 401                         *max_pfn = pfn;
 402         }
 403         return 0;
 404 }
 405
 406 static int __init
 407 efi_memory_present_wrapper(unsigned long start, unsigned long end, void *arg)
 408 {
 409         memory_present(0, PFN_UP(start), PFN_DOWN(end));
 410         return 0;
 411 }
 412
 413  /*
 414   * This function checks if the entire range <start,end> is mapped with type.
 415   *
 416   * Note: this function only works correct if the e820 table is sorted and
 417   * not-overlapping, which is the case
 418   */
 419 int __init
 420 e820_all_mapped(unsigned long s, unsigned long e, unsigned type)
 421 {
 422         u64 start = s;
 423         u64 end = e;
 424         int i;
 425         for (i = 0; i < e820.nr_map; i++) {
 426                 struct e820entry *ei = &e820.map[i];
 427                 if (type && ei->type != type)
 428                         continue;
 429                 /* is the region (part) in overlap with the current region ?*/
 430                 if (ei->addr >= end || ei->addr + ei->size <= start)
 431                         continue;
 432                 /* if the region is at the beginning of <start,end> we move
 433                  * start to the end of the region since it's ok until there
 434                  */
 435                 if (ei->addr <= start)
 436                         start = ei->addr + ei->size;
 437                 /* if start is now at or beyond end, we're done, full
 438                  * coverage */
 439                 if (start >= end)
 440                         return 1; /* we're done */
 441         }
 442         return 0;
 443 }
 444
 445 /*
 446  * Find the highest page frame number we have available
 447  */
 448 void __init find_max_pfn(void)
 449 {
 450         int i;
 451
 452         max_pfn = 0;
 453         if (efi_enabled) {
 454                 efi_memmap_walk(efi_find_max_pfn, &max_pfn);
 455                 efi_memmap_walk(efi_memory_present_wrapper, NULL);
 456                 return;
 457         }
 458
 459         for (i = 0; i < e820.nr_map; i++) {
 460                 unsigned long start, end;
 461                 /* RAM? */
 462                 if (e820.map[i].type != E820_RAM)
 463                         continue;
 464                 start = PFN_UP(e820.map[i].addr);
 465                 end = PFN_DOWN(e820.map[i].addr + e820.map[i].size);
 466                 if (start >= end)
 467                         continue;
 468                 if (end > max_pfn)
 469                         max_pfn = end;
 470                 memory_present(0, start, end);
 471         }
 472 }
 473
 474 /*
 475  * Determine low and high memory ranges:
 476  */
 477 unsigned long __init find_max_low_pfn(void)
 478 {
 479         unsigned long max_low_pfn;
 480
 481         max_low_pfn = max_pfn;
 482         if (max_low_pfn > MAXMEM_PFN) {
 483                 if (highmem_pages == -1)
 484                         highmem_pages = max_pfn - MAXMEM_PFN;
 485                 if (highmem_pages + MAXMEM_PFN < max_pfn)
 486                         max_pfn = MAXMEM_PFN + highmem_pages;
 487                 if (highmem_pages + MAXMEM_PFN > max_pfn) {
 488                         printk("only %luMB highmem pages available, ignoring highmem size of %uMB.\n", pages_to_mb(max_pfn - MAXMEM_PFN), pages_to_mb(highmem_pages));
 489                         highmem_pages = 0;
 490                 }
 491                 max_low_pfn = MAXMEM_PFN;
 492 #ifndef CONFIG_HIGHMEM
 493                 /* Maximum memory usable is what is directly addressable */
 494                 printk(KERN_WARNING "Warning only %ldMB will be used.\n",
 495                                         MAXMEM>>20);
 496                 if (max_pfn > MAX_NONPAE_PFN)
 497                         printk(KERN_WARNING "Use a PAE enabled kernel.\n");
 498                 else
 499                         printk(KERN_WARNING "Use a HIGHMEM enabled kernel.\n");
 500                 max_pfn = MAXMEM_PFN;
 501 #else /* !CONFIG_HIGHMEM */
 502 #ifndef CONFIG_X86_PAE
 503                 if (max_pfn > MAX_NONPAE_PFN) {
 504                         max_pfn = MAX_NONPAE_PFN;
 505                         printk(KERN_WARNING "Warning only 4GB will be used.\n");
 506                         printk(KERN_WARNING "Use a PAE enabled kernel.\n");
 507                 }
 508 #endif /* !CONFIG_X86_PAE */
 509 #endif /* !CONFIG_HIGHMEM */
 510         } else {
 511                 if (highmem_pages == -1)
 512                         highmem_pages = 0;
 513 #ifdef CONFIG_HIGHMEM
 514                 if (highmem_pages >= max_pfn) {
 515                         printk(KERN_ERR "highmem size specified (%uMB) is bigger than pages available (%luMB)!.\n", pages_to_mb(highmem_pages), pages_to_mb(max_pfn));
 516                         highmem_pages = 0;
 517                 }
 518                 if (highmem_pages) {
 519                         if (max_low_pfn-highmem_pages < 64*1024*1024/PAGE_SIZE){
 520                                 printk(KERN_ERR "highmem size %uMB results in smaller than 64MB lowmem, ignoring it.\n", pages_to_mb(highmem_pages));
 521                                 highmem_pages = 0;
 522                         }
 523                         max_low_pfn -= highmem_pages;
 524                 }
 525 #else
 526                 if (highmem_pages)
 527                         printk(KERN_ERR "ignoring highmem size on non-highmem kernel!\n");
 528 #endif
 529         }
 530         return max_low_pfn;
 531 }
 532
 533 /*
 534  * Free all available memory for boot time allocation.  Used
 535  * as a callback function by efi_memory_walk()
 536  */
 537
 538 static int __init
 539 free_available_memory(unsigned long start, unsigned long end, void *arg)
 540 {
 541         /* check max_low_pfn */
 542         if (start >= (max_low_pfn << PAGE_SHIFT))
 543                 return 0;
 544         if (end >= (max_low_pfn << PAGE_SHIFT))
 545                 end = max_low_pfn << PAGE_SHIFT;
 546         if (start < end)
 547                 free_bootmem(start, end - start);
 548
 549         return 0;
 550 }
 551 /*
 552  * Register fully available low RAM pages with the bootmem allocator.
 553  */
 554 static void __init register_bootmem_low_pages(unsigned long max_low_pfn)
 555 {
 556         int i;
 557
 558         if (efi_enabled) {
 559                 efi_memmap_walk(free_available_memory, NULL);
 560                 return;
 561         }
 562         for (i = 0; i < e820.nr_map; i++) {
 563                 unsigned long curr_pfn, last_pfn, size;
 564                 /*
 565                  * Reserve usable low memory
 566                  */
 567                 if (e820.map[i].type != E820_RAM)
 568                         continue;
 569                 /*
 570                  * We are rounding up the start address of usable memory:
 571                  */
 572                 curr_pfn = PFN_UP(e820.map[i].addr);
 573                 if (curr_pfn >= max_low_pfn)
 574                         continue;
 575                 /*
 576                  * ... and at the end of the usable range downwards:
 577                  */
 578                 last_pfn = PFN_DOWN(e820.map[i].addr + e820.map[i].size);
 579
 580                 if (last_pfn > max_low_pfn)
 581                         last_pfn = max_low_pfn;
 582
 583                 /*
 584                  * .. finally, did all the rounding and playing
 585                  * around just make the area go away?
 586                  */
 587                 if (last_pfn <= curr_pfn)
 588                         continue;
 589
 590                 size = last_pfn - curr_pfn;
 591                 free_bootmem(PFN_PHYS(curr_pfn), PFN_PHYS(size));
 592         }
 593 }
 594
 595 /*
 596  * workaround for Dell systems that neglect to reserve EBDA
 597  */
 598 static void __init reserve_ebda_region(void)
 599 {
 600         unsigned int addr;
 601         addr = get_bios_ebda();
 602         if (addr)
 603                 reserve_bootmem(addr, PAGE_SIZE);
 604 }
 605
 606 #ifndef CONFIG_NEED_MULTIPLE_NODES
 607 void __init setup_bootmem_allocator(void);
 608 static unsigned long __init setup_memory(void)
 609 {
 610         /*
 611          * partially used pages are not usable - thus
 612          * we are rounding upwards:
 613          */
 614         min_low_pfn = PFN_UP(init_pg_tables_end);
 615
 616         find_max_pfn();
 617
 618         max_low_pfn = find_max_low_pfn();
 619
 620 #ifdef CONFIG_HIGHMEM
 621         highstart_pfn = highend_pfn = max_pfn;
 622         if (max_pfn > max_low_pfn) {
 623                 highstart_pfn = max_low_pfn;
 624         }
 625         printk(KERN_NOTICE "%ldMB HIGHMEM available.\n",
 626                 pages_to_mb(highend_pfn - highstart_pfn));
 627         num_physpages = highend_pfn;
 628         high_memory = (void *) __va(highstart_pfn * PAGE_SIZE - 1) + 1;
 629 #else
 630         num_physpages = max_low_pfn;
 631         high_memory = (void *) __va(max_low_pfn * PAGE_SIZE - 1) + 1;
 632 #endif
 633 #ifdef CONFIG_FLATMEM
 634         max_mapnr = num_physpages;
 635 #endif
 636         printk(KERN_NOTICE "%ldMB LOWMEM available.\n",
 637                         pages_to_mb(max_low_pfn));
 638
 639         setup_bootmem_allocator();
 640
 641         return max_low_pfn;
 642 }
 643
 644 void __init zone_sizes_init(void)
 645 {
 646         unsigned long max_zone_pfns[MAX_NR_ZONES];
 647         memset(max_zone_pfns, 0, sizeof(max_zone_pfns));
 648         max_zone_pfns[ZONE_DMA] =
 649                 virt_to_phys((char *)MAX_DMA_ADDRESS) >> PAGE_SHIFT;
 650         max_zone_pfns[ZONE_NORMAL] = max_low_pfn;
 651 #ifdef CONFIG_HIGHMEM
 652         max_zone_pfns[ZONE_HIGHMEM] = highend_pfn;
 653         add_active_range(0, 0, highend_pfn);
 654 #else
 655         add_active_range(0, 0, max_low_pfn);
 656 #endif
 657
 658         free_area_init_nodes(max_zone_pfns);
 659 }
 660 #else
 661 extern unsigned long __init setup_memory(void);
 662 extern void zone_sizes_init(void);
 663 #endif /* !CONFIG_NEED_MULTIPLE_NODES */
 664
 665 void __init setup_bootmem_allocator(void)
 666 {
 667         unsigned long bootmap_size;
 668         /*
 669          * Initialize the boot-time allocator (with low memory only):
 670          */
 671         bootmap_size = init_bootmem(min_low_pfn, max_low_pfn);
 672
 673         register_bootmem_low_pages(max_low_pfn);
 674
 675         /*
 676          * Reserve the bootmem bitmap itself as well. We do this in two
 677          * steps (first step was init_bootmem()) because this catches
 678          * the (very unlikely) case of us accidentally initializing the
 679          * bootmem allocator with an invalid RAM area.
 680          */
 681         reserve_bootmem(__pa_symbol(_text), (PFN_PHYS(min_low_pfn) +
 682                          bootmap_size + PAGE_SIZE-1) - __pa_symbol(_text));
 683
 684         /*
 685          * reserve physical page 0 - it's a special BIOS page on many boxes,
 686          * enabling clean reboots, SMP operation, laptop functions.
 687          */
 688         reserve_bootmem(0, PAGE_SIZE);
 689
 690         /* reserve EBDA region, it's a 4K region */
 691         reserve_ebda_region();
 692
 693     /* could be an AMD 768MPX chipset. Reserve a page  before VGA to prevent
 694        PCI prefetch into it (errata #56). Usually the page is reserved anyways,
 695        unless you have no PS/2 mouse plugged in. */
 696         if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD &&
 697             boot_cpu_data.x86 == 6)
 698              reserve_bootmem(0xa0000 - 4096, 4096);
 699
 700 #ifdef CONFIG_SMP
 701         /*
 702          * But first pinch a few for the stack/trampoline stuff
 703          * FIXME: Don't need the extra page at 4K, but need to fix
 704          * trampoline before removing it. (see the GDT stuff)
 705          */
 706         reserve_bootmem(PAGE_SIZE, PAGE_SIZE);
 707 #endif
 708 #ifdef CONFIG_ACPI_SLEEP
 709         /*
 710          * Reserve low memory region for sleep support.
 711          */
 712         acpi_reserve_bootmem();
 713 #endif
 714 #ifdef CONFIG_X86_FIND_SMP_CONFIG
 715         /*
 716          * Find and reserve possible boot-time SMP configuration:
 717          */
 718         find_smp_config();
 719 #endif
 720         numa_kva_reserve();
 721 #ifdef CONFIG_BLK_DEV_INITRD
 722         if (LOADER_TYPE && INITRD_START) {
 723                 if (INITRD_START + INITRD_SIZE <= (max_low_pfn << PAGE_SHIFT)) {
 724                         reserve_bootmem(INITRD_START, INITRD_SIZE);
 725                         initrd_start =
 726                                 INITRD_START ? INITRD_START + PAGE_OFFSET : 0;
 727                         initrd_end = initrd_start+INITRD_SIZE;
 728                 }
 729                 else {
 730                         printk(KERN_ERR "initrd extends beyond end of memory "
 731                             "(0x%08lx > 0x%08lx)\ndisabling initrd\n",
 732                             INITRD_START + INITRD_SIZE,
 733                             max_low_pfn << PAGE_SHIFT);
 734                         initrd_start = 0;
 735                 }
 736         }
 737 #endif
 738 #ifdef CONFIG_KEXEC
 739         if (crashk_res.start != crashk_res.end)
 740                 reserve_bootmem(crashk_res.start,
 741                         crashk_res.end - crashk_res.start + 1);
 742 #endif
 743 }
 744
 745 /*
 746  * The node 0 pgdat is initialized before all of these because
 747  * it's needed for bootmem.  node>0 pgdats have their virtual
 748  * space allocated before the pagetables are in place to access
 749  * them, so they can't be cleared then.
 750  *
 751  * This should all compile down to nothing when NUMA is off.
 752  */
 753 void __init remapped_pgdat_init(void)
 754 {
 755         int nid;
 756
 757         for_each_online_node(nid) {
 758                 if (nid != 0)
 759                         memset(NODE_DATA(nid), 0, sizeof(struct pglist_data));
 760         }
 761 }
 762
 763
 764
 765 static void __init register_memory(void)
 766 {
 767         unsigned long gapstart, gapsize, round;
 768         unsigned long long last;
 769         int i;
 770
 771         /*
 772          * Search for the bigest gap in the low 32 bits of the e820
 773          * memory space.
 774          */
 775         last = 0x100000000ull;
 776         gapstart = 0x10000000;
 777         gapsize = 0x400000;
 778         i = e820.nr_map;
 779         while (--i >= 0) {
 780                 unsigned long long start = e820.map[i].addr;
 781                 unsigned long long end = start + e820.map[i].size;
 782
 783                 /*
 784                  * Since "last" is at most 4GB, we know we'll
 785                  * fit in 32 bits if this condition is true
 786                  */
 787                 if (last > end) {
 788                         unsigned long gap = last - end;
 789
 790                         if (gap > gapsize) {
 791                                 gapsize = gap;
 792                                 gapstart = end;
 793                         }
 794                 }
 795                 if (start < last)
 796                         last = start;
 797         }
 798
 799         /*
 800          * See how much we want to round up: start off with
 801          * rounding to the next 1MB area.
 802          */
 803         round = 0x100000;
 804         while ((gapsize >> 4) > round)
 805                 round += round;
 806         /* Fun with two's complement */
 807         pci_mem_start = (gapstart + round) & -round;
 808
 809         printk("Allocating PCI resources starting at %08lx (gap: %08lx:%08lx)\n",
 810                 pci_mem_start, gapstart, gapsize);
 811 }
 812
 813 #ifdef CONFIG_MCA
 814 static void set_mca_bus(int x)
 815 {
 816         MCA_bus = x;
 817 }
 818 #else
 819 static void set_mca_bus(int x) { }
 820 #endif
 821
 822 /*
 823  * Determine if we were loaded by an EFI loader.  If so, then we have also been
 824  * passed the efi memmap, systab, etc., so we should use these data structures
 825  * for initialization.  Note, the efi init code path is determined by the
 826  * global efi_enabled. This allows the same kernel image to be used on existing
 827  * systems (with a traditional BIOS) as well as on EFI systems.
 828  */
 829 void __init setup_arch(char **cmdline_p)
 830 {
 831         unsigned long max_low_pfn;
 832
 833         memcpy(&boot_cpu_data, &new_cpu_data, sizeof(new_cpu_data));
 834         pre_setup_arch_hook();
 835         early_cpu_init();
 836
 837         /*
 838          * FIXME: This isn't an official loader_type right
 839          * now but does currently work with elilo.
 840          * If we were configured as an EFI kernel, check to make
 841          * sure that we were loaded correctly from elilo and that
 842          * the system table is valid.  If not, then initialize normally.
 843          */
 844 #ifdef CONFIG_EFI
 845         if ((LOADER_TYPE == 0x50) && EFI_SYSTAB)
 846                 efi_enabled = 1;
 847 #endif
 848
 849         ROOT_DEV = old_decode_dev(ORIG_ROOT_DEV);
 850         drive_info = DRIVE_INFO;
 851         screen_info = SCREEN_INFO;
 852         edid_info = EDID_INFO;
 853         apm_info.bios = APM_BIOS_INFO;
 854         ist_info = IST_INFO;
 855         saved_videomode = VIDEO_MODE;
 856         if( SYS_DESC_TABLE.length != 0 ) {
 857                 set_mca_bus(SYS_DESC_TABLE.table[3] & 0x2);
 858                 machine_id = SYS_DESC_TABLE.table[0];
 859                 machine_submodel_id = SYS_DESC_TABLE.table[1];
 860                 BIOS_revision = SYS_DESC_TABLE.table[2];
 861         }
 862         bootloader_type = LOADER_TYPE;
 863
 864 #ifdef CONFIG_BLK_DEV_RAM
 865         rd_image_start = RAMDISK_FLAGS & RAMDISK_IMAGE_START_MASK;
 866         rd_prompt = ((RAMDISK_FLAGS & RAMDISK_PROMPT_FLAG) != 0);
 867         rd_doload = ((RAMDISK_FLAGS & RAMDISK_LOAD_FLAG) != 0);
 868 #endif
 869         ARCH_SETUP
 870         if (efi_enabled)
 871                 efi_init();
 872         else {
 873                 printk(KERN_INFO "BIOS-provided physical RAM map:\n");
 874                 print_memory_map(machine_specific_memory_setup());
 875         }
 876
 877         copy_edd();
 878
 879         if (!MOUNT_ROOT_RDONLY)
 880                 root_mountflags &= ~MS_RDONLY;
 881         init_mm.start_code = (unsigned long) _text;
 882         init_mm.end_code = (unsigned long) _etext;
 883         init_mm.end_data = (unsigned long) _edata;
 884         init_mm.brk = init_pg_tables_end + PAGE_OFFSET;
 885
 886         code_resource.start = virt_to_phys(_text);
 887         code_resource.end = virt_to_phys(_etext)-1;
 888         data_resource.start = virt_to_phys(_etext);
 889         data_resource.end = virt_to_phys(_edata)-1;
 890
 891         parse_early_param();
 892
 893         if (user_defined_memmap) {
 894                 printk(KERN_INFO "user-defined physical RAM map:\n");
 895                 print_memory_map("user");
 896         }
 897
 898         strlcpy(command_line, saved_command_line, COMMAND_LINE_SIZE);
 899         *cmdline_p = command_line;
 900
 901         max_low_pfn = setup_memory();
 902
 903         /*
 904          * NOTE: before this point _nobody_ is allowed to allocate
 905          * any memory using the bootmem allocator.  Although the
 906          * alloctor is now initialised only the first 8Mb of the kernel
 907          * virtual address space has been mapped.  All allocations before
 908          * paging_init() has completed must use the alloc_bootmem_low_pages()
 909          * variant (which allocates DMA'able memory) and care must be taken
 910          * not to exceed the 8Mb limit.
 911          */
 912
 913 #ifdef CONFIG_SMP
 914         smp_alloc_memory(); /* AP processor realmode stacks in low memory*/
 915 #endif
 916         paging_init();
 917         remapped_pgdat_init();
 918         sparse_init();
 919         zone_sizes_init();
 920
 921         /*
 922          * NOTE: at this point the bootmem allocator is fully available.
 923          */
 924
 925         dmi_scan_machine();
 926
 927 #ifdef CONFIG_X86_GENERICARCH
 928         generic_apic_probe();
 929 #endif
 930         if (efi_enabled)
 931                 efi_map_memmap();
 932
 933 #ifdef CONFIG_ACPI
 934         /*
 935          * Parse the ACPI tables for possible boot-time SMP configuration.
 936          */
 937         acpi_boot_table_init();
 938 #endif
 939
 940 #ifdef CONFIG_PCI
 941 #ifdef CONFIG_X86_IO_APIC
 942         check_acpi_pci();       /* Checks more than just ACPI actually */
 943 #endif
 944 #endif
 945
 946 #ifdef CONFIG_ACPI
 947         acpi_boot_init();
 948
 949 #if defined(CONFIG_SMP) && defined(CONFIG_X86_PC)
 950         if (def_to_bigsmp)
 951                 printk(KERN_WARNING "More than 8 CPUs detected and "
 952                         "CONFIG_X86_PC cannot handle it.\nUse "
 953                         "CONFIG_X86_GENERICARCH or CONFIG_X86_BIGSMP.\n");
 954 #endif
 955 #endif
 956 #ifdef CONFIG_X86_LOCAL_APIC
 957         if (smp_found_config)
 958                 get_smp_config();
 959 #endif
 960
 961         register_memory();
 962
 963 #ifdef CONFIG_VT
 964 #if defined(CONFIG_VGA_CONSOLE)
 965         if (!efi_enabled || (efi_mem_type(0xa0000) != EFI_CONVENTIONAL_MEMORY))
 966                 conswitchp = &vga_con;
 967 #elif defined(CONFIG_DUMMY_CONSOLE)
 968         conswitchp = &dummy_con;
 969 #endif
 970 #endif
 971         tsc_init();
 972 }
 973
 974 static __init int add_pcspkr(void)
 975 {
 976         struct platform_device *pd;
 977         int ret;
 978
 979         pd = platform_device_alloc("pcspkr", -1);
 980         if (!pd)
 981                 return -ENOMEM;
 982
 983         ret = platform_device_add(pd);
 984         if (ret)
 985                 platform_device_put(pd);
 986
 987         return ret;
 988 }
 989 device_initcall(add_pcspkr);
 990
 991 /*
 992  * Local Variables:
 993  * mode:c
 994  * c-file-style:"k&r"
 995  * c-basic-offset:8
 996  * End:
 997  */