1 /* 2 * Copyright (C) 1995 Linus Torvalds 3 * 4 * Support of BIGMEM added by Gerhard Wichert, Siemens AG, July 1999 5 * 6 * Memory region support 7 * David Parsons <orc@pell.chi.il.us>, July-August 1999 8 * 9 * Added E820 sanitization routine (removes overlapping memory regions); 10 * Brian Moyle <bmoyle@mvista.com>, February 2001 11 * 12 * Moved CPU detection code to cpu/${cpu}.c 13 * Patrick Mochel <mochel@osdl.org>, March 2002 14 * 15 * Provisions for empty E820 memory regions (reported by certain BIOSes). 16 * Alex Achenbach <xela@slit.de>, December 2002. 17 * 18 */ 19 20 /* 21 * This file handles the architecture-dependent parts of initialization 22 */ 23 24 #include <linux/sched.h> 25 #include <linux/mm.h> 26 #include <linux/mmzone.h> 27 #include <linux/screen_info.h> 28 #include <linux/ioport.h> 29 #include <linux/acpi.h> 30 #include <linux/sfi.h> 31 #include <linux/apm_bios.h> 32 #include <linux/initrd.h> 33 #include <linux/bootmem.h> 34 #include <linux/seq_file.h> 35 #include <linux/console.h> 36 #include <linux/mca.h> 37 #include <linux/root_dev.h> 38 #include <linux/highmem.h> 39 #include <linux/module.h> 40 #include <linux/efi.h> 41 #include <linux/init.h> 42 #include <linux/edd.h> 43 #include <linux/iscsi_ibft.h> 44 #include <linux/nodemask.h> 45 #include <linux/kexec.h> 46 #include <linux/dmi.h> 47 #include <linux/pfn.h> 48 #include <linux/pci.h> 49 #include <asm/pci-direct.h> 50 #include <linux/init_ohci1394_dma.h> 51 #include <linux/kvm_para.h> 52 53 #include <linux/errno.h> 54 #include <linux/kernel.h> 55 #include <linux/stddef.h> 56 #include <linux/unistd.h> 57 #include <linux/ptrace.h> 58 #include <linux/slab.h> 59 #include <linux/user.h> 60 #include <linux/delay.h> 61 62 #include <linux/kallsyms.h> 63 #include <linux/cpufreq.h> 64 #include <linux/dma-mapping.h> 65 #include <linux/ctype.h> 66 #include <linux/uaccess.h> 67 68 #include <linux/percpu.h> 69 #include <linux/crash_dump.h> 70 #include <linux/tboot.h> 71 72 #include <video/edid.h> 73 74 #include <asm/mtrr.h> 75 #include <asm/apic.h> 76 #include <asm/e820.h> 77 #include <asm/mpspec.h> 78 #include <asm/setup.h> 79 #include <asm/efi.h> 80 #include <asm/timer.h> 81 #include <asm/i8259.h> 82 #include <asm/sections.h> 83 #include <asm/dmi.h> 84 #include <asm/io_apic.h> 85 #include <asm/ist.h> 86 #include <asm/vmi.h> 87 #include <asm/setup_arch.h> 88 #include <asm/bios_ebda.h> 89 #include <asm/cacheflush.h> 90 #include <asm/processor.h> 91 #include <asm/bugs.h> 92 93 #include <asm/system.h> 94 #include <asm/vsyscall.h> 95 #include <asm/cpu.h> 96 #include <asm/desc.h> 97 #include <asm/dma.h> 98 #include <asm/iommu.h> 99 #include <asm/gart.h> 100 #include <asm/mmu_context.h> 101 #include <asm/proto.h> 102 103 #include <asm/paravirt.h> 104 #include <asm/hypervisor.h> 105 106 #include <asm/percpu.h> 107 #include <asm/topology.h> 108 #include <asm/apicdef.h> 109 #include <asm/k8.h> 110 #ifdef CONFIG_X86_64 111 #include <asm/numa_64.h> 112 #endif 113 #include <asm/mce.h> 114 115 /* 116 * end_pfn only includes RAM, while max_pfn_mapped includes all e820 entries. 117 * The direct mapping extends to max_pfn_mapped, so that we can directly access 118 * apertures, ACPI and other tables without having to play with fixmaps. 119 */ 120 unsigned long max_low_pfn_mapped; 121 unsigned long max_pfn_mapped; 122 123 RESERVE_BRK(dmi_alloc, 65536); 124 125 unsigned int boot_cpu_id __read_mostly; 126 127 static __initdata unsigned long _brk_start = (unsigned long)__brk_base; 128 unsigned long _brk_end = (unsigned long)__brk_base; 129 130 #ifdef CONFIG_X86_64 131 int default_cpu_present_to_apicid(int mps_cpu) 132 { 133 return __default_cpu_present_to_apicid(mps_cpu); 134 } 135 136 int default_check_phys_apicid_present(int phys_apicid) 137 { 138 return __default_check_phys_apicid_present(phys_apicid); 139 } 140 #endif 141 142 #ifndef CONFIG_DEBUG_BOOT_PARAMS 143 struct boot_params __initdata boot_params; 144 #else 145 struct boot_params boot_params; 146 #endif 147 148 /* 149 * Machine setup.. 150 */ 151 static struct resource data_resource = { 152 .name = "Kernel data", 153 .start = 0, 154 .end = 0, 155 .flags = IORESOURCE_BUSY | IORESOURCE_MEM 156 }; 157 158 static struct resource code_resource = { 159 .name = "Kernel code", 160 .start = 0, 161 .end = 0, 162 .flags = IORESOURCE_BUSY | IORESOURCE_MEM 163 }; 164 165 static struct resource bss_resource = { 166 .name = "Kernel bss", 167 .start = 0, 168 .end = 0, 169 .flags = IORESOURCE_BUSY | IORESOURCE_MEM 170 }; 171 172 173 #ifdef CONFIG_X86_32 174 /* cpu data as detected by the assembly code in head.S */ 175 struct cpuinfo_x86 new_cpu_data __cpuinitdata = {0, 0, 0, 0, -1, 1, 0, 0, -1}; 176 /* common cpu data for all cpus */ 177 struct cpuinfo_x86 boot_cpu_data __read_mostly = {0, 0, 0, 0, -1, 1, 0, 0, -1}; 178 EXPORT_SYMBOL(boot_cpu_data); 179 static void set_mca_bus(int x) 180 { 181 #ifdef CONFIG_MCA 182 MCA_bus = x; 183 #endif 184 } 185 186 unsigned int def_to_bigsmp; 187 188 /* for MCA, but anyone else can use it if they want */ 189 unsigned int machine_id; 190 unsigned int machine_submodel_id; 191 unsigned int BIOS_revision; 192 193 struct apm_info apm_info; 194 EXPORT_SYMBOL(apm_info); 195 196 #if defined(CONFIG_X86_SPEEDSTEP_SMI) || \ 197 defined(CONFIG_X86_SPEEDSTEP_SMI_MODULE) 198 struct ist_info ist_info; 199 EXPORT_SYMBOL(ist_info); 200 #else 201 struct ist_info ist_info; 202 #endif 203 204 #else 205 struct cpuinfo_x86 boot_cpu_data __read_mostly = { 206 .x86_phys_bits = MAX_PHYSMEM_BITS, 207 }; 208 EXPORT_SYMBOL(boot_cpu_data); 209 #endif 210 211 212 #if !defined(CONFIG_X86_PAE) || defined(CONFIG_X86_64) 213 unsigned long mmu_cr4_features; 214 #else 215 unsigned long mmu_cr4_features = X86_CR4_PAE; 216 #endif 217 218 /* Boot loader ID and version as integers, for the benefit of proc_dointvec */ 219 int bootloader_type, bootloader_version; 220 221 /* 222 * Setup options 223 */ 224 struct screen_info screen_info; 225 EXPORT_SYMBOL(screen_info); 226 struct edid_info edid_info; 227 EXPORT_SYMBOL_GPL(edid_info); 228 229 extern int root_mountflags; 230 231 unsigned long saved_video_mode; 232 233 #define RAMDISK_IMAGE_START_MASK 0x07FF 234 #define RAMDISK_PROMPT_FLAG 0x8000 235 #define RAMDISK_LOAD_FLAG 0x4000 236 237 static char __initdata command_line[COMMAND_LINE_SIZE]; 238 #ifdef CONFIG_CMDLINE_BOOL 239 static char __initdata builtin_cmdline[COMMAND_LINE_SIZE] = CONFIG_CMDLINE; 240 #endif 241 242 #if defined(CONFIG_EDD) || defined(CONFIG_EDD_MODULE) 243 struct edd edd; 244 #ifdef CONFIG_EDD_MODULE 245 EXPORT_SYMBOL(edd); 246 #endif 247 /** 248 * copy_edd() - Copy the BIOS EDD information 249 * from boot_params into a safe place. 250 * 251 */ 252 static inline void __init copy_edd(void) 253 { 254 memcpy(edd.mbr_signature, boot_params.edd_mbr_sig_buffer, 255 sizeof(edd.mbr_signature)); 256 memcpy(edd.edd_info, boot_params.eddbuf, sizeof(edd.edd_info)); 257 edd.mbr_signature_nr = boot_params.edd_mbr_sig_buf_entries; 258 edd.edd_info_nr = boot_params.eddbuf_entries; 259 } 260 #else 261 static inline void __init copy_edd(void) 262 { 263 } 264 #endif 265 266 void * __init extend_brk(size_t size, size_t align) 267 { 268 size_t mask = align - 1; 269 void *ret; 270 271 BUG_ON(_brk_start == 0); 272 BUG_ON(align & mask); 273 274 _brk_end = (_brk_end + mask) & ~mask; 275 BUG_ON((char *)(_brk_end + size) > __brk_limit); 276 277 ret = (void *)_brk_end; 278 _brk_end += size; 279 280 memset(ret, 0, size); 281 282 return ret; 283 } 284 285 #ifdef CONFIG_X86_64 286 static void __init init_gbpages(void) 287 { 288 if (direct_gbpages && cpu_has_gbpages) 289 printk(KERN_INFO "Using GB pages for direct mapping\n"); 290 else 291 direct_gbpages = 0; 292 } 293 #else 294 static inline void init_gbpages(void) 295 { 296 } 297 #endif 298 299 static void __init reserve_brk(void) 300 { 301 if (_brk_end > _brk_start) 302 reserve_early(__pa(_brk_start), __pa(_brk_end), "BRK"); 303 304 /* Mark brk area as locked down and no longer taking any 305 new allocations */ 306 _brk_start = 0; 307 } 308 309 #ifdef CONFIG_BLK_DEV_INITRD 310 311 #define MAX_MAP_CHUNK (NR_FIX_BTMAPS << PAGE_SHIFT) 312 static void __init relocate_initrd(void) 313 { 314 315 u64 ramdisk_image = boot_params.hdr.ramdisk_image; 316 u64 ramdisk_size = boot_params.hdr.ramdisk_size; 317 u64 end_of_lowmem = max_low_pfn_mapped << PAGE_SHIFT; 318 u64 ramdisk_here; 319 unsigned long slop, clen, mapaddr; 320 char *p, *q; 321 322 /* We need to move the initrd down into lowmem */ 323 ramdisk_here = find_e820_area(0, end_of_lowmem, ramdisk_size, 324 PAGE_SIZE); 325 326 if (ramdisk_here == -1ULL) 327 panic("Cannot find place for new RAMDISK of size %lld\n", 328 ramdisk_size); 329 330 /* Note: this includes all the lowmem currently occupied by 331 the initrd, we rely on that fact to keep the data intact. */ 332 reserve_early(ramdisk_here, ramdisk_here + ramdisk_size, 333 "NEW RAMDISK"); 334 initrd_start = ramdisk_here + PAGE_OFFSET; 335 initrd_end = initrd_start + ramdisk_size; 336 printk(KERN_INFO "Allocated new RAMDISK: %08llx - %08llx\n", 337 ramdisk_here, ramdisk_here + ramdisk_size); 338 339 q = (char *)initrd_start; 340 341 /* Copy any lowmem portion of the initrd */ 342 if (ramdisk_image < end_of_lowmem) { 343 clen = end_of_lowmem - ramdisk_image; 344 p = (char *)__va(ramdisk_image); 345 memcpy(q, p, clen); 346 q += clen; 347 ramdisk_image += clen; 348 ramdisk_size -= clen; 349 } 350 351 /* Copy the highmem portion of the initrd */ 352 while (ramdisk_size) { 353 slop = ramdisk_image & ~PAGE_MASK; 354 clen = ramdisk_size; 355 if (clen > MAX_MAP_CHUNK-slop) 356 clen = MAX_MAP_CHUNK-slop; 357 mapaddr = ramdisk_image & PAGE_MASK; 358 p = early_memremap(mapaddr, clen+slop); 359 memcpy(q, p+slop, clen); 360 early_iounmap(p, clen+slop); 361 q += clen; 362 ramdisk_image += clen; 363 ramdisk_size -= clen; 364 } 365 /* high pages is not converted by early_res_to_bootmem */ 366 ramdisk_image = boot_params.hdr.ramdisk_image; 367 ramdisk_size = boot_params.hdr.ramdisk_size; 368 printk(KERN_INFO "Move RAMDISK from %016llx - %016llx to" 369 " %08llx - %08llx\n", 370 ramdisk_image, ramdisk_image + ramdisk_size - 1, 371 ramdisk_here, ramdisk_here + ramdisk_size - 1); 372 } 373 374 static void __init reserve_initrd(void) 375 { 376 u64 ramdisk_image = boot_params.hdr.ramdisk_image; 377 u64 ramdisk_size = boot_params.hdr.ramdisk_size; 378 u64 ramdisk_end = ramdisk_image + ramdisk_size; 379 u64 end_of_lowmem = max_low_pfn_mapped << PAGE_SHIFT; 380 381 if (!boot_params.hdr.type_of_loader || 382 !ramdisk_image || !ramdisk_size) 383 return; /* No initrd provided by bootloader */ 384 385 initrd_start = 0; 386 387 if (ramdisk_size >= (end_of_lowmem>>1)) { 388 free_early(ramdisk_image, ramdisk_end); 389 printk(KERN_ERR "initrd too large to handle, " 390 "disabling initrd\n"); 391 return; 392 } 393 394 printk(KERN_INFO "RAMDISK: %08llx - %08llx\n", ramdisk_image, 395 ramdisk_end); 396 397 398 if (ramdisk_end <= end_of_lowmem) { 399 /* All in lowmem, easy case */ 400 /* 401 * don't need to reserve again, already reserved early 402 * in i386_start_kernel 403 */ 404 initrd_start = ramdisk_image + PAGE_OFFSET; 405 initrd_end = initrd_start + ramdisk_size; 406 return; 407 } 408 409 relocate_initrd(); 410 411 free_early(ramdisk_image, ramdisk_end); 412 } 413 #else 414 static void __init reserve_initrd(void) 415 { 416 } 417 #endif /* CONFIG_BLK_DEV_INITRD */ 418 419 static void __init parse_setup_data(void) 420 { 421 struct setup_data *data; 422 u64 pa_data; 423 424 if (boot_params.hdr.version < 0x0209) 425 return; 426 pa_data = boot_params.hdr.setup_data; 427 while (pa_data) { 428 data = early_memremap(pa_data, PAGE_SIZE); 429 switch (data->type) { 430 case SETUP_E820_EXT: 431 parse_e820_ext(data, pa_data); 432 break; 433 default: 434 break; 435 } 436 pa_data = data->next; 437 early_iounmap(data, PAGE_SIZE); 438 } 439 } 440 441 static void __init e820_reserve_setup_data(void) 442 { 443 struct setup_data *data; 444 u64 pa_data; 445 int found = 0; 446 447 if (boot_params.hdr.version < 0x0209) 448 return; 449 pa_data = boot_params.hdr.setup_data; 450 while (pa_data) { 451 data = early_memremap(pa_data, sizeof(*data)); 452 e820_update_range(pa_data, sizeof(*data)+data->len, 453 E820_RAM, E820_RESERVED_KERN); 454 found = 1; 455 pa_data = data->next; 456 early_iounmap(data, sizeof(*data)); 457 } 458 if (!found) 459 return; 460 461 sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map); 462 memcpy(&e820_saved, &e820, sizeof(struct e820map)); 463 printk(KERN_INFO "extended physical RAM map:\n"); 464 e820_print_map("reserve setup_data"); 465 } 466 467 static void __init reserve_early_setup_data(void) 468 { 469 struct setup_data *data; 470 u64 pa_data; 471 char buf[32]; 472 473 if (boot_params.hdr.version < 0x0209) 474 return; 475 pa_data = boot_params.hdr.setup_data; 476 while (pa_data) { 477 data = early_memremap(pa_data, sizeof(*data)); 478 sprintf(buf, "setup data %x", data->type); 479 reserve_early(pa_data, pa_data+sizeof(*data)+data->len, buf); 480 pa_data = data->next; 481 early_iounmap(data, sizeof(*data)); 482 } 483 } 484 485 /* 486 * --------- Crashkernel reservation ------------------------------ 487 */ 488 489 #ifdef CONFIG_KEXEC 490 491 static inline unsigned long long get_total_mem(void) 492 { 493 unsigned long long total; 494 495 total = max_pfn - min_low_pfn; 496 497 return total << PAGE_SHIFT; 498 } 499 500 static void __init reserve_crashkernel(void) 501 { 502 unsigned long long total_mem; 503 unsigned long long crash_size, crash_base; 504 int ret; 505 506 total_mem = get_total_mem(); 507 508 ret = parse_crashkernel(boot_command_line, total_mem, 509 &crash_size, &crash_base); 510 if (ret != 0 || crash_size <= 0) 511 return; 512 513 /* 0 means: find the address automatically */ 514 if (crash_base <= 0) { 515 const unsigned long long alignment = 16<<20; /* 16M */ 516 517 crash_base = find_e820_area(alignment, ULONG_MAX, crash_size, 518 alignment); 519 if (crash_base == -1ULL) { 520 pr_info("crashkernel reservation failed - No suitable area found.\n"); 521 return; 522 } 523 } else { 524 unsigned long long start; 525 526 start = find_e820_area(crash_base, ULONG_MAX, crash_size, 527 1<<20); 528 if (start != crash_base) { 529 pr_info("crashkernel reservation failed - memory is in use.\n"); 530 return; 531 } 532 } 533 reserve_early(crash_base, crash_base + crash_size, "CRASH KERNEL"); 534 535 printk(KERN_INFO "Reserving %ldMB of memory at %ldMB " 536 "for crashkernel (System RAM: %ldMB)\n", 537 (unsigned long)(crash_size >> 20), 538 (unsigned long)(crash_base >> 20), 539 (unsigned long)(total_mem >> 20)); 540 541 crashk_res.start = crash_base; 542 crashk_res.end = crash_base + crash_size - 1; 543 insert_resource(&iomem_resource, &crashk_res); 544 } 545 #else 546 static void __init reserve_crashkernel(void) 547 { 548 } 549 #endif 550 551 static struct resource standard_io_resources[] = { 552 { .name = "dma1", .start = 0x00, .end = 0x1f, 553 .flags = IORESOURCE_BUSY | IORESOURCE_IO }, 554 { .name = "pic1", .start = 0x20, .end = 0x21, 555 .flags = IORESOURCE_BUSY | IORESOURCE_IO }, 556 { .name = "timer0", .start = 0x40, .end = 0x43, 557 .flags = IORESOURCE_BUSY | IORESOURCE_IO }, 558 { .name = "timer1", .start = 0x50, .end = 0x53, 559 .flags = IORESOURCE_BUSY | IORESOURCE_IO }, 560 { .name = "keyboard", .start = 0x60, .end = 0x60, 561 .flags = IORESOURCE_BUSY | IORESOURCE_IO }, 562 { .name = "keyboard", .start = 0x64, .end = 0x64, 563 .flags = IORESOURCE_BUSY | IORESOURCE_IO }, 564 { .name = "dma page reg", .start = 0x80, .end = 0x8f, 565 .flags = IORESOURCE_BUSY | IORESOURCE_IO }, 566 { .name = "pic2", .start = 0xa0, .end = 0xa1, 567 .flags = IORESOURCE_BUSY | IORESOURCE_IO }, 568 { .name = "dma2", .start = 0xc0, .end = 0xdf, 569 .flags = IORESOURCE_BUSY | IORESOURCE_IO }, 570 { .name = "fpu", .start = 0xf0, .end = 0xff, 571 .flags = IORESOURCE_BUSY | IORESOURCE_IO } 572 }; 573 574 void __init reserve_standard_io_resources(void) 575 { 576 int i; 577 578 /* request I/O space for devices used on all i[345]86 PCs */ 579 for (i = 0; i < ARRAY_SIZE(standard_io_resources); i++) 580 request_resource(&ioport_resource, &standard_io_resources[i]); 581 582 } 583 584 /* 585 * Note: elfcorehdr_addr is not just limited to vmcore. It is also used by 586 * is_kdump_kernel() to determine if we are booting after a panic. Hence 587 * ifdef it under CONFIG_CRASH_DUMP and not CONFIG_PROC_VMCORE. 588 */ 589 590 #ifdef CONFIG_CRASH_DUMP 591 /* elfcorehdr= specifies the location of elf core header 592 * stored by the crashed kernel. This option will be passed 593 * by kexec loader to the capture kernel. 594 */ 595 static int __init setup_elfcorehdr(char *arg) 596 { 597 char *end; 598 if (!arg) 599 return -EINVAL; 600 elfcorehdr_addr = memparse(arg, &end); 601 return end > arg ? 0 : -EINVAL; 602 } 603 early_param("elfcorehdr", setup_elfcorehdr); 604 #endif 605 606 #ifdef CONFIG_X86_RESERVE_LOW_64K 607 static int __init dmi_low_memory_corruption(const struct dmi_system_id *d) 608 { 609 printk(KERN_NOTICE 610 "%s detected: BIOS may corrupt low RAM, working around it.\n", 611 d->ident); 612 613 e820_update_range(0, 0x10000, E820_RAM, E820_RESERVED); 614 sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map); 615 616 return 0; 617 } 618 #endif 619 620 /* List of systems that have known low memory corruption BIOS problems */ 621 static struct dmi_system_id __initdata bad_bios_dmi_table[] = { 622 #ifdef CONFIG_X86_RESERVE_LOW_64K 623 { 624 .callback = dmi_low_memory_corruption, 625 .ident = "AMI BIOS", 626 .matches = { 627 DMI_MATCH(DMI_BIOS_VENDOR, "American Megatrends Inc."), 628 }, 629 }, 630 { 631 .callback = dmi_low_memory_corruption, 632 .ident = "Phoenix BIOS", 633 .matches = { 634 DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies"), 635 }, 636 }, 637 { 638 .callback = dmi_low_memory_corruption, 639 .ident = "Phoenix/MSC BIOS", 640 .matches = { 641 DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix/MSC"), 642 }, 643 }, 644 { 645 /* 646 * AMI BIOS with low memory corruption was found on Intel DG45ID board. 647 * It hase different DMI_BIOS_VENDOR = "Intel Corp.", for now we will 648 * match only DMI_BOARD_NAME and see if there is more bad products 649 * with this vendor. 650 */ 651 .callback = dmi_low_memory_corruption, 652 .ident = "AMI BIOS", 653 .matches = { 654 DMI_MATCH(DMI_BOARD_NAME, "DG45ID"), 655 }, 656 }, 657 #endif 658 {} 659 }; 660 661 /* 662 * Determine if we were loaded by an EFI loader. If so, then we have also been 663 * passed the efi memmap, systab, etc., so we should use these data structures 664 * for initialization. Note, the efi init code path is determined by the 665 * global efi_enabled. This allows the same kernel image to be used on existing 666 * systems (with a traditional BIOS) as well as on EFI systems. 667 */ 668 /* 669 * setup_arch - architecture-specific boot-time initializations 670 * 671 * Note: On x86_64, fixmaps are ready for use even before this is called. 672 */ 673 674 void __init setup_arch(char **cmdline_p) 675 { 676 int acpi = 0; 677 int k8 = 0; 678 679 #ifdef CONFIG_X86_32 680 memcpy(&boot_cpu_data, &new_cpu_data, sizeof(new_cpu_data)); 681 visws_early_detect(); 682 #else 683 printk(KERN_INFO "Command line: %s\n", boot_command_line); 684 #endif 685 686 /* VMI may relocate the fixmap; do this before touching ioremap area */ 687 vmi_init(); 688 689 early_cpu_init(); 690 early_ioremap_init(); 691 692 ROOT_DEV = old_decode_dev(boot_params.hdr.root_dev); 693 screen_info = boot_params.screen_info; 694 edid_info = boot_params.edid_info; 695 #ifdef CONFIG_X86_32 696 apm_info.bios = boot_params.apm_bios_info; 697 ist_info = boot_params.ist_info; 698 if (boot_params.sys_desc_table.length != 0) { 699 set_mca_bus(boot_params.sys_desc_table.table[3] & 0x2); 700 machine_id = boot_params.sys_desc_table.table[0]; 701 machine_submodel_id = boot_params.sys_desc_table.table[1]; 702 BIOS_revision = boot_params.sys_desc_table.table[2]; 703 } 704 #endif 705 saved_video_mode = boot_params.hdr.vid_mode; 706 bootloader_type = boot_params.hdr.type_of_loader; 707 if ((bootloader_type >> 4) == 0xe) { 708 bootloader_type &= 0xf; 709 bootloader_type |= (boot_params.hdr.ext_loader_type+0x10) << 4; 710 } 711 bootloader_version = bootloader_type & 0xf; 712 bootloader_version |= boot_params.hdr.ext_loader_ver << 4; 713 714 #ifdef CONFIG_BLK_DEV_RAM 715 rd_image_start = boot_params.hdr.ram_size & RAMDISK_IMAGE_START_MASK; 716 rd_prompt = ((boot_params.hdr.ram_size & RAMDISK_PROMPT_FLAG) != 0); 717 rd_doload = ((boot_params.hdr.ram_size & RAMDISK_LOAD_FLAG) != 0); 718 #endif 719 #ifdef CONFIG_EFI 720 if (!strncmp((char *)&boot_params.efi_info.efi_loader_signature, 721 #ifdef CONFIG_X86_32 722 "EL32", 723 #else 724 "EL64", 725 #endif 726 4)) { 727 efi_enabled = 1; 728 efi_reserve_early(); 729 } 730 #endif 731 732 x86_init.oem.arch_setup(); 733 734 setup_memory_map(); 735 parse_setup_data(); 736 /* update the e820_saved too */ 737 e820_reserve_setup_data(); 738 739 copy_edd(); 740 741 if (!boot_params.hdr.root_flags) 742 root_mountflags &= ~MS_RDONLY; 743 init_mm.start_code = (unsigned long) _text; 744 init_mm.end_code = (unsigned long) _etext; 745 init_mm.end_data = (unsigned long) _edata; 746 init_mm.brk = _brk_end; 747 748 code_resource.start = virt_to_phys(_text); 749 code_resource.end = virt_to_phys(_etext)-1; 750 data_resource.start = virt_to_phys(_etext); 751 data_resource.end = virt_to_phys(_edata)-1; 752 bss_resource.start = virt_to_phys(&__bss_start); 753 bss_resource.end = virt_to_phys(&__bss_stop)-1; 754 755 #ifdef CONFIG_CMDLINE_BOOL 756 #ifdef CONFIG_CMDLINE_OVERRIDE 757 strlcpy(boot_command_line, builtin_cmdline, COMMAND_LINE_SIZE); 758 #else 759 if (builtin_cmdline[0]) { 760 /* append boot loader cmdline to builtin */ 761 strlcat(builtin_cmdline, " ", COMMAND_LINE_SIZE); 762 strlcat(builtin_cmdline, boot_command_line, COMMAND_LINE_SIZE); 763 strlcpy(boot_command_line, builtin_cmdline, COMMAND_LINE_SIZE); 764 } 765 #endif 766 #endif 767 768 strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE); 769 *cmdline_p = command_line; 770 771 /* 772 * x86_configure_nx() is called before parse_early_param() to detect 773 * whether hardware doesn't support NX (so that the early EHCI debug 774 * console setup can safely call set_fixmap()). It may then be called 775 * again from within noexec_setup() during parsing early parameters 776 * to honor the respective command line option. 777 */ 778 x86_configure_nx(); 779 780 parse_early_param(); 781 782 x86_report_nx(); 783 784 /* Must be before kernel pagetables are setup */ 785 vmi_activate(); 786 787 /* after early param, so could get panic from serial */ 788 reserve_early_setup_data(); 789 790 if (acpi_mps_check()) { 791 #ifdef CONFIG_X86_LOCAL_APIC 792 disable_apic = 1; 793 #endif 794 setup_clear_cpu_cap(X86_FEATURE_APIC); 795 } 796 797 #ifdef CONFIG_PCI 798 if (pci_early_dump_regs) 799 early_dump_pci_devices(); 800 #endif 801 802 finish_e820_parsing(); 803 804 if (efi_enabled) 805 efi_init(); 806 807 dmi_scan_machine(); 808 809 dmi_check_system(bad_bios_dmi_table); 810 811 /* 812 * VMware detection requires dmi to be available, so this 813 * needs to be done after dmi_scan_machine, for the BP. 814 */ 815 init_hypervisor_platform(); 816 817 x86_init.resources.probe_roms(); 818 819 /* after parse_early_param, so could debug it */ 820 insert_resource(&iomem_resource, &code_resource); 821 insert_resource(&iomem_resource, &data_resource); 822 insert_resource(&iomem_resource, &bss_resource); 823 824 825 #ifdef CONFIG_X86_32 826 if (ppro_with_ram_bug()) { 827 e820_update_range(0x70000000ULL, 0x40000ULL, E820_RAM, 828 E820_RESERVED); 829 sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map); 830 printk(KERN_INFO "fixed physical RAM map:\n"); 831 e820_print_map("bad_ppro"); 832 } 833 #else 834 early_gart_iommu_check(); 835 #endif 836 837 /* 838 * partially used pages are not usable - thus 839 * we are rounding upwards: 840 */ 841 max_pfn = e820_end_of_ram_pfn(); 842 843 /* preallocate 4k for mptable mpc */ 844 early_reserve_e820_mpc_new(); 845 /* update e820 for memory not covered by WB MTRRs */ 846 mtrr_bp_init(); 847 if (mtrr_trim_uncached_memory(max_pfn)) 848 max_pfn = e820_end_of_ram_pfn(); 849 850 #ifdef CONFIG_X86_32 851 /* max_low_pfn get updated here */ 852 find_low_pfn_range(); 853 #else 854 num_physpages = max_pfn; 855 856 check_x2apic(); 857 858 /* How many end-of-memory variables you have, grandma! */ 859 /* need this before calling reserve_initrd */ 860 if (max_pfn > (1UL<<(32 - PAGE_SHIFT))) 861 max_low_pfn = e820_end_of_low_ram_pfn(); 862 else 863 max_low_pfn = max_pfn; 864 865 high_memory = (void *)__va(max_pfn * PAGE_SIZE - 1) + 1; 866 max_pfn_mapped = KERNEL_IMAGE_SIZE >> PAGE_SHIFT; 867 #endif 868 869 #ifdef CONFIG_X86_CHECK_BIOS_CORRUPTION 870 setup_bios_corruption_check(); 871 #endif 872 873 printk(KERN_DEBUG "initial memory mapped : 0 - %08lx\n", 874 max_pfn_mapped<<PAGE_SHIFT); 875 876 reserve_brk(); 877 878 #ifdef CONFIG_ACPI_SLEEP 879 /* 880 * Reserve low memory region for sleep support. 881 * even before init_memory_mapping 882 */ 883 acpi_reserve_wakeup_memory(); 884 #endif 885 init_gbpages(); 886 887 /* max_pfn_mapped is updated here */ 888 max_low_pfn_mapped = init_memory_mapping(0, max_low_pfn<<PAGE_SHIFT); 889 max_pfn_mapped = max_low_pfn_mapped; 890 891 #ifdef CONFIG_X86_64 892 if (max_pfn > max_low_pfn) { 893 max_pfn_mapped = init_memory_mapping(1UL<<32, 894 max_pfn<<PAGE_SHIFT); 895 /* can we preseve max_low_pfn ?*/ 896 max_low_pfn = max_pfn; 897 } 898 #endif 899 900 /* 901 * NOTE: On x86-32, only from this point on, fixmaps are ready for use. 902 */ 903 904 #ifdef CONFIG_PROVIDE_OHCI1394_DMA_INIT 905 if (init_ohci1394_dma_early) 906 init_ohci1394_dma_on_all_controllers(); 907 #endif 908 909 reserve_initrd(); 910 911 reserve_crashkernel(); 912 913 vsmp_init(); 914 915 io_delay_init(); 916 917 /* 918 * Parse the ACPI tables for possible boot-time SMP configuration. 919 */ 920 acpi_boot_table_init(); 921 922 early_acpi_boot_init(); 923 924 /* 925 * Find and reserve possible boot-time SMP configuration: 926 */ 927 find_smp_config(); 928 929 #ifdef CONFIG_ACPI_NUMA 930 /* 931 * Parse SRAT to discover nodes. 932 */ 933 acpi = acpi_numa_init(); 934 #endif 935 936 #ifdef CONFIG_K8_NUMA 937 if (!acpi) 938 k8 = !k8_numa_init(0, max_pfn); 939 #endif 940 941 initmem_init(0, max_pfn, acpi, k8); 942 943 #ifdef CONFIG_X86_64 944 /* 945 * dma32_reserve_bootmem() allocates bootmem which may conflict 946 * with the crashkernel command line, so do that after 947 * reserve_crashkernel() 948 */ 949 dma32_reserve_bootmem(); 950 #endif 951 952 reserve_ibft_region(); 953 954 #ifdef CONFIG_KVM_CLOCK 955 kvmclock_init(); 956 #endif 957 958 x86_init.paging.pagetable_setup_start(swapper_pg_dir); 959 paging_init(); 960 x86_init.paging.pagetable_setup_done(swapper_pg_dir); 961 962 tboot_probe(); 963 964 #ifdef CONFIG_X86_64 965 map_vsyscall(); 966 #endif 967 968 generic_apic_probe(); 969 970 early_quirks(); 971 972 /* 973 * Read APIC and some other early information from ACPI tables. 974 */ 975 acpi_boot_init(); 976 977 sfi_init(); 978 979 /* 980 * get boot-time SMP configuration: 981 */ 982 if (smp_found_config) 983 get_smp_config(); 984 985 prefill_possible_map(); 986 987 #ifdef CONFIG_X86_64 988 init_cpu_to_node(); 989 #endif 990 991 init_apic_mappings(); 992 ioapic_init_mappings(); 993 994 /* need to wait for io_apic is mapped */ 995 probe_nr_irqs_gsi(); 996 997 kvm_guest_init(); 998 999 e820_reserve_resources(); 1000 e820_mark_nosave_regions(max_low_pfn); 1001 1002 x86_init.resources.reserve_resources(); 1003 1004 e820_setup_gap(); 1005 1006 #ifdef CONFIG_VT 1007 #if defined(CONFIG_VGA_CONSOLE) 1008 if (!efi_enabled || (efi_mem_type(0xa0000) != EFI_CONVENTIONAL_MEMORY)) 1009 conswitchp = &vga_con; 1010 #elif defined(CONFIG_DUMMY_CONSOLE) 1011 conswitchp = &dummy_con; 1012 #endif 1013 #endif 1014 x86_init.oem.banner(); 1015 1016 mcheck_init(); 1017 } 1018 1019 #ifdef CONFIG_X86_32 1020 1021 static struct resource video_ram_resource = { 1022 .name = "Video RAM area", 1023 .start = 0xa0000, 1024 .end = 0xbffff, 1025 .flags = IORESOURCE_BUSY | IORESOURCE_MEM 1026 }; 1027 1028 void __init i386_reserve_resources(void) 1029 { 1030 request_resource(&iomem_resource, &video_ram_resource); 1031 reserve_standard_io_resources(); 1032 } 1033 1034 #endif /* CONFIG_X86_32 */ 1035