blob: f7b8b9894b226fd8498ab5f886381f68be2541c2 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * 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>
Andy Whitcroft05b79bd2005-06-23 00:07:57 -070026#include <linux/mmzone.h>
Jon Smirl894673e2006-07-10 04:44:13 -070027#include <linux/screen_info.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/ioport.h>
29#include <linux/acpi.h>
Feng Tangefafc8b2009-08-14 15:23:29 -040030#include <linux/sfi.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include <linux/apm_bios.h>
32#include <linux/initrd.h>
33#include <linux/bootmem.h>
34#include <linux/seq_file.h>
35#include <linux/console.h>
36#include <linux/mca.h>
37#include <linux/root_dev.h>
38#include <linux/highmem.h>
39#include <linux/module.h>
40#include <linux/efi.h>
41#include <linux/init.h>
42#include <linux/edd.h>
Konrad Rzeszutek138fe4e2008-04-09 19:50:41 -070043#include <linux/iscsi_ibft.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070044#include <linux/nodemask.h>
Eric W. Biederman1bc3b912005-06-25 14:58:01 -070045#include <linux/kexec.h>
Andi Kleene9928672006-01-11 22:43:33 +010046#include <linux/dmi.h>
Dave Hansen22a98352006-03-27 01:16:04 -080047#include <linux/pfn.h>
Thomas Gleixner376ff032008-01-30 13:30:16 +010048#include <linux/pci.h>
Yinghai Lu46d671b2008-06-25 17:51:29 -070049#include <asm/pci-direct.h>
Bernhard Kaindlf212ec42008-01-30 13:34:11 +010050#include <linux/init_ohci1394_dma.h>
Glauber de Oliveira Costa790c73f2008-02-15 17:52:48 -020051#include <linux/kvm_para.h>
Eric W. Biederman1bc3b912005-06-25 14:58:01 -070052
Yinghai Lu46d671b2008-06-25 17:51:29 -070053#include <linux/errno.h>
54#include <linux/kernel.h>
55#include <linux/stddef.h>
56#include <linux/unistd.h>
57#include <linux/ptrace.h>
58#include <linux/slab.h>
59#include <linux/user.h>
60#include <linux/delay.h>
Yinghai Lu46d671b2008-06-25 17:51:29 -070061
62#include <linux/kallsyms.h>
Yinghai Lu46d671b2008-06-25 17:51:29 -070063#include <linux/cpufreq.h>
64#include <linux/dma-mapping.h>
65#include <linux/ctype.h>
66#include <linux/uaccess.h>
67
68#include <linux/percpu.h>
69#include <linux/crash_dump.h>
Shane Wang69575d32009-09-01 18:25:07 -070070#include <linux/tboot.h>
Yinghai Lu46d671b2008-06-25 17:51:29 -070071
Linus Torvalds1da177e2005-04-16 15:20:36 -070072#include <video/edid.h>
Eric W. Biederman1bc3b912005-06-25 14:58:01 -070073
Yinghai Lu093af8d2008-01-30 13:33:32 +010074#include <asm/mtrr.h>
Eric W. Biederman9635b472005-06-25 14:57:41 -070075#include <asm/apic.h>
Yinghai Lu893f38d2009-12-10 13:07:22 -080076#include <asm/trampoline.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070077#include <asm/e820.h>
78#include <asm/mpspec.h>
79#include <asm/setup.h>
Yinghai Lu55f26232008-06-25 17:54:23 -070080#include <asm/efi.h>
Ingo Molnar8e6dafd2009-02-23 00:34:39 +010081#include <asm/timer.h>
82#include <asm/i8259.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070083#include <asm/sections.h>
Yinghai Lu1c6e5502008-06-17 15:41:45 -070084#include <asm/dmi.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070085#include <asm/io_apic.h>
86#include <asm/ist.h>
Zachary Amsden7ce0bcf2007-02-13 13:26:21 +010087#include <asm/vmi.h>
Ingo Molnar1164dd02009-01-28 19:34:09 +010088#include <asm/setup_arch.h>
Alexey Starikovskiyce3fe6b2008-03-17 22:08:17 +030089#include <asm/bios_ebda.h>
Bernhard Walle00bf4092007-10-21 16:42:01 -070090#include <asm/cacheflush.h>
Alexander van Heukelum2fde61f2008-03-04 19:57:42 +010091#include <asm/processor.h>
Yinghai Lucc9f7a02008-06-16 16:11:08 -070092#include <asm/bugs.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070093
Yinghai Lu46d671b2008-06-25 17:51:29 -070094#include <asm/system.h>
95#include <asm/vsyscall.h>
Jaswinder Singh Rajput6e5385d2009-01-07 18:11:35 +053096#include <asm/cpu.h>
Yinghai Lu46d671b2008-06-25 17:51:29 -070097#include <asm/desc.h>
98#include <asm/dma.h>
FUJITA Tomonori46a7fa22008-07-11 10:23:42 +090099#include <asm/iommu.h>
Joerg Roedel1d9b16d2008-11-27 18:39:15 +0100100#include <asm/gart.h>
Yinghai Lu46d671b2008-06-25 17:51:29 -0700101#include <asm/mmu_context.h>
102#include <asm/proto.h>
103
Yinghai Lu46d671b2008-06-25 17:51:29 -0700104#include <asm/paravirt.h>
Alok Kataria88b094f2008-10-27 10:41:46 -0700105#include <asm/hypervisor.h>
Yinghai Lu46d671b2008-06-25 17:51:29 -0700106
107#include <asm/percpu.h>
Yinghai Lu46d671b2008-06-25 17:51:29 -0700108#include <asm/topology.h>
109#include <asm/apicdef.h>
David Rientjes8ee2deb2009-09-25 15:20:00 -0700110#include <asm/k8.h>
Yinghai Lu55f26232008-06-25 17:54:23 -0700111#ifdef CONFIG_X86_64
112#include <asm/numa_64.h>
113#endif
Yong Wanga2202aa2009-11-10 09:38:24 +0800114#include <asm/mce.h>
Yinghai Lu46d671b2008-06-25 17:51:29 -0700115
Pekka Enberg2b723942009-04-28 16:00:49 +0300116/*
117 * end_pfn only includes RAM, while max_pfn_mapped includes all e820 entries.
118 * The direct mapping extends to max_pfn_mapped, so that we can directly access
119 * apertures, ACPI and other tables without having to play with fixmaps.
120 */
121unsigned long max_low_pfn_mapped;
122unsigned long max_pfn_mapped;
123
Jeremy Fitzhardinge796216a2009-03-12 16:09:49 -0700124RESERVE_BRK(dmi_alloc, 65536);
125
Ingo Molnarc0b58422009-01-27 17:13:05 +0100126unsigned int boot_cpu_id __read_mostly;
127
Jeremy Fitzhardinge93dbda72009-02-26 17:35:44 -0800128static __initdata unsigned long _brk_start = (unsigned long)__brk_base;
129unsigned long _brk_end = (unsigned long)__brk_base;
130
Ingo Molnarc0b58422009-01-27 17:13:05 +0100131#ifdef CONFIG_X86_64
132int default_cpu_present_to_apicid(int mps_cpu)
133{
134 return __default_cpu_present_to_apicid(mps_cpu);
135}
136
Thomas Gleixnere11dada2009-08-31 15:18:40 +0200137int default_check_phys_apicid_present(int phys_apicid)
Ingo Molnarc0b58422009-01-27 17:13:05 +0100138{
Thomas Gleixnere11dada2009-08-31 15:18:40 +0200139 return __default_check_phys_apicid_present(phys_apicid);
Ingo Molnarc0b58422009-01-27 17:13:05 +0100140}
141#endif
142
Yinghai Lu217b8ce2008-06-25 17:55:20 -0700143#ifndef CONFIG_DEBUG_BOOT_PARAMS
144struct boot_params __initdata boot_params;
145#else
146struct boot_params boot_params;
147#endif
148
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149/*
150 * Machine setup..
151 */
Bernhard Wallec9cce832008-01-30 13:30:32 +0100152static struct resource data_resource = {
153 .name = "Kernel data",
154 .start = 0,
155 .end = 0,
156 .flags = IORESOURCE_BUSY | IORESOURCE_MEM
157};
158
159static struct resource code_resource = {
160 .name = "Kernel code",
161 .start = 0,
162 .end = 0,
163 .flags = IORESOURCE_BUSY | IORESOURCE_MEM
164};
165
166static struct resource bss_resource = {
167 .name = "Kernel bss",
168 .start = 0,
169 .end = 0,
170 .flags = IORESOURCE_BUSY | IORESOURCE_MEM
171};
172
Yinghai Lu7dea23e2008-06-25 17:50:06 -0700173
174#ifdef CONFIG_X86_32
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175/* cpu data as detected by the assembly code in head.S */
Yinghai Lu7dea23e2008-06-25 17:50:06 -0700176struct cpuinfo_x86 new_cpu_data __cpuinitdata = {0, 0, 0, 0, -1, 1, 0, 0, -1};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177/* common cpu data for all cpus */
Yinghai Lu7dea23e2008-06-25 17:50:06 -0700178struct cpuinfo_x86 boot_cpu_data __read_mostly = {0, 0, 0, 0, -1, 1, 0, 0, -1};
Alexey Dobriyan129f6942005-06-23 00:08:33 -0700179EXPORT_SYMBOL(boot_cpu_data);
Yinghai Lu7dea23e2008-06-25 17:50:06 -0700180static void set_mca_bus(int x)
181{
182#ifdef CONFIG_MCA
183 MCA_bus = x;
184#endif
185}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186
Alexey Starikovskiy0c254e32008-03-27 23:55:04 +0300187unsigned int def_to_bigsmp;
188
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189/* for MCA, but anyone else can use it if they want */
190unsigned int machine_id;
191unsigned int machine_submodel_id;
192unsigned int BIOS_revision;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193
Yinghai Lu7dea23e2008-06-25 17:50:06 -0700194struct apm_info apm_info;
195EXPORT_SYMBOL(apm_info);
196
197#if defined(CONFIG_X86_SPEEDSTEP_SMI) || \
198 defined(CONFIG_X86_SPEEDSTEP_SMI_MODULE)
199struct ist_info ist_info;
200EXPORT_SYMBOL(ist_info);
201#else
202struct ist_info ist_info;
203#endif
204
205#else
Jeremy Fitzhardingeed26dbe2009-03-04 16:16:51 -0800206struct cpuinfo_x86 boot_cpu_data __read_mostly = {
207 .x86_phys_bits = MAX_PHYSMEM_BITS,
208};
Yinghai Lu7dea23e2008-06-25 17:50:06 -0700209EXPORT_SYMBOL(boot_cpu_data);
210#endif
211
212
213#if !defined(CONFIG_X86_PAE) || defined(CONFIG_X86_64)
214unsigned long mmu_cr4_features;
215#else
216unsigned long mmu_cr4_features = X86_CR4_PAE;
217#endif
218
H. Peter Anvin50312962009-05-07 16:54:11 -0700219/* Boot loader ID and version as integers, for the benefit of proc_dointvec */
220int bootloader_type, bootloader_version;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222/*
223 * Setup options
224 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225struct screen_info screen_info;
Alexey Dobriyan129f6942005-06-23 00:08:33 -0700226EXPORT_SYMBOL(screen_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227struct edid_info edid_info;
Antonino A. Daplas5e518d72005-09-09 13:04:34 -0700228EXPORT_SYMBOL_GPL(edid_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230extern int root_mountflags;
231
Pavel Macheke44b7b72008-04-10 23:28:10 +0200232unsigned long saved_video_mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233
H. Peter Anvincf8fa922008-01-30 13:32:51 +0100234#define RAMDISK_IMAGE_START_MASK 0x07FF
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235#define RAMDISK_PROMPT_FLAG 0x8000
H. Peter Anvincf8fa922008-01-30 13:32:51 +0100236#define RAMDISK_LOAD_FLAG 0x4000
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237
Alon Bar-Lev4e498b62007-02-12 00:54:11 -0800238static char __initdata command_line[COMMAND_LINE_SIZE];
Tim Bird516cbf32008-08-12 12:52:36 -0700239#ifdef CONFIG_CMDLINE_BOOL
240static char __initdata builtin_cmdline[COMMAND_LINE_SIZE] = CONFIG_CMDLINE;
241#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243#if defined(CONFIG_EDD) || defined(CONFIG_EDD_MODULE)
244struct edd edd;
245#ifdef CONFIG_EDD_MODULE
246EXPORT_SYMBOL(edd);
247#endif
248/**
249 * copy_edd() - Copy the BIOS EDD information
250 * from boot_params into a safe place.
251 *
252 */
Helight.Xu9eaa1922009-11-30 18:33:51 +0800253static inline void __init copy_edd(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254{
H. Peter Anvin30c82642007-10-15 17:13:22 -0700255 memcpy(edd.mbr_signature, boot_params.edd_mbr_sig_buffer,
256 sizeof(edd.mbr_signature));
257 memcpy(edd.edd_info, boot_params.eddbuf, sizeof(edd.edd_info));
258 edd.mbr_signature_nr = boot_params.edd_mbr_sig_buf_entries;
259 edd.edd_info_nr = boot_params.eddbuf_entries;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260}
261#else
Helight.Xu9eaa1922009-11-30 18:33:51 +0800262static inline void __init copy_edd(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263{
264}
265#endif
266
H. Peter Anvin5368a2b2009-03-14 17:19:51 -0700267void * __init extend_brk(size_t size, size_t align)
268{
269 size_t mask = align - 1;
270 void *ret;
271
272 BUG_ON(_brk_start == 0);
273 BUG_ON(align & mask);
274
275 _brk_end = (_brk_end + mask) & ~mask;
276 BUG_ON((char *)(_brk_end + size) > __brk_limit);
277
278 ret = (void *)_brk_end;
279 _brk_end += size;
280
281 memset(ret, 0, size);
282
283 return ret;
284}
285
Pekka J Enberg854c8792009-06-22 17:39:41 +0300286#ifdef CONFIG_X86_64
287static void __init init_gbpages(void)
288{
289 if (direct_gbpages && cpu_has_gbpages)
290 printk(KERN_INFO "Using GB pages for direct mapping\n");
291 else
292 direct_gbpages = 0;
293}
294#else
295static inline void init_gbpages(void)
296{
297}
298#endif
299
H. Peter Anvin5368a2b2009-03-14 17:19:51 -0700300static void __init reserve_brk(void)
301{
302 if (_brk_end > _brk_start)
303 reserve_early(__pa(_brk_start), __pa(_brk_end), "BRK");
304
305 /* Mark brk area as locked down and no longer taking any
306 new allocations */
307 _brk_start = 0;
308}
309
H. Peter Anvincf8fa922008-01-30 13:32:51 +0100310#ifdef CONFIG_BLK_DEV_INITRD
311
Yinghai Lueb1379c2008-06-25 17:49:26 -0700312#define MAX_MAP_CHUNK (NR_FIX_BTMAPS << PAGE_SHIFT)
313static void __init relocate_initrd(void)
H. Peter Anvincf8fa922008-01-30 13:32:51 +0100314{
Yinghai Lueb1379c2008-06-25 17:49:26 -0700315
Yinghai Luba5b14c2008-05-21 18:40:18 -0700316 u64 ramdisk_image = boot_params.hdr.ramdisk_image;
317 u64 ramdisk_size = boot_params.hdr.ramdisk_size;
Yinghai Lu8c5dd8f2009-06-04 19:14:22 -0700318 u64 end_of_lowmem = max_low_pfn_mapped << PAGE_SHIFT;
Yinghai Luba5b14c2008-05-21 18:40:18 -0700319 u64 ramdisk_here;
Yinghai Lueb1379c2008-06-25 17:49:26 -0700320 unsigned long slop, clen, mapaddr;
321 char *p, *q;
H. Peter Anvincf8fa922008-01-30 13:32:51 +0100322
323 /* We need to move the initrd down into lowmem */
Yinghai Lu4e296842008-06-24 12:18:14 -0700324 ramdisk_here = find_e820_area(0, end_of_lowmem, ramdisk_size,
325 PAGE_SIZE);
H. Peter Anvincf8fa922008-01-30 13:32:51 +0100326
Yinghai Lu3945e2c2008-05-25 10:00:09 -0700327 if (ramdisk_here == -1ULL)
328 panic("Cannot find place for new RAMDISK of size %lld\n",
329 ramdisk_size);
330
H. Peter Anvincf8fa922008-01-30 13:32:51 +0100331 /* Note: this includes all the lowmem currently occupied by
332 the initrd, we rely on that fact to keep the data intact. */
Yinghai Lu3945e2c2008-05-25 10:00:09 -0700333 reserve_early(ramdisk_here, ramdisk_here + ramdisk_size,
Yinghai Luba5b14c2008-05-21 18:40:18 -0700334 "NEW RAMDISK");
H. Peter Anvincf8fa922008-01-30 13:32:51 +0100335 initrd_start = ramdisk_here + PAGE_OFFSET;
336 initrd_end = initrd_start + ramdisk_size;
Yinghai Luf0d43102008-05-29 12:56:36 -0700337 printk(KERN_INFO "Allocated new RAMDISK: %08llx - %08llx\n",
338 ramdisk_here, ramdisk_here + ramdisk_size);
H. Peter Anvincf8fa922008-01-30 13:32:51 +0100339
H. Peter Anvincf8fa922008-01-30 13:32:51 +0100340 q = (char *)initrd_start;
341
342 /* Copy any lowmem portion of the initrd */
343 if (ramdisk_image < end_of_lowmem) {
344 clen = end_of_lowmem - ramdisk_image;
345 p = (char *)__va(ramdisk_image);
346 memcpy(q, p, clen);
347 q += clen;
348 ramdisk_image += clen;
349 ramdisk_size -= clen;
350 }
351
352 /* Copy the highmem portion of the initrd */
353 while (ramdisk_size) {
354 slop = ramdisk_image & ~PAGE_MASK;
355 clen = ramdisk_size;
356 if (clen > MAX_MAP_CHUNK-slop)
357 clen = MAX_MAP_CHUNK-slop;
358 mapaddr = ramdisk_image & PAGE_MASK;
Jeremy Fitzhardinge88b4c142008-09-07 15:21:16 -0700359 p = early_memremap(mapaddr, clen+slop);
H. Peter Anvincf8fa922008-01-30 13:32:51 +0100360 memcpy(q, p+slop, clen);
Huang, Yingbeacfaa2008-01-30 13:33:44 +0100361 early_iounmap(p, clen+slop);
H. Peter Anvincf8fa922008-01-30 13:32:51 +0100362 q += clen;
363 ramdisk_image += clen;
364 ramdisk_size -= clen;
365 }
Yinghai Lua4c81cf2008-05-18 01:18:57 -0700366 /* high pages is not converted by early_res_to_bootmem */
Yinghai Luba5b14c2008-05-21 18:40:18 -0700367 ramdisk_image = boot_params.hdr.ramdisk_image;
368 ramdisk_size = boot_params.hdr.ramdisk_size;
Yinghai Lueb1379c2008-06-25 17:49:26 -0700369 printk(KERN_INFO "Move RAMDISK from %016llx - %016llx to"
370 " %08llx - %08llx\n",
Yinghai Luba5b14c2008-05-21 18:40:18 -0700371 ramdisk_image, ramdisk_image + ramdisk_size - 1,
372 ramdisk_here, ramdisk_here + ramdisk_size - 1);
Yinghai Lueb1379c2008-06-25 17:49:26 -0700373}
Yinghai Lu9a27f5c2008-06-13 20:07:03 -0700374
Yinghai Lueb1379c2008-06-25 17:49:26 -0700375static void __init reserve_initrd(void)
376{
377 u64 ramdisk_image = boot_params.hdr.ramdisk_image;
378 u64 ramdisk_size = boot_params.hdr.ramdisk_size;
379 u64 ramdisk_end = ramdisk_image + ramdisk_size;
Yinghai Lu8c5dd8f2009-06-04 19:14:22 -0700380 u64 end_of_lowmem = max_low_pfn_mapped << PAGE_SHIFT;
Yinghai Lueb1379c2008-06-25 17:49:26 -0700381
382 if (!boot_params.hdr.type_of_loader ||
383 !ramdisk_image || !ramdisk_size)
384 return; /* No initrd provided by bootloader */
385
386 initrd_start = 0;
387
388 if (ramdisk_size >= (end_of_lowmem>>1)) {
389 free_early(ramdisk_image, ramdisk_end);
390 printk(KERN_ERR "initrd too large to handle, "
391 "disabling initrd\n");
392 return;
393 }
394
395 printk(KERN_INFO "RAMDISK: %08llx - %08llx\n", ramdisk_image,
396 ramdisk_end);
397
398
399 if (ramdisk_end <= end_of_lowmem) {
400 /* All in lowmem, easy case */
401 /*
402 * don't need to reserve again, already reserved early
403 * in i386_start_kernel
404 */
405 initrd_start = ramdisk_image + PAGE_OFFSET;
406 initrd_end = initrd_start + ramdisk_size;
407 return;
408 }
409
Yinghai Lueb1379c2008-06-25 17:49:26 -0700410 relocate_initrd();
Yinghai Lu8c5dd8f2009-06-04 19:14:22 -0700411
Yinghai Lueb1379c2008-06-25 17:49:26 -0700412 free_early(ramdisk_image, ramdisk_end);
H. Peter Anvincf8fa922008-01-30 13:32:51 +0100413}
Yinghai Lu225c37d2008-06-22 02:46:58 -0700414#else
Yinghai Lueb1379c2008-06-25 17:49:26 -0700415static void __init reserve_initrd(void)
Yinghai Lu225c37d2008-06-22 02:46:58 -0700416{
417}
H. Peter Anvincf8fa922008-01-30 13:32:51 +0100418#endif /* CONFIG_BLK_DEV_INITRD */
419
Yinghai Lu29f784e2008-06-25 18:00:22 -0700420static void __init parse_setup_data(void)
Yinghai Lu257b0fd2008-06-25 17:56:22 -0700421{
422 struct setup_data *data;
423 u64 pa_data;
424
425 if (boot_params.hdr.version < 0x0209)
426 return;
427 pa_data = boot_params.hdr.setup_data;
428 while (pa_data) {
Jeremy Fitzhardinge88b4c142008-09-07 15:21:16 -0700429 data = early_memremap(pa_data, PAGE_SIZE);
Yinghai Lu257b0fd2008-06-25 17:56:22 -0700430 switch (data->type) {
431 case SETUP_E820_EXT:
432 parse_e820_ext(data, pa_data);
433 break;
434 default:
435 break;
436 }
Yinghai Lu257b0fd2008-06-25 17:56:22 -0700437 pa_data = data->next;
438 early_iounmap(data, PAGE_SIZE);
439 }
440}
441
Yinghai Lua0a0bec2008-07-03 11:37:13 -0700442static void __init e820_reserve_setup_data(void)
Yinghai Lu28bb2232008-06-30 16:20:54 -0700443{
444 struct setup_data *data;
445 u64 pa_data;
Yinghai Lud9a81b42008-07-01 20:04:10 -0700446 int found = 0;
Yinghai Lu28bb2232008-06-30 16:20:54 -0700447
448 if (boot_params.hdr.version < 0x0209)
449 return;
450 pa_data = boot_params.hdr.setup_data;
451 while (pa_data) {
Jeremy Fitzhardinge88b4c142008-09-07 15:21:16 -0700452 data = early_memremap(pa_data, sizeof(*data));
Yinghai Lu28bb2232008-06-30 16:20:54 -0700453 e820_update_range(pa_data, sizeof(*data)+data->len,
454 E820_RAM, E820_RESERVED_KERN);
Yinghai Lud9a81b42008-07-01 20:04:10 -0700455 found = 1;
Yinghai Lu28bb2232008-06-30 16:20:54 -0700456 pa_data = data->next;
457 early_iounmap(data, sizeof(*data));
458 }
Yinghai Lud9a81b42008-07-01 20:04:10 -0700459 if (!found)
460 return;
461
Yinghai Lu28bb2232008-06-30 16:20:54 -0700462 sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
Yinghai Lua0a0bec2008-07-03 11:37:13 -0700463 memcpy(&e820_saved, &e820, sizeof(struct e820map));
Yinghai Lu28bb2232008-06-30 16:20:54 -0700464 printk(KERN_INFO "extended physical RAM map:\n");
465 e820_print_map("reserve setup_data");
466}
467
Yinghai Lua0a0bec2008-07-03 11:37:13 -0700468static void __init reserve_early_setup_data(void)
469{
470 struct setup_data *data;
471 u64 pa_data;
472 char buf[32];
473
474 if (boot_params.hdr.version < 0x0209)
475 return;
476 pa_data = boot_params.hdr.setup_data;
477 while (pa_data) {
Jeremy Fitzhardinge88b4c142008-09-07 15:21:16 -0700478 data = early_memremap(pa_data, sizeof(*data));
Yinghai Lua0a0bec2008-07-03 11:37:13 -0700479 sprintf(buf, "setup data %x", data->type);
480 reserve_early(pa_data, pa_data+sizeof(*data)+data->len, buf);
481 pa_data = data->next;
482 early_iounmap(data, sizeof(*data));
483 }
484}
485
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486/*
Yinghai Luccb4def2008-06-25 17:57:13 -0700487 * --------- Crashkernel reservation ------------------------------
488 */
489
490#ifdef CONFIG_KEXEC
Bernhard Walle32105f72008-06-26 21:54:08 +0200491
Yinghai Luccb4def2008-06-25 17:57:13 -0700492static inline unsigned long long get_total_mem(void)
493{
494 unsigned long long total;
495
Yinghai Lu44280732009-11-22 17:18:49 -0800496 total = max_pfn - min_low_pfn;
Yinghai Luccb4def2008-06-25 17:57:13 -0700497
498 return total << PAGE_SHIFT;
499}
500
Yinghai Lu29f784e2008-06-25 18:00:22 -0700501static void __init reserve_crashkernel(void)
Yinghai Luccb4def2008-06-25 17:57:13 -0700502{
503 unsigned long long total_mem;
504 unsigned long long crash_size, crash_base;
505 int ret;
506
507 total_mem = get_total_mem();
508
509 ret = parse_crashkernel(boot_command_line, total_mem,
510 &crash_size, &crash_base);
Bernhard Walle32105f72008-06-26 21:54:08 +0200511 if (ret != 0 || crash_size <= 0)
512 return;
513
514 /* 0 means: find the address automatically */
515 if (crash_base <= 0) {
Yinghai Lu44280732009-11-22 17:18:49 -0800516 const unsigned long long alignment = 16<<20; /* 16M */
517
518 crash_base = find_e820_area(alignment, ULONG_MAX, crash_size,
519 alignment);
Bernhard Walle32105f72008-06-26 21:54:08 +0200520 if (crash_base == -1ULL) {
Yinghai Lu44280732009-11-22 17:18:49 -0800521 pr_info("crashkernel reservation failed - No suitable area found.\n");
Yinghai Luccb4def2008-06-25 17:57:13 -0700522 return;
523 }
Bernhard Walle32105f72008-06-26 21:54:08 +0200524 } else {
Yinghai Lu44280732009-11-22 17:18:49 -0800525 unsigned long long start;
526
527 start = find_e820_area(crash_base, ULONG_MAX, crash_size,
528 1<<20);
529 if (start != crash_base) {
530 pr_info("crashkernel reservation failed - memory is in use.\n");
Yinghai Luccb4def2008-06-25 17:57:13 -0700531 return;
532 }
Yinghai Luccb4def2008-06-25 17:57:13 -0700533 }
Yinghai Lu44280732009-11-22 17:18:49 -0800534 reserve_early(crash_base, crash_base + crash_size, "CRASH KERNEL");
Bernhard Walle32105f72008-06-26 21:54:08 +0200535
536 printk(KERN_INFO "Reserving %ldMB of memory at %ldMB "
537 "for crashkernel (System RAM: %ldMB)\n",
538 (unsigned long)(crash_size >> 20),
539 (unsigned long)(crash_base >> 20),
540 (unsigned long)(total_mem >> 20));
541
542 crashk_res.start = crash_base;
543 crashk_res.end = crash_base + crash_size - 1;
544 insert_resource(&iomem_resource, &crashk_res);
Yinghai Luccb4def2008-06-25 17:57:13 -0700545}
546#else
Yinghai Lu29f784e2008-06-25 18:00:22 -0700547static void __init reserve_crashkernel(void)
Yinghai Luccb4def2008-06-25 17:57:13 -0700548{
549}
550#endif
551
Yinghai Lubdba0e72008-06-25 17:58:02 -0700552static struct resource standard_io_resources[] = {
553 { .name = "dma1", .start = 0x00, .end = 0x1f,
554 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
555 { .name = "pic1", .start = 0x20, .end = 0x21,
556 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
557 { .name = "timer0", .start = 0x40, .end = 0x43,
558 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
559 { .name = "timer1", .start = 0x50, .end = 0x53,
560 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
561 { .name = "keyboard", .start = 0x60, .end = 0x60,
562 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
563 { .name = "keyboard", .start = 0x64, .end = 0x64,
564 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
565 { .name = "dma page reg", .start = 0x80, .end = 0x8f,
566 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
567 { .name = "pic2", .start = 0xa0, .end = 0xa1,
568 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
569 { .name = "dma2", .start = 0xc0, .end = 0xdf,
570 .flags = IORESOURCE_BUSY | IORESOURCE_IO },
571 { .name = "fpu", .start = 0xf0, .end = 0xff,
572 .flags = IORESOURCE_BUSY | IORESOURCE_IO }
573};
574
Thomas Gleixner8fee6972009-08-19 14:55:50 +0200575void __init reserve_standard_io_resources(void)
Yinghai Lubdba0e72008-06-25 17:58:02 -0700576{
577 int i;
578
579 /* request I/O space for devices used on all i[345]86 PCs */
580 for (i = 0; i < ARRAY_SIZE(standard_io_resources); i++)
581 request_resource(&ioport_resource, &standard_io_resources[i]);
582
583}
584
Vivek Goyal57cac4d2008-10-18 20:28:25 -0700585/*
586 * Note: elfcorehdr_addr is not just limited to vmcore. It is also used by
587 * is_kdump_kernel() to determine if we are booting after a panic. Hence
588 * ifdef it under CONFIG_CRASH_DUMP and not CONFIG_PROC_VMCORE.
589 */
590
591#ifdef CONFIG_CRASH_DUMP
Yinghai Lu0196bcb2008-06-25 17:58:55 -0700592/* elfcorehdr= specifies the location of elf core header
593 * stored by the crashed kernel. This option will be passed
594 * by kexec loader to the capture kernel.
595 */
596static int __init setup_elfcorehdr(char *arg)
597{
598 char *end;
599 if (!arg)
600 return -EINVAL;
601 elfcorehdr_addr = memparse(arg, &end);
602 return end > arg ? 0 : -EINVAL;
603}
604early_param("elfcorehdr", setup_elfcorehdr);
605#endif
606
Richard A. Holden IIIbb557462008-11-19 16:05:15 -0700607#ifdef CONFIG_X86_RESERVE_LOW_64K
Ingo Molnar5649b7c2008-09-16 09:29:09 +0200608static int __init dmi_low_memory_corruption(const struct dmi_system_id *d)
609{
610 printk(KERN_NOTICE
Alex Chiang45608392009-02-04 16:44:01 -0700611 "%s detected: BIOS may corrupt low RAM, working around it.\n",
Ingo Molnar5649b7c2008-09-16 09:29:09 +0200612 d->ident);
613
Yinghai Lu2216d192008-09-22 02:52:26 -0700614 e820_update_range(0, 0x10000, E820_RAM, E820_RESERVED);
615 sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
Ingo Molnar5649b7c2008-09-16 09:29:09 +0200616
617 return 0;
618}
Richard A. Holden IIIbb557462008-11-19 16:05:15 -0700619#endif
Ingo Molnar5649b7c2008-09-16 09:29:09 +0200620
621/* List of systems that have known low memory corruption BIOS problems */
622static struct dmi_system_id __initdata bad_bios_dmi_table[] = {
Ingo Molnarfc381512008-09-16 10:07:34 +0200623#ifdef CONFIG_X86_RESERVE_LOW_64K
Ingo Molnar5649b7c2008-09-16 09:29:09 +0200624 {
625 .callback = dmi_low_memory_corruption,
626 .ident = "AMI BIOS",
627 .matches = {
628 DMI_MATCH(DMI_BIOS_VENDOR, "American Megatrends Inc."),
629 },
630 },
Ingo Molnar1e224362008-09-16 09:58:02 +0200631 {
632 .callback = dmi_low_memory_corruption,
633 .ident = "Phoenix BIOS",
634 .matches = {
Philipp Kohlbecher0af40a42008-11-16 12:11:01 +0100635 DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies"),
Ingo Molnar1e224362008-09-16 09:58:02 +0200636 },
637 },
Alexey Fisher6aa542a2009-07-15 14:16:09 +0200638 {
Simon Kagstromf1b291d2009-11-06 15:44:04 +0100639 .callback = dmi_low_memory_corruption,
640 .ident = "Phoenix/MSC BIOS",
641 .matches = {
642 DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix/MSC"),
643 },
644 },
645 {
Alexey Fisher6aa542a2009-07-15 14:16:09 +0200646 /*
647 * AMI BIOS with low memory corruption was found on Intel DG45ID board.
648 * It hase different DMI_BIOS_VENDOR = "Intel Corp.", for now we will
649 * match only DMI_BOARD_NAME and see if there is more bad products
650 * with this vendor.
651 */
652 .callback = dmi_low_memory_corruption,
653 .ident = "AMI BIOS",
654 .matches = {
655 DMI_MATCH(DMI_BOARD_NAME, "DG45ID"),
656 },
657 },
Ingo Molnarfc381512008-09-16 10:07:34 +0200658#endif
Yinghai Lua8b71a22008-09-23 00:35:33 -0700659 {}
Ingo Molnar5649b7c2008-09-16 09:29:09 +0200660};
661
Jeremy Fitzhardinge5394f802008-09-07 01:51:32 -0700662/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 * Determine if we were loaded by an EFI loader. If so, then we have also been
664 * passed the efi memmap, systab, etc., so we should use these data structures
665 * for initialization. Note, the efi init code path is determined by the
666 * global efi_enabled. This allows the same kernel image to be used on existing
667 * systems (with a traditional BIOS) as well as on EFI systems.
668 */
Yinghai Lu76934ed2008-06-25 17:52:35 -0700669/*
670 * setup_arch - architecture-specific boot-time initializations
671 *
672 * Note: On x86_64, fixmaps are ready for use even before this is called.
673 */
674
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675void __init setup_arch(char **cmdline_p)
676{
David Rientjes8ee2deb2009-09-25 15:20:00 -0700677 int acpi = 0;
678 int k8 = 0;
679
Yinghai Lu76934ed2008-06-25 17:52:35 -0700680#ifdef CONFIG_X86_32
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 memcpy(&boot_cpu_data, &new_cpu_data, sizeof(new_cpu_data));
Ingo Molnar3b335532008-07-10 17:30:40 +0200682 visws_early_detect();
Yinghai Lu76934ed2008-06-25 17:52:35 -0700683#else
684 printk(KERN_INFO "Command line: %s\n", boot_command_line);
685#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686
Zachary Amsdenae8d04e2008-12-13 12:36:58 -0800687 /* VMI may relocate the fixmap; do this before touching ioremap area */
688 vmi_init();
689
Jeremy Fitzhardinge9e882c92008-07-21 16:49:54 -0700690 early_cpu_init();
Jeremy Fitzhardinge1a98fd12008-06-29 20:02:44 -0700691 early_ioremap_init();
692
H. Peter Anvin30c82642007-10-15 17:13:22 -0700693 ROOT_DEV = old_decode_dev(boot_params.hdr.root_dev);
694 screen_info = boot_params.screen_info;
695 edid_info = boot_params.edid_info;
Yinghai Lu76934ed2008-06-25 17:52:35 -0700696#ifdef CONFIG_X86_32
H. Peter Anvin30c82642007-10-15 17:13:22 -0700697 apm_info.bios = boot_params.apm_bios_info;
698 ist_info = boot_params.ist_info;
Yinghai Lu76934ed2008-06-25 17:52:35 -0700699 if (boot_params.sys_desc_table.length != 0) {
H. Peter Anvin30c82642007-10-15 17:13:22 -0700700 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];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 }
Yinghai Lu76934ed2008-06-25 17:52:35 -0700705#endif
706 saved_video_mode = boot_params.hdr.vid_mode;
H. Peter Anvin30c82642007-10-15 17:13:22 -0700707 bootloader_type = boot_params.hdr.type_of_loader;
H. Peter Anvin50312962009-05-07 16:54:11 -0700708 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714
715#ifdef CONFIG_BLK_DEV_RAM
H. Peter Anvin30c82642007-10-15 17:13:22 -0700716 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719#endif
Yinghai Lu74652522008-06-23 19:53:33 -0700720#ifdef CONFIG_EFI
721 if (!strncmp((char *)&boot_params.efi_info.efi_loader_signature,
Yinghai Lu76934ed2008-06-25 17:52:35 -0700722#ifdef CONFIG_X86_32
723 "EL32",
724#else
725 "EL64",
726#endif
727 4)) {
Yinghai Lu74652522008-06-23 19:53:33 -0700728 efi_enabled = 1;
729 efi_reserve_early();
730 }
731#endif
732
Thomas Gleixner42bbdb42009-08-20 13:04:10 +0200733 x86_init.oem.arch_setup();
Huang, Ying2215e692008-01-30 13:31:19 +0100734
Alexander van Heukelum0dbfafa2008-04-23 15:09:05 +0200735 setup_memory_map();
Yinghai Lu28bb2232008-06-30 16:20:54 -0700736 parse_setup_data();
Yinghai Lua0a0bec2008-07-03 11:37:13 -0700737 /* update the e820_saved too */
738 e820_reserve_setup_data();
Yinghai Lu28bb2232008-06-30 16:20:54 -0700739
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 copy_edd();
741
H. Peter Anvin30c82642007-10-15 17:13:22 -0700742 if (!boot_params.hdr.root_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 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;
Jeremy Fitzhardinge93dbda72009-02-26 17:35:44 -0800747 init_mm.brk = _brk_end;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748
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;
Bernhard Walle00bf4092007-10-21 16:42:01 -0700753 bss_resource.start = virt_to_phys(&__bss_start);
754 bss_resource.end = virt_to_phys(&__bss_stop)-1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755
Tim Bird516cbf32008-08-12 12:52:36 -0700756#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
Yinghai Lueda6da92009-09-19 11:07:57 -0700769 strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE);
770 *cmdline_p = command_line;
771
Yinghai Lueda6da92009-09-19 11:07:57 -0700772 /*
Kees Cook4b0f3b82009-11-13 15:28:17 -0800773 * x86_configure_nx() is called before parse_early_param() to detect
774 * whether hardware doesn't support NX (so that the early EHCI debug
775 * console setup can safely call set_fixmap()). It may then be called
776 * again from within noexec_setup() during parsing early parameters
777 * to honor the respective command line option.
Yinghai Lueda6da92009-09-19 11:07:57 -0700778 */
H. Peter Anvin4763ed42009-11-13 15:28:16 -0800779 x86_configure_nx();
Yinghai Lueda6da92009-09-19 11:07:57 -0700780
781 parse_early_param();
782
Kees Cook4b0f3b82009-11-13 15:28:17 -0800783 x86_report_nx();
Jeremy Fitzhardinge0ad5bce2008-09-11 16:42:00 -0700784
Zachary Amsdenae8d04e2008-12-13 12:36:58 -0800785 /* Must be before kernel pagetables are setup */
786 vmi_activate();
Alok Kataria3a6ddd52008-08-21 11:32:26 -0700787
Yinghai Lu28bb2232008-06-30 16:20:54 -0700788 /* after early param, so could get panic from serial */
Yinghai Lua0a0bec2008-07-03 11:37:13 -0700789 reserve_early_setup_data();
Yinghai Lu28bb2232008-06-30 16:20:54 -0700790
Yinghai Lu76934ed2008-06-25 17:52:35 -0700791 if (acpi_mps_check()) {
Ingo Molnar3eb11ed2008-06-23 22:19:22 +0200792#ifdef CONFIG_X86_LOCAL_APIC
Yinghai Lu76934ed2008-06-25 17:52:35 -0700793 disable_apic = 1;
794#endif
Yinghai Lu988781d2008-07-21 11:21:43 -0700795 setup_clear_cpu_cap(X86_FEATURE_APIC);
Yinghai Lu3c999f12008-06-20 16:11:20 -0700796 }
797
Linus Torvaldsdc7c65d2008-07-16 17:25:46 -0700798#ifdef CONFIG_PCI
799 if (pci_early_dump_regs)
800 early_dump_pci_devices();
Glauber de Oliveira Costa4fe29a82008-03-19 14:25:23 -0300801#endif
Linus Torvaldsdc7c65d2008-07-16 17:25:46 -0700802
Alexander van Heukelum0dbfafa2008-04-23 15:09:05 +0200803 finish_e820_parsing();
Rusty Russell1a3f2392006-09-26 10:52:32 +0200804
Brian Malyff0c0872009-03-03 21:55:31 -0500805 if (efi_enabled)
806 efi_init();
807
Yinghai Lu2216d192008-09-22 02:52:26 -0700808 dmi_scan_machine();
809
810 dmi_check_system(bad_bios_dmi_table);
811
Alok Kataria88b094f2008-10-27 10:41:46 -0700812 /*
813 * VMware detection requires dmi to be available, so this
814 * needs to be done after dmi_scan_machine, for the BP.
815 */
Thomas Gleixner2d826402009-08-20 17:06:25 +0200816 init_hypervisor_platform();
Alok Kataria88b094f2008-10-27 10:41:46 -0700817
Thomas Gleixnerf7cf5a52009-08-19 14:43:56 +0200818 x86_init.resources.probe_roms();
Yinghai Lu41c094f2008-06-16 13:03:31 -0700819
820 /* after parse_early_param, so could debug it */
821 insert_resource(&iomem_resource, &code_resource);
822 insert_resource(&iomem_resource, &data_resource);
823 insert_resource(&iomem_resource, &bss_resource);
824
Huang, Ying8b2cb7a2008-01-30 13:32:11 +0100825
Yinghai Lu76934ed2008-06-25 17:52:35 -0700826#ifdef CONFIG_X86_32
Yinghai Lucc9f7a02008-06-16 16:11:08 -0700827 if (ppro_with_ram_bug()) {
828 e820_update_range(0x70000000ULL, 0x40000ULL, E820_RAM,
829 E820_RESERVED);
830 sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
831 printk(KERN_INFO "fixed physical RAM map:\n");
832 e820_print_map("bad_ppro");
833 }
Yinghai Lu76934ed2008-06-25 17:52:35 -0700834#else
835 early_gart_iommu_check();
836#endif
Yinghai Lucc9f7a02008-06-16 16:11:08 -0700837
Yinghai Lu7b2a0a62008-06-03 19:35:04 -0700838 /*
839 * partially used pages are not usable - thus
840 * we are rounding upwards:
841 */
Yinghai Luf361a452008-07-10 20:38:26 -0700842 max_pfn = e820_end_of_ram_pfn();
Yinghai Lu7b2a0a62008-06-03 19:35:04 -0700843
Yinghai Lu67807112008-06-08 19:53:26 -0700844 /* preallocate 4k for mptable mpc */
845 early_reserve_e820_mpc_new();
Yinghai Lu093af8d2008-01-30 13:33:32 +0100846 /* update e820 for memory not covered by WB MTRRs */
847 mtrr_bp_init();
Yinghai Lu2dc807b2008-07-08 18:56:38 -0700848 if (mtrr_trim_uncached_memory(max_pfn))
Yinghai Luf361a452008-07-10 20:38:26 -0700849 max_pfn = e820_end_of_ram_pfn();
Yinghai Lu76c324182008-03-23 00:16:49 -0700850
Yinghai Lu76934ed2008-06-25 17:52:35 -0700851#ifdef CONFIG_X86_32
Yinghai Lu4e296842008-06-24 12:18:14 -0700852 /* max_low_pfn get updated here */
Yinghai Lu2ec65f82008-06-23 03:05:30 -0700853 find_low_pfn_range();
Yinghai Lu76934ed2008-06-25 17:52:35 -0700854#else
855 num_physpages = max_pfn;
856
Yinghai Lu06cd9a72009-02-16 17:29:58 -0800857 check_x2apic();
Yinghai Lu76934ed2008-06-25 17:52:35 -0700858
859 /* How many end-of-memory variables you have, grandma! */
860 /* need this before calling reserve_initrd */
Yinghai Luf361a452008-07-10 20:38:26 -0700861 if (max_pfn > (1UL<<(32 - PAGE_SHIFT)))
862 max_low_pfn = e820_end_of_low_ram_pfn();
863 else
864 max_low_pfn = max_pfn;
865
Yinghai Lu76934ed2008-06-25 17:52:35 -0700866 high_memory = (void *)__va(max_pfn * PAGE_SIZE - 1) + 1;
Yinghai Lu80989ce2009-05-09 23:47:42 -0700867 max_pfn_mapped = KERNEL_IMAGE_SIZE >> PAGE_SHIFT;
Yinghai Lu76934ed2008-06-25 17:52:35 -0700868#endif
Yinghai Lu2ec65f82008-06-23 03:05:30 -0700869
Jeremy Fitzhardinge5394f802008-09-07 01:51:32 -0700870#ifdef CONFIG_X86_CHECK_BIOS_CORRUPTION
871 setup_bios_corruption_check();
872#endif
873
Yinghai Lu80989ce2009-05-09 23:47:42 -0700874 printk(KERN_DEBUG "initial memory mapped : 0 - %08lx\n",
875 max_pfn_mapped<<PAGE_SHIFT);
876
Jeremy Fitzhardinge93dbda72009-02-26 17:35:44 -0800877 reserve_brk();
878
Yinghai Lu893f38d2009-12-10 13:07:22 -0800879 /*
880 * Find and reserve possible boot-time SMP configuration:
881 */
882 find_smp_config();
883
884 reserve_trampoline_memory();
885
Yinghai Lu196cf0d2009-11-10 18:27:23 -0800886#ifdef CONFIG_ACPI_SLEEP
887 /*
888 * Reserve low memory region for sleep support.
889 * even before init_memory_mapping
890 */
891 acpi_reserve_wakeup_memory();
892#endif
Pekka J Enberg854c8792009-06-22 17:39:41 +0300893 init_gbpages();
894
Yinghai Lu4e296842008-06-24 12:18:14 -0700895 /* max_pfn_mapped is updated here */
Yinghai Luf361a452008-07-10 20:38:26 -0700896 max_low_pfn_mapped = init_memory_mapping(0, max_low_pfn<<PAGE_SHIFT);
897 max_pfn_mapped = max_low_pfn_mapped;
898
899#ifdef CONFIG_X86_64
900 if (max_pfn > max_low_pfn) {
901 max_pfn_mapped = init_memory_mapping(1UL<<32,
902 max_pfn<<PAGE_SHIFT);
903 /* can we preseve max_low_pfn ?*/
904 max_low_pfn = max_pfn;
905 }
906#endif
Yinghai Lu4e296842008-06-24 12:18:14 -0700907
Yinghai Lue7b37892008-06-25 21:51:28 -0700908 /*
909 * NOTE: On x86-32, only from this point on, fixmaps are ready for use.
910 */
911
912#ifdef CONFIG_PROVIDE_OHCI1394_DMA_INIT
913 if (init_ohci1394_dma_early)
914 init_ohci1394_dma_on_all_controllers();
915#endif
916
Yinghai Lu2ec65f82008-06-23 03:05:30 -0700917 reserve_initrd();
918
Yinghai Lu44280732009-11-22 17:18:49 -0800919 reserve_crashkernel();
920
Yinghai Lu76934ed2008-06-25 17:52:35 -0700921 vsmp_init();
Yinghai Lu76934ed2008-06-25 17:52:35 -0700922
Yinghai Lu1c6e5502008-06-17 15:41:45 -0700923 io_delay_init();
924
Yinghai Lu1c6e5502008-06-17 15:41:45 -0700925 /*
926 * Parse the ACPI tables for possible boot-time SMP configuration.
927 */
928 acpi_boot_table_init();
Yinghai Lu1c6e5502008-06-17 15:41:45 -0700929
Jack Steiner2e420602008-09-23 15:37:13 -0500930 early_acpi_boot_init();
931
Yinghai Lu1c6e5502008-06-17 15:41:45 -0700932#ifdef CONFIG_ACPI_NUMA
Yinghai Luf2f865f2008-06-25 17:53:22 -0700933 /*
934 * Parse SRAT to discover nodes.
935 */
David Rientjes87162732009-09-25 15:20:04 -0700936 acpi = acpi_numa_init();
Yinghai Lu1c6e5502008-06-17 15:41:45 -0700937#endif
938
David Rientjes8ee2deb2009-09-25 15:20:00 -0700939#ifdef CONFIG_K8_NUMA
David Rientjes87162732009-09-25 15:20:04 -0700940 if (!acpi)
941 k8 = !k8_numa_init(0, max_pfn);
David Rientjes8ee2deb2009-09-25 15:20:00 -0700942#endif
943
944 initmem_init(0, max_pfn, acpi, k8);
Yinghai Lu593a0cc2008-06-17 10:02:45 -0700945
Bernhard Walle91467bd2008-07-18 19:07:53 +0200946#ifdef CONFIG_X86_64
947 /*
948 * dma32_reserve_bootmem() allocates bootmem which may conflict
949 * with the crashkernel command line, so do that after
950 * reserve_crashkernel()
951 */
952 dma32_reserve_bootmem();
953#endif
954
Yinghai Lu593a0cc2008-06-17 10:02:45 -0700955 reserve_ibft_region();
956
Glauber de Oliveira Costa790c73f2008-02-15 17:52:48 -0200957#ifdef CONFIG_KVM_CLOCK
958 kvmclock_init();
959#endif
960
Thomas Gleixner030cb6c2009-08-20 14:30:02 +0200961 x86_init.paging.pagetable_setup_start(swapper_pg_dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962 paging_init();
Thomas Gleixner030cb6c2009-08-20 14:30:02 +0200963 x86_init.paging.pagetable_setup_done(swapper_pg_dir);
Bernhard Kaindlf212ec42008-01-30 13:34:11 +0100964
Joseph Cihula31625342009-06-30 19:30:59 -0700965 tboot_probe();
966
Yinghai Lu76934ed2008-06-25 17:52:35 -0700967#ifdef CONFIG_X86_64
968 map_vsyscall();
969#endif
970
Rusty Russell1a3f2392006-09-26 10:52:32 +0200971 generic_apic_probe();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972
Andi Kleen54ef3402007-10-19 20:35:03 +0200973 early_quirks();
Andy Curridd44647b2006-06-08 00:43:38 -0700974
Yinghai Lu295deae2008-06-23 19:55:05 -0700975 /*
976 * Read APIC and some other early information from ACPI tables.
977 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978 acpi_boot_init();
Yinghai Lu04606612008-06-21 01:38:41 -0700979
Feng Tangefafc8b2009-08-14 15:23:29 -0400980 sfi_init();
981
Yinghai Lu295deae2008-06-23 19:55:05 -0700982 /*
983 * get boot-time SMP configuration:
984 */
Yinghai Lue0da3362008-06-08 18:29:22 -0700985 if (smp_found_config)
986 get_smp_config();
Yinghai Lu76934ed2008-06-25 17:52:35 -0700987
Yinghai Lu329513a2008-07-02 18:54:40 -0700988 prefill_possible_map();
Yinghai Lu301e6192008-08-19 20:50:02 -0700989
Yinghai Lu5f4765f2008-07-02 18:53:44 -0700990#ifdef CONFIG_X86_64
991 init_cpu_to_node();
992#endif
993
Yinghai Lu76934ed2008-06-25 17:52:35 -0700994 init_apic_mappings();
995 ioapic_init_mappings();
Yinghai Luf3294a32008-06-27 01:41:56 -0700996
Yinghai Lu9d6a4d02008-08-19 20:50:52 -0700997 /* need to wait for io_apic is mapped */
Yinghai Lube5d5352008-12-05 18:58:33 -0800998 probe_nr_irqs_gsi();
Yinghai Lu9d6a4d02008-08-19 20:50:52 -0700999
Yinghai Lu295deae2008-06-23 19:55:05 -07001000 kvm_guest_init();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001
Yinghai Lu41c094f2008-06-16 13:03:31 -07001002 e820_reserve_resources();
Yinghai Lubf62f392008-05-20 20:10:58 -07001003 e820_mark_nosave_regions(max_low_pfn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004
Thomas Gleixner8fee6972009-08-19 14:55:50 +02001005 x86_init.resources.reserve_resources();
Yinghai Lu41c094f2008-06-16 13:03:31 -07001006
1007 e820_setup_gap();
1008
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009#ifdef CONFIG_VT
1010#if defined(CONFIG_VGA_CONSOLE)
1011 if (!efi_enabled || (efi_mem_type(0xa0000) != EFI_CONVENTIONAL_MEMORY))
1012 conswitchp = &vga_con;
1013#elif defined(CONFIG_DUMMY_CONSOLE)
1014 conswitchp = &dummy_con;
1015#endif
1016#endif
Thomas Gleixner6f30c1a2009-08-20 13:19:57 +02001017 x86_init.oem.banner();
Yong Wanga2202aa2009-11-10 09:38:24 +08001018
1019 mcheck_init();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020}
Ingo Molnar5649b7c2008-09-16 09:29:09 +02001021
Ingo Molnar9be1b562009-02-17 23:12:48 +01001022#ifdef CONFIG_X86_32
Ingo Molnar5649b7c2008-09-16 09:29:09 +02001023
Thomas Gleixner8fee6972009-08-19 14:55:50 +02001024static struct resource video_ram_resource = {
1025 .name = "Video RAM area",
1026 .start = 0xa0000,
1027 .end = 0xbffff,
1028 .flags = IORESOURCE_BUSY | IORESOURCE_MEM
Ingo Molnar9be1b562009-02-17 23:12:48 +01001029};
1030
Thomas Gleixner8fee6972009-08-19 14:55:50 +02001031void __init i386_reserve_resources(void)
Ingo Molnar9be1b562009-02-17 23:12:48 +01001032{
Thomas Gleixner8fee6972009-08-19 14:55:50 +02001033 request_resource(&iomem_resource, &video_ram_resource);
1034 reserve_standard_io_resources();
Ingo Molnar9be1b562009-02-17 23:12:48 +01001035}
1036
Ingo Molnar9be1b562009-02-17 23:12:48 +01001037#endif /* CONFIG_X86_32 */