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