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