2 * linux/arch/i386/kernel/setup.c
4 * Copyright (C) 1995 Linus Torvalds
6 * Support of BIGMEM added by Gerhard Wichert, Siemens AG, July 1999
8 * Memory region support
9 * David Parsons <orc@pell.chi.il.us>, July-August 1999
11 * Added E820 sanitization routine (removes overlapping memory regions);
12 * Brian Moyle <bmoyle@mvista.com>, February 2001
14 * Moved CPU detection code to cpu/${cpu}.c
15 * Patrick Mochel <mochel@osdl.org>, March 2002
17 * Provisions for empty E820 memory regions (reported by certain BIOSes).
18 * Alex Achenbach <xela@slit.de>, December 2002.
23 * This file handles the architecture-dependent parts of initialization
26 #include <linux/sched.h>
28 #include <linux/tty.h>
29 #include <linux/ioport.h>
30 #include <linux/acpi.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/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 <video/edid.h>
44 #include <asm/mpspec.h>
45 #include <asm/setup.h>
46 #include <asm/arch_hooks.h>
47 #include <asm/sections.h>
48 #include <asm/io_apic.h>
51 #include "setup_arch_pre.h"
53 /* This value is set up by the early boot code to point to the value
54 immediately after the boot time page tables. It contains a *physical*
55 address, and must not be in the .bss segment! */
56 unsigned long init_pg_tables_end __initdata = ~0UL;
58 int disable_pse __initdata = 0;
60 static inline char * __init machine_specific_memory_setup(void);
68 EXPORT_SYMBOL(efi_enabled);
71 /* cpu data as detected by the assembly code in head.S */
72 struct cpuinfo_x86 new_cpu_data __initdata = { 0, 0, 0, 0, -1, 1, 0, 0, -1 };
73 /* common cpu data for all cpus */
74 struct cpuinfo_x86 boot_cpu_data = { 0, 0, 0, 0, -1, 1, 0, 0, -1 };
76 unsigned long mmu_cr4_features;
77 EXPORT_SYMBOL_GPL(mmu_cr4_features);
79 #ifdef CONFIG_ACPI_INTERPRETER
80 int acpi_disabled = 0;
82 int acpi_disabled = 1;
84 EXPORT_SYMBOL(acpi_disabled);
86 #ifdef CONFIG_ACPI_BOOT
87 int __initdata acpi_force = 0;
88 extern acpi_interrupt_flags acpi_sci_flags;
92 /* for MCA, but anyone else can use it if they want */
93 unsigned int machine_id;
94 unsigned int machine_submodel_id;
95 unsigned int BIOS_revision;
96 unsigned int mca_pentium_flag;
98 /* For PCI or other memory-mapped resources */
99 unsigned long pci_mem_start = 0x10000000;
101 /* user-defined highmem size */
102 static unsigned int highmem_pages = -1;
107 struct drive_info_struct { char dummy[32]; } drive_info;
108 struct screen_info screen_info;
109 struct apm_info apm_info;
110 struct sys_desc_table_struct {
111 unsigned short length;
112 unsigned char table[0];
114 struct edid_info edid_info;
115 struct ist_info ist_info;
118 unsigned char aux_device_present;
120 extern void early_cpu_init(void);
121 extern void dmi_scan_machine(void);
122 extern void generic_apic_probe(char *);
123 extern int root_mountflags;
125 unsigned long saved_videomode;
127 #define RAMDISK_IMAGE_START_MASK 0x07FF
128 #define RAMDISK_PROMPT_FLAG 0x8000
129 #define RAMDISK_LOAD_FLAG 0x4000
131 static char command_line[COMMAND_LINE_SIZE];
132 char saved_command_line[COMMAND_LINE_SIZE];
134 unsigned char __initdata boot_params[PARAM_SIZE];
136 static struct resource data_resource = {
137 .name = "Kernel data",
140 .flags = IORESOURCE_BUSY | IORESOURCE_MEM
143 static struct resource code_resource = {
144 .name = "Kernel code",
147 .flags = IORESOURCE_BUSY | IORESOURCE_MEM
150 static struct resource system_rom_resource = {
151 .name = "System ROM",
154 .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
157 static struct resource extension_rom_resource = {
158 .name = "Extension ROM",
161 .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
164 static struct resource adapter_rom_resources[] = { {
165 .name = "Adapter ROM",
168 .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
170 .name = "Adapter ROM",
173 .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
175 .name = "Adapter ROM",
178 .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
180 .name = "Adapter ROM",
183 .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
185 .name = "Adapter ROM",
188 .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
190 .name = "Adapter ROM",
193 .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
196 #define ADAPTER_ROM_RESOURCES \
197 (sizeof adapter_rom_resources / sizeof adapter_rom_resources[0])
199 static struct resource video_rom_resource = {
203 .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
206 static struct resource video_ram_resource = {
207 .name = "Video RAM area",
210 .flags = IORESOURCE_BUSY | IORESOURCE_MEM
213 static struct resource standard_io_resources[] = { {
217 .flags = IORESOURCE_BUSY | IORESOURCE_IO
222 .flags = IORESOURCE_BUSY | IORESOURCE_IO
227 .flags = IORESOURCE_BUSY | IORESOURCE_IO
232 .flags = IORESOURCE_BUSY | IORESOURCE_IO
234 .name = "dma page reg",
237 .flags = IORESOURCE_BUSY | IORESOURCE_IO
242 .flags = IORESOURCE_BUSY | IORESOURCE_IO
247 .flags = IORESOURCE_BUSY | IORESOURCE_IO
252 .flags = IORESOURCE_BUSY | IORESOURCE_IO
255 #define STANDARD_IO_RESOURCES \
256 (sizeof standard_io_resources / sizeof standard_io_resources[0])
258 #define romsignature(x) (*(unsigned short *)(x) == 0xaa55)
260 static int __init romchecksum(unsigned char *rom, unsigned long length)
262 unsigned char *p, sum = 0;
264 for (p = rom; p < rom + length; p++)
269 static void __init probe_roms(void)
271 unsigned long start, length, upper;
276 upper = adapter_rom_resources[0].start;
277 for (start = video_rom_resource.start; start < upper; start += 2048) {
278 rom = isa_bus_to_virt(start);
279 if (!romsignature(rom))
282 video_rom_resource.start = start;
284 /* 0 < length <= 0x7f * 512, historically */
285 length = rom[2] * 512;
287 /* if checksum okay, trust length byte */
288 if (length && romchecksum(rom, length))
289 video_rom_resource.end = start + length - 1;
291 request_resource(&iomem_resource, &video_rom_resource);
295 start = (video_rom_resource.end + 1 + 2047) & ~2047UL;
300 request_resource(&iomem_resource, &system_rom_resource);
301 upper = system_rom_resource.start;
303 /* check for extension rom (ignore length byte!) */
304 rom = isa_bus_to_virt(extension_rom_resource.start);
305 if (romsignature(rom)) {
306 length = extension_rom_resource.end - extension_rom_resource.start + 1;
307 if (romchecksum(rom, length)) {
308 request_resource(&iomem_resource, &extension_rom_resource);
309 upper = extension_rom_resource.start;
313 /* check for adapter roms on 2k boundaries */
314 for (i = 0; i < ADAPTER_ROM_RESOURCES && start < upper; start += 2048) {
315 rom = isa_bus_to_virt(start);
316 if (!romsignature(rom))
319 /* 0 < length <= 0x7f * 512, historically */
320 length = rom[2] * 512;
322 /* but accept any length that fits if checksum okay */
323 if (!length || start + length > upper || !romchecksum(rom, length))
326 adapter_rom_resources[i].start = start;
327 adapter_rom_resources[i].end = start + length - 1;
328 request_resource(&iomem_resource, &adapter_rom_resources[i]);
330 start = adapter_rom_resources[i++].end & ~2047UL;
334 static void __init limit_regions(unsigned long long size)
336 unsigned long long current_addr = 0;
340 for (i = 0; i < memmap.nr_map; i++) {
341 current_addr = memmap.map[i].phys_addr +
342 (memmap.map[i].num_pages << 12);
343 if (memmap.map[i].type == EFI_CONVENTIONAL_MEMORY) {
344 if (current_addr >= size) {
345 memmap.map[i].num_pages -=
346 (((current_addr-size) + PAGE_SIZE-1) >> PAGE_SHIFT);
347 memmap.nr_map = i + 1;
353 for (i = 0; i < e820.nr_map; i++) {
354 if (e820.map[i].type == E820_RAM) {
355 current_addr = e820.map[i].addr + e820.map[i].size;
356 if (current_addr >= size) {
357 e820.map[i].size -= current_addr-size;
365 static void __init add_memory_region(unsigned long long start,
366 unsigned long long size, int type)
374 printk(KERN_ERR "Ooops! Too many entries in the memory map!\n");
378 e820.map[x].addr = start;
379 e820.map[x].size = size;
380 e820.map[x].type = type;
383 } /* add_memory_region */
387 static void __init print_memory_map(char *who)
391 for (i = 0; i < e820.nr_map; i++) {
392 printk(" %s: %016Lx - %016Lx ", who,
394 e820.map[i].addr + e820.map[i].size);
395 switch (e820.map[i].type) {
396 case E820_RAM: printk("(usable)\n");
399 printk("(reserved)\n");
402 printk("(ACPI data)\n");
405 printk("(ACPI NVS)\n");
407 default: printk("type %lu\n", e820.map[i].type);
414 * Sanitize the BIOS e820 map.
416 * Some e820 responses include overlapping entries. The following
417 * replaces the original e820 map with a new one, removing overlaps.
420 struct change_member {
421 struct e820entry *pbios; /* pointer to original bios entry */
422 unsigned long long addr; /* address for this change point */
424 struct change_member change_point_list[2*E820MAX] __initdata;
425 struct change_member *change_point[2*E820MAX] __initdata;
426 struct e820entry *overlap_list[E820MAX] __initdata;
427 struct e820entry new_bios[E820MAX] __initdata;
429 static int __init sanitize_e820_map(struct e820entry * biosmap, char * pnr_map)
431 struct change_member *change_tmp;
432 unsigned long current_type, last_type;
433 unsigned long long last_addr;
434 int chgidx, still_changing;
437 int old_nr, new_nr, chg_nr;
441 Visually we're performing the following (1,2,3,4 = memory types)...
443 Sample memory map (w/overlaps):
444 ____22__________________
445 ______________________4_
446 ____1111________________
447 _44_____________________
448 11111111________________
449 ____________________33__
450 ___________44___________
451 __________33333_________
452 ______________22________
453 ___________________2222_
454 _________111111111______
455 _____________________11_
456 _________________4______
458 Sanitized equivalent (no overlap):
459 1_______________________
460 _44_____________________
461 ___1____________________
462 ____22__________________
463 ______11________________
464 _________1______________
465 __________3_____________
466 ___________44___________
467 _____________33_________
468 _______________2________
469 ________________1_______
470 _________________4______
471 ___________________2____
472 ____________________33__
473 ______________________4_
476 /* if there's only one memory region, don't bother */
482 /* bail out if we find any unreasonable addresses in bios map */
483 for (i=0; i<old_nr; i++)
484 if (biosmap[i].addr + biosmap[i].size < biosmap[i].addr)
487 /* create pointers for initial change-point information (for sorting) */
488 for (i=0; i < 2*old_nr; i++)
489 change_point[i] = &change_point_list[i];
491 /* record all known change-points (starting and ending addresses),
492 omitting those that are for empty memory regions */
494 for (i=0; i < old_nr; i++) {
495 if (biosmap[i].size != 0) {
496 change_point[chgidx]->addr = biosmap[i].addr;
497 change_point[chgidx++]->pbios = &biosmap[i];
498 change_point[chgidx]->addr = biosmap[i].addr + biosmap[i].size;
499 change_point[chgidx++]->pbios = &biosmap[i];
502 chg_nr = chgidx; /* true number of change-points */
504 /* sort change-point list by memory addresses (low -> high) */
506 while (still_changing) {
508 for (i=1; i < chg_nr; i++) {
509 /* if <current_addr> > <last_addr>, swap */
510 /* or, if current=<start_addr> & last=<end_addr>, swap */
511 if ((change_point[i]->addr < change_point[i-1]->addr) ||
512 ((change_point[i]->addr == change_point[i-1]->addr) &&
513 (change_point[i]->addr == change_point[i]->pbios->addr) &&
514 (change_point[i-1]->addr != change_point[i-1]->pbios->addr))
517 change_tmp = change_point[i];
518 change_point[i] = change_point[i-1];
519 change_point[i-1] = change_tmp;
525 /* create a new bios memory map, removing overlaps */
526 overlap_entries=0; /* number of entries in the overlap table */
527 new_bios_entry=0; /* index for creating new bios map entries */
528 last_type = 0; /* start with undefined memory type */
529 last_addr = 0; /* start with 0 as last starting address */
530 /* loop through change-points, determining affect on the new bios map */
531 for (chgidx=0; chgidx < chg_nr; chgidx++)
533 /* keep track of all overlapping bios entries */
534 if (change_point[chgidx]->addr == change_point[chgidx]->pbios->addr)
536 /* add map entry to overlap list (> 1 entry implies an overlap) */
537 overlap_list[overlap_entries++]=change_point[chgidx]->pbios;
541 /* remove entry from list (order independent, so swap with last) */
542 for (i=0; i<overlap_entries; i++)
544 if (overlap_list[i] == change_point[chgidx]->pbios)
545 overlap_list[i] = overlap_list[overlap_entries-1];
549 /* if there are overlapping entries, decide which "type" to use */
550 /* (larger value takes precedence -- 1=usable, 2,3,4,4+=unusable) */
552 for (i=0; i<overlap_entries; i++)
553 if (overlap_list[i]->type > current_type)
554 current_type = overlap_list[i]->type;
555 /* continue building up new bios map based on this information */
556 if (current_type != last_type) {
557 if (last_type != 0) {
558 new_bios[new_bios_entry].size =
559 change_point[chgidx]->addr - last_addr;
560 /* move forward only if the new size was non-zero */
561 if (new_bios[new_bios_entry].size != 0)
562 if (++new_bios_entry >= E820MAX)
563 break; /* no more space left for new bios entries */
565 if (current_type != 0) {
566 new_bios[new_bios_entry].addr = change_point[chgidx]->addr;
567 new_bios[new_bios_entry].type = current_type;
568 last_addr=change_point[chgidx]->addr;
570 last_type = current_type;
573 new_nr = new_bios_entry; /* retain count for new bios entries */
575 /* copy new bios mapping into original location */
576 memcpy(biosmap, new_bios, new_nr*sizeof(struct e820entry));
583 * Copy the BIOS e820 map into a safe place.
585 * Sanity-check it while we're at it..
587 * If we're lucky and live on a modern system, the setup code
588 * will have given us a memory map that we can use to properly
589 * set up memory. If we aren't, we'll fake a memory map.
591 * We check to see that the memory map contains at least 2 elements
592 * before we'll use it, because the detection code in setup.S may
593 * not be perfect and most every PC known to man has two memory
594 * regions: one from 0 to 640k, and one from 1mb up. (The IBM
595 * thinkpad 560x, for example, does not cooperate with the memory
598 static int __init copy_e820_map(struct e820entry * biosmap, int nr_map)
600 /* Only one memory region (or negative)? Ignore it */
605 unsigned long long start = biosmap->addr;
606 unsigned long long size = biosmap->size;
607 unsigned long long end = start + size;
608 unsigned long type = biosmap->type;
610 /* Overflow in 64 bits? Ignore the memory map. */
615 * Some BIOSes claim RAM in the 640k - 1M region.
616 * Not right. Fix it up.
618 if (type == E820_RAM) {
619 if (start < 0x100000ULL && end > 0xA0000ULL) {
620 if (start < 0xA0000ULL)
621 add_memory_region(start, 0xA0000ULL-start, type);
622 if (end <= 0x100000ULL)
628 add_memory_region(start, size, type);
629 } while (biosmap++,--nr_map);
633 #if defined(CONFIG_EDD) || defined(CONFIG_EDD_MODULE)
635 struct edd_info edd[EDDMAXNR];
636 unsigned int edd_disk80_sig;
637 #ifdef CONFIG_EDD_MODULE
638 EXPORT_SYMBOL(eddnr);
640 EXPORT_SYMBOL(edd_disk80_sig);
643 * copy_edd() - Copy the BIOS EDD information
644 * from boot_params into a safe place.
647 static inline void copy_edd(void)
650 memcpy(edd, EDD_BUF, sizeof(edd));
651 edd_disk80_sig = DISK80_SIGNATURE;
654 #define copy_edd() do {} while (0)
658 * Do NOT EVER look at the BIOS memory size location.
659 * It does not work on many machines.
661 #define LOWMEMSIZE() (0x9f000)
663 static void __init setup_memory_region(void)
665 char *who = machine_specific_memory_setup();
666 printk(KERN_INFO "BIOS-provided physical RAM map:\n");
667 print_memory_map(who);
668 } /* setup_memory_region */
671 static void __init parse_cmdline_early (char ** cmdline_p)
673 char c = ' ', *to = command_line, *from = saved_command_line;
677 /* Save unparsed command line copy for /proc/cmdline */
678 saved_command_line[COMMAND_LINE_SIZE-1] = '\0';
682 * "mem=nopentium" disables the 4MB page tables.
683 * "mem=XXX[kKmM]" defines a memory region from HIGH_MEM
684 * to <mem>, overriding the bios size.
685 * "memmap=XXX[KkmM]@XXX[KkmM]" defines a memory region from
686 * <start> to <start>+<mem>, overriding the bios size.
688 * HPA tells me bootloaders need to parse mem=, so no new
689 * option should be mem= [also see Documentation/i386/boot.txt]
691 if (c == ' ' && !memcmp(from, "mem=", 4)) {
692 if (to != command_line)
694 if (!memcmp(from+4, "nopentium", 9)) {
696 clear_bit(X86_FEATURE_PSE, boot_cpu_data.x86_capability);
699 /* If the user specifies memory size, we
700 * limit the BIOS-provided memory map to
701 * that size. exactmap can be used to specify
702 * the exact map. mem=number can be used to
703 * trim the existing memory map.
705 unsigned long long mem_size;
707 mem_size = memparse(from+4, &from);
708 limit_regions(mem_size);
713 if (c == ' ' && !memcmp(from, "memmap=", 7)) {
714 if (to != command_line)
716 if (!memcmp(from+7, "exactmap", 8)) {
721 /* If the user specifies memory size, we
722 * limit the BIOS-provided memory map to
723 * that size. exactmap can be used to specify
724 * the exact map. mem=number can be used to
725 * trim the existing memory map.
727 unsigned long long start_at, mem_size;
729 mem_size = memparse(from+7, &from);
731 start_at = memparse(from+1, &from);
732 add_memory_region(start_at, mem_size, E820_RAM);
733 } else if (*from == '#') {
734 start_at = memparse(from+1, &from);
735 add_memory_region(start_at, mem_size, E820_ACPI);
736 } else if (*from == '$') {
737 start_at = memparse(from+1, &from);
738 add_memory_region(start_at, mem_size, E820_RESERVED);
740 limit_regions(mem_size);
746 #ifdef CONFIG_X86_SMP
748 * If the BIOS enumerates physical processors before logical,
749 * maxcpus=N at enumeration-time can be used to disable HT.
751 else if (!memcmp(from, "maxcpus=", 8)) {
752 extern unsigned int maxcpus;
754 maxcpus = simple_strtoul(from + 8, NULL, 0);
758 #ifdef CONFIG_ACPI_BOOT
759 /* "acpi=off" disables both ACPI table parsing and interpreter */
760 else if (!memcmp(from, "acpi=off", 8)) {
764 /* acpi=force to over-ride black-list */
765 else if (!memcmp(from, "acpi=force", 10)) {
771 /* acpi=strict disables out-of-spec workarounds */
772 else if (!memcmp(from, "acpi=strict", 11)) {
776 /* Limit ACPI just to boot-time to enable HT */
777 else if (!memcmp(from, "acpi=ht", 7)) {
783 /* "pci=noacpi" disable ACPI IRQ routing and PCI scan */
784 else if (!memcmp(from, "pci=noacpi", 10)) {
787 /* "acpi=noirq" disables ACPI interrupt routing */
788 else if (!memcmp(from, "acpi=noirq", 10)) {
792 else if (!memcmp(from, "acpi_sci=edge", 13))
793 acpi_sci_flags.trigger = 1;
795 else if (!memcmp(from, "acpi_sci=level", 14))
796 acpi_sci_flags.trigger = 3;
798 else if (!memcmp(from, "acpi_sci=high", 13))
799 acpi_sci_flags.polarity = 1;
801 else if (!memcmp(from, "acpi_sci=low", 12))
802 acpi_sci_flags.polarity = 3;
804 #ifdef CONFIG_X86_IO_APIC
805 else if (!memcmp(from, "acpi_skip_timer_override", 24))
806 acpi_skip_timer_override = 1;
809 #ifdef CONFIG_X86_LOCAL_APIC
810 /* disable IO-APIC */
811 else if (!memcmp(from, "noapic", 6))
812 disable_ioapic_setup();
813 #endif /* CONFIG_X86_LOCAL_APIC */
814 #endif /* CONFIG_ACPI_BOOT */
817 * highmem=size forces highmem to be exactly 'size' bytes.
818 * This works even on boxes that have no highmem otherwise.
819 * This also works to reduce highmem size on bigger boxes.
821 if (c == ' ' && !memcmp(from, "highmem=", 8))
822 highmem_pages = memparse(from+8, &from) >> PAGE_SHIFT;
827 if (COMMAND_LINE_SIZE <= ++len)
832 *cmdline_p = command_line;
834 printk(KERN_INFO "user-defined physical RAM map:\n");
835 print_memory_map("user");
840 * Callback for efi_memory_walk.
843 efi_find_max_pfn(unsigned long start, unsigned long end, void *arg)
845 unsigned long *max_pfn = arg, pfn;
848 pfn = PFN_UP(end -1);
857 * Find the highest page frame number we have available
859 void __init find_max_pfn(void)
865 efi_memmap_walk(efi_find_max_pfn, &max_pfn);
869 for (i = 0; i < e820.nr_map; i++) {
870 unsigned long start, end;
872 if (e820.map[i].type != E820_RAM)
874 start = PFN_UP(e820.map[i].addr);
875 end = PFN_DOWN(e820.map[i].addr + e820.map[i].size);
884 * Determine low and high memory ranges:
886 unsigned long __init find_max_low_pfn(void)
888 unsigned long max_low_pfn;
890 max_low_pfn = max_pfn;
891 if (max_low_pfn > MAXMEM_PFN) {
892 if (highmem_pages == -1)
893 highmem_pages = max_pfn - MAXMEM_PFN;
894 if (highmem_pages + MAXMEM_PFN < max_pfn)
895 max_pfn = MAXMEM_PFN + highmem_pages;
896 if (highmem_pages + MAXMEM_PFN > max_pfn) {
897 printk("only %luMB highmem pages available, ignoring highmem size of %uMB.\n", pages_to_mb(max_pfn - MAXMEM_PFN), pages_to_mb(highmem_pages));
900 max_low_pfn = MAXMEM_PFN;
901 #ifndef CONFIG_HIGHMEM
902 /* Maximum memory usable is what is directly addressable */
903 printk(KERN_WARNING "Warning only %ldMB will be used.\n",
905 if (max_pfn > MAX_NONPAE_PFN)
906 printk(KERN_WARNING "Use a PAE enabled kernel.\n");
908 printk(KERN_WARNING "Use a HIGHMEM enabled kernel.\n");
909 max_pfn = MAXMEM_PFN;
910 #else /* !CONFIG_HIGHMEM */
911 #ifndef CONFIG_X86_PAE
912 if (max_pfn > MAX_NONPAE_PFN) {
913 max_pfn = MAX_NONPAE_PFN;
914 printk(KERN_WARNING "Warning only 4GB will be used.\n");
915 printk(KERN_WARNING "Use a PAE enabled kernel.\n");
917 #endif /* !CONFIG_X86_PAE */
918 #endif /* !CONFIG_HIGHMEM */
920 if (highmem_pages == -1)
922 #ifdef CONFIG_HIGHMEM
923 if (highmem_pages >= max_pfn) {
924 printk(KERN_ERR "highmem size specified (%uMB) is bigger than pages available (%luMB)!.\n", pages_to_mb(highmem_pages), pages_to_mb(max_pfn));
928 if (max_low_pfn-highmem_pages < 64*1024*1024/PAGE_SIZE){
929 printk(KERN_ERR "highmem size %uMB results in smaller than 64MB lowmem, ignoring it.\n", pages_to_mb(highmem_pages));
932 max_low_pfn -= highmem_pages;
936 printk(KERN_ERR "ignoring highmem size on non-highmem kernel!\n");
942 #ifndef CONFIG_DISCONTIGMEM
945 * Free all available memory for boot time allocation. Used
946 * as a callback function by efi_memory_walk()
950 free_available_memory(unsigned long start, unsigned long end, void *arg)
952 /* check max_low_pfn */
953 if (start >= ((max_low_pfn + 1) << PAGE_SHIFT))
955 if (end >= ((max_low_pfn + 1) << PAGE_SHIFT))
956 end = (max_low_pfn + 1) << PAGE_SHIFT;
958 free_bootmem(start, end - start);
963 * Register fully available low RAM pages with the bootmem allocator.
965 static void __init register_bootmem_low_pages(unsigned long max_low_pfn)
970 efi_memmap_walk(free_available_memory, NULL);
973 for (i = 0; i < e820.nr_map; i++) {
974 unsigned long curr_pfn, last_pfn, size;
976 * Reserve usable low memory
978 if (e820.map[i].type != E820_RAM)
981 * We are rounding up the start address of usable memory:
983 curr_pfn = PFN_UP(e820.map[i].addr);
984 if (curr_pfn >= max_low_pfn)
987 * ... and at the end of the usable range downwards:
989 last_pfn = PFN_DOWN(e820.map[i].addr + e820.map[i].size);
991 if (last_pfn > max_low_pfn)
992 last_pfn = max_low_pfn;
995 * .. finally, did all the rounding and playing
996 * around just make the area go away?
998 if (last_pfn <= curr_pfn)
1001 size = last_pfn - curr_pfn;
1002 free_bootmem(PFN_PHYS(curr_pfn), PFN_PHYS(size));
1006 static unsigned long __init setup_memory(void)
1008 unsigned long bootmap_size, start_pfn, max_low_pfn;
1011 * partially used pages are not usable - thus
1012 * we are rounding upwards:
1014 start_pfn = PFN_UP(init_pg_tables_end);
1018 max_low_pfn = find_max_low_pfn();
1020 #ifdef CONFIG_HIGHMEM
1021 highstart_pfn = highend_pfn = max_pfn;
1022 if (max_pfn > max_low_pfn) {
1023 highstart_pfn = max_low_pfn;
1025 printk(KERN_NOTICE "%ldMB HIGHMEM available.\n",
1026 pages_to_mb(highend_pfn - highstart_pfn));
1028 printk(KERN_NOTICE "%ldMB LOWMEM available.\n",
1029 pages_to_mb(max_low_pfn));
1031 * Initialize the boot-time allocator (with low memory only):
1033 bootmap_size = init_bootmem(start_pfn, max_low_pfn);
1035 register_bootmem_low_pages(max_low_pfn);
1038 * Reserve the bootmem bitmap itself as well. We do this in two
1039 * steps (first step was init_bootmem()) because this catches
1040 * the (very unlikely) case of us accidentally initializing the
1041 * bootmem allocator with an invalid RAM area.
1043 reserve_bootmem(HIGH_MEMORY, (PFN_PHYS(start_pfn) +
1044 bootmap_size + PAGE_SIZE-1) - (HIGH_MEMORY));
1047 * reserve physical page 0 - it's a special BIOS page on many boxes,
1048 * enabling clean reboots, SMP operation, laptop functions.
1050 reserve_bootmem(0, PAGE_SIZE);
1052 /* could be an AMD 768MPX chipset. Reserve a page before VGA to prevent
1053 PCI prefetch into it (errata #56). Usually the page is reserved anyways,
1054 unless you have no PS/2 mouse plugged in. */
1055 if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD &&
1056 boot_cpu_data.x86 == 6)
1057 reserve_bootmem(0xa0000 - 4096, 4096);
1061 * But first pinch a few for the stack/trampoline stuff
1062 * FIXME: Don't need the extra page at 4K, but need to fix
1063 * trampoline before removing it. (see the GDT stuff)
1065 reserve_bootmem(PAGE_SIZE, PAGE_SIZE);
1067 #ifdef CONFIG_ACPI_SLEEP
1069 * Reserve low memory region for sleep support.
1071 acpi_reserve_bootmem();
1073 #ifdef CONFIG_X86_FIND_SMP_CONFIG
1075 * Find and reserve possible boot-time SMP configuration:
1080 #ifdef CONFIG_BLK_DEV_INITRD
1081 if (LOADER_TYPE && INITRD_START) {
1082 if (INITRD_START + INITRD_SIZE <= (max_low_pfn << PAGE_SHIFT)) {
1083 reserve_bootmem(INITRD_START, INITRD_SIZE);
1085 INITRD_START ? INITRD_START + PAGE_OFFSET : 0;
1086 initrd_end = initrd_start+INITRD_SIZE;
1089 printk(KERN_ERR "initrd extends beyond end of memory "
1090 "(0x%08lx > 0x%08lx)\ndisabling initrd\n",
1091 INITRD_START + INITRD_SIZE,
1092 max_low_pfn << PAGE_SHIFT);
1100 extern unsigned long setup_memory(void);
1101 #endif /* !CONFIG_DISCONTIGMEM */
1104 * Request address space for all standard RAM and ROM resources
1105 * and also for regions reported as reserved by the e820.
1108 legacy_init_iomem_resources(struct resource *code_resource, struct resource *data_resource)
1113 for (i = 0; i < e820.nr_map; i++) {
1114 struct resource *res;
1115 if (e820.map[i].addr + e820.map[i].size > 0x100000000ULL)
1117 res = alloc_bootmem_low(sizeof(struct resource));
1118 switch (e820.map[i].type) {
1119 case E820_RAM: res->name = "System RAM"; break;
1120 case E820_ACPI: res->name = "ACPI Tables"; break;
1121 case E820_NVS: res->name = "ACPI Non-volatile Storage"; break;
1122 default: res->name = "reserved";
1124 res->start = e820.map[i].addr;
1125 res->end = res->start + e820.map[i].size - 1;
1126 res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
1127 request_resource(&iomem_resource, res);
1128 if (e820.map[i].type == E820_RAM) {
1130 * We don't know which RAM region contains kernel data,
1131 * so we try it repeatedly and let the resource manager
1134 request_resource(res, code_resource);
1135 request_resource(res, data_resource);
1141 * Request address space for all standard resources
1143 static void __init register_memory(unsigned long max_low_pfn)
1145 unsigned long low_mem_size;
1149 efi_initialize_iomem_resources(&code_resource, &data_resource);
1151 legacy_init_iomem_resources(&code_resource, &data_resource);
1153 /* EFI systems may still have VGA */
1154 request_resource(&iomem_resource, &video_ram_resource);
1156 /* request I/O space for devices used on all i[345]86 PCs */
1157 for (i = 0; i < STANDARD_IO_RESOURCES; i++)
1158 request_resource(&ioport_resource, &standard_io_resources[i]);
1160 /* Tell the PCI layer not to allocate too close to the RAM area.. */
1161 low_mem_size = ((max_low_pfn << PAGE_SHIFT) + 0xfffff) & ~0xfffff;
1162 if (low_mem_size > pci_mem_start)
1163 pci_mem_start = low_mem_size;
1166 /* Use inline assembly to define this because the nops are defined
1167 as inline assembly strings in the include files and we cannot
1168 get them easily into strings. */
1169 asm("\t.data\nintelnops: "
1170 GENERIC_NOP1 GENERIC_NOP2 GENERIC_NOP3 GENERIC_NOP4 GENERIC_NOP5 GENERIC_NOP6
1171 GENERIC_NOP7 GENERIC_NOP8);
1172 asm("\t.data\nk8nops: "
1173 K8_NOP1 K8_NOP2 K8_NOP3 K8_NOP4 K8_NOP5 K8_NOP6
1175 asm("\t.data\nk7nops: "
1176 K7_NOP1 K7_NOP2 K7_NOP3 K7_NOP4 K7_NOP5 K7_NOP6
1179 extern unsigned char intelnops[], k8nops[], k7nops[];
1180 static unsigned char *intel_nops[ASM_NOP_MAX+1] = {
1185 intelnops + 1 + 2 + 3,
1186 intelnops + 1 + 2 + 3 + 4,
1187 intelnops + 1 + 2 + 3 + 4 + 5,
1188 intelnops + 1 + 2 + 3 + 4 + 5 + 6,
1189 intelnops + 1 + 2 + 3 + 4 + 5 + 6 + 7,
1191 static unsigned char *k8_nops[ASM_NOP_MAX+1] = {
1197 k8nops + 1 + 2 + 3 + 4,
1198 k8nops + 1 + 2 + 3 + 4 + 5,
1199 k8nops + 1 + 2 + 3 + 4 + 5 + 6,
1200 k8nops + 1 + 2 + 3 + 4 + 5 + 6 + 7,
1202 static unsigned char *k7_nops[ASM_NOP_MAX+1] = {
1208 k7nops + 1 + 2 + 3 + 4,
1209 k7nops + 1 + 2 + 3 + 4 + 5,
1210 k7nops + 1 + 2 + 3 + 4 + 5 + 6,
1211 k7nops + 1 + 2 + 3 + 4 + 5 + 6 + 7,
1215 unsigned char **noptable;
1217 { X86_FEATURE_K8, k8_nops },
1218 { X86_FEATURE_K7, k7_nops },
1222 /* Replace instructions with better alternatives for this CPU type.
1224 This runs before SMP is initialized to avoid SMP problems with
1225 self modifying code. This implies that assymetric systems where
1226 APs have less capabilities than the boot processor are not handled.
1227 In this case boot with "noreplacement". */
1228 void apply_alternatives(void *start, void *end)
1230 struct alt_instr *a;
1232 unsigned char **noptable = intel_nops;
1233 for (i = 0; noptypes[i].cpuid >= 0; i++) {
1234 if (boot_cpu_has(noptypes[i].cpuid)) {
1235 noptable = noptypes[i].noptable;
1239 for (a = start; (void *)a < end; a++) {
1240 if (!boot_cpu_has(a->cpuid))
1242 BUG_ON(a->replacementlen > a->instrlen);
1243 memcpy(a->instr, a->replacement, a->replacementlen);
1244 diff = a->instrlen - a->replacementlen;
1245 /* Pad the rest with nops */
1246 for (i = a->replacementlen; diff > 0; diff -= k, i += k) {
1248 if (k > ASM_NOP_MAX)
1250 memcpy(a->instr + i, noptable[k], k);
1255 static int no_replacement __initdata = 0;
1257 void __init alternative_instructions(void)
1259 extern struct alt_instr __alt_instructions[], __alt_instructions_end[];
1262 apply_alternatives(__alt_instructions, __alt_instructions_end);
1265 static int __init noreplacement_setup(char *s)
1271 __setup("noreplacement", noreplacement_setup);
1274 * Determine if we were loaded by an EFI loader. If so, then we have also been
1275 * passed the efi memmap, systab, etc., so we should use these data structures
1276 * for initialization. Note, the efi init code path is determined by the
1277 * global efi_enabled. This allows the same kernel image to be used on existing
1278 * systems (with a traditional BIOS) as well as on EFI systems.
1280 void __init setup_arch(char **cmdline_p)
1282 unsigned long max_low_pfn;
1284 memcpy(&boot_cpu_data, &new_cpu_data, sizeof(new_cpu_data));
1285 pre_setup_arch_hook();
1289 * FIXME: This isn't an official loader_type right
1290 * now but does currently work with elilo.
1291 * If we were configured as an EFI kernel, check to make
1292 * sure that we were loaded correctly from elilo and that
1293 * the system table is valid. If not, then initialize normally.
1296 if ((LOADER_TYPE == 0x50) && EFI_SYSTAB)
1300 ROOT_DEV = old_decode_dev(ORIG_ROOT_DEV);
1301 drive_info = DRIVE_INFO;
1302 screen_info = SCREEN_INFO;
1303 edid_info = EDID_INFO;
1304 apm_info.bios = APM_BIOS_INFO;
1305 ist_info = IST_INFO;
1306 saved_videomode = VIDEO_MODE;
1307 if( SYS_DESC_TABLE.length != 0 ) {
1308 MCA_bus = SYS_DESC_TABLE.table[3] &0x2;
1309 machine_id = SYS_DESC_TABLE.table[0];
1310 machine_submodel_id = SYS_DESC_TABLE.table[1];
1311 BIOS_revision = SYS_DESC_TABLE.table[2];
1313 aux_device_present = AUX_DEVICE_INFO;
1315 #ifdef CONFIG_BLK_DEV_RAM
1316 rd_image_start = RAMDISK_FLAGS & RAMDISK_IMAGE_START_MASK;
1317 rd_prompt = ((RAMDISK_FLAGS & RAMDISK_PROMPT_FLAG) != 0);
1318 rd_doload = ((RAMDISK_FLAGS & RAMDISK_LOAD_FLAG) != 0);
1324 setup_memory_region();
1328 if (!MOUNT_ROOT_RDONLY)
1329 root_mountflags &= ~MS_RDONLY;
1330 init_mm.start_code = (unsigned long) _text;
1331 init_mm.end_code = (unsigned long) _etext;
1332 init_mm.end_data = (unsigned long) _edata;
1333 init_mm.brk = init_pg_tables_end + PAGE_OFFSET;
1335 code_resource.start = virt_to_phys(_text);
1336 code_resource.end = virt_to_phys(_etext)-1;
1337 data_resource.start = virt_to_phys(_etext);
1338 data_resource.end = virt_to_phys(_edata)-1;
1340 parse_cmdline_early(cmdline_p);
1342 max_low_pfn = setup_memory();
1345 * NOTE: before this point _nobody_ is allowed to allocate
1346 * any memory using the bootmem allocator.
1350 smp_alloc_memory(); /* AP processor realmode stacks in low memory*/
1354 #ifdef CONFIG_EARLY_PRINTK
1356 char *s = strstr(*cmdline_p, "earlyprintk=");
1358 extern void setup_early_printk(char *);
1360 setup_early_printk(s);
1361 printk("early console enabled\n");
1369 #ifdef CONFIG_X86_GENERICARCH
1370 generic_apic_probe(*cmdline_p);
1376 * Parse the ACPI tables for possible boot-time SMP configuration.
1380 #ifdef CONFIG_X86_LOCAL_APIC
1381 if (smp_found_config)
1385 register_memory(max_low_pfn);
1388 #if defined(CONFIG_VGA_CONSOLE)
1389 if (!efi_enabled || (efi_mem_type(0xa0000) != EFI_CONVENTIONAL_MEMORY))
1390 conswitchp = &vga_con;
1391 #elif defined(CONFIG_DUMMY_CONSOLE)
1392 conswitchp = &dummy_con;
1397 #include "setup_arch_post.h"
1401 * c-file-style:"k&r"