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