setup.c 21.3 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
/*
 *  Copyright (C) 1995  Linus Torvalds
 *
 *  Support of BIGMEM added by Gerhard Wichert, Siemens AG, July 1999
 *
 *  Memory region support
 *	David Parsons <orc@pell.chi.il.us>, July-August 1999
 *
 *  Added E820 sanitization routine (removes overlapping memory regions);
 *  Brian Moyle <bmoyle@mvista.com>, February 2001
 *
 * Moved CPU detection code to cpu/${cpu}.c
 *    Patrick Mochel <mochel@osdl.org>, March 2002
 *
 *  Provisions for empty E820 memory regions (reported by certain BIOSes).
 *  Alex Achenbach <xela@slit.de>, December 2002.
 *
 */

/*
 * This file handles the architecture-dependent parts of initialization
 */

#include <linux/sched.h>
#include <linux/mm.h>
26
#include <linux/mmzone.h>
27
#include <linux/screen_info.h>
L
Linus Torvalds 已提交
28 29 30 31 32 33 34 35 36 37 38 39 40 41
#include <linux/ioport.h>
#include <linux/acpi.h>
#include <linux/apm_bios.h>
#include <linux/initrd.h>
#include <linux/bootmem.h>
#include <linux/seq_file.h>
#include <linux/console.h>
#include <linux/mca.h>
#include <linux/root_dev.h>
#include <linux/highmem.h>
#include <linux/module.h>
#include <linux/efi.h>
#include <linux/init.h>
#include <linux/edd.h>
42
#include <linux/iscsi_ibft.h>
L
Linus Torvalds 已提交
43
#include <linux/nodemask.h>
44
#include <linux/kexec.h>
45
#include <linux/dmi.h>
D
Dave Hansen 已提交
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 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/stddef.h>
#include <linux/unistd.h>
#include <linux/ptrace.h>
#include <linux/slab.h>
#include <linux/user.h>
#include <linux/delay.h>
#include <linux/highmem.h>

#include <linux/kallsyms.h>
#include <linux/edd.h>
#include <linux/iscsi_ibft.h>
#include <linux/kexec.h>
#include <linux/cpufreq.h>
#include <linux/dma-mapping.h>
#include <linux/ctype.h>
#include <linux/uaccess.h>

#include <linux/percpu.h>
#include <linux/crash_dump.h>

L
Linus Torvalds 已提交
74
#include <video/edid.h>
75

76
#include <asm/mtrr.h>
77
#include <asm/apic.h>
L
Linus Torvalds 已提交
78 79 80 81
#include <asm/e820.h>
#include <asm/mpspec.h>
#include <asm/setup.h>
#include <asm/arch_hooks.h>
Y
Yinghai Lu 已提交
82
#include <asm/efi.h>
L
Linus Torvalds 已提交
83
#include <asm/sections.h>
84
#include <asm/dmi.h>
L
Linus Torvalds 已提交
85 86
#include <asm/io_apic.h>
#include <asm/ist.h>
87
#include <asm/vmi.h>
88
#include <setup_arch.h>
89
#include <asm/bios_ebda.h>
B
Bernhard Walle 已提交
90
#include <asm/cacheflush.h>
91
#include <asm/processor.h>
Y
Yinghai Lu 已提交
92
#include <asm/bugs.h>
L
Linus Torvalds 已提交
93

94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109
#include <asm/system.h>
#include <asm/vsyscall.h>
#include <asm/smp.h>
#include <asm/desc.h>
#include <asm/dma.h>
#include <asm/gart.h>
#include <asm/mmu_context.h>
#include <asm/proto.h>

#include <mach_apic.h>
#include <asm/paravirt.h>

#include <asm/percpu.h>
#include <asm/sections.h>
#include <asm/topology.h>
#include <asm/apicdef.h>
Y
Yinghai Lu 已提交
110 111 112
#ifdef CONFIG_X86_64
#include <asm/numa_64.h>
#endif
113

Y
Yinghai Lu 已提交
114 115 116 117
#ifndef ARCH_SETUP
#define ARCH_SETUP
#endif

118 119 120 121 122 123
#ifndef CONFIG_DEBUG_BOOT_PARAMS
struct boot_params __initdata boot_params;
#else
struct boot_params boot_params;
#endif

L
Linus Torvalds 已提交
124 125 126
/*
 * Machine setup..
 */
127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147
static struct resource data_resource = {
	.name	= "Kernel data",
	.start	= 0,
	.end	= 0,
	.flags	= IORESOURCE_BUSY | IORESOURCE_MEM
};

static struct resource code_resource = {
	.name	= "Kernel code",
	.start	= 0,
	.end	= 0,
	.flags	= IORESOURCE_BUSY | IORESOURCE_MEM
};

static struct resource bss_resource = {
	.name	= "Kernel bss",
	.start	= 0,
	.end	= 0,
	.flags	= IORESOURCE_BUSY | IORESOURCE_MEM
};

148 149

#ifdef CONFIG_X86_32
150 151 152 153 154 155
/* This value is set up by the early boot code to point to the value
   immediately after the boot time page tables.  It contains a *physical*
   address, and must not be in the .bss segment! */
unsigned long init_pg_tables_start __initdata = ~0UL;
unsigned long init_pg_tables_end __initdata = ~0UL;

156 157 158 159 160 161 162
static struct resource video_ram_resource = {
	.name	= "Video RAM area",
	.start	= 0xa0000,
	.end	= 0xbffff,
	.flags	= IORESOURCE_BUSY | IORESOURCE_MEM
};

L
Linus Torvalds 已提交
163
/* cpu data as detected by the assembly code in head.S */
164
struct cpuinfo_x86 new_cpu_data __cpuinitdata = {0, 0, 0, 0, -1, 1, 0, 0, -1};
L
Linus Torvalds 已提交
165
/* common cpu data for all cpus */
166
struct cpuinfo_x86 boot_cpu_data __read_mostly = {0, 0, 0, 0, -1, 1, 0, 0, -1};
167
EXPORT_SYMBOL(boot_cpu_data);
168 169 170 171 172 173
static void set_mca_bus(int x)
{
#ifdef CONFIG_MCA
	MCA_bus = x;
#endif
}
L
Linus Torvalds 已提交
174

175 176
unsigned int def_to_bigsmp;

L
Linus Torvalds 已提交
177 178 179 180 181
/* for MCA, but anyone else can use it if they want */
unsigned int machine_id;
unsigned int machine_submodel_id;
unsigned int BIOS_revision;

182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204
struct apm_info apm_info;
EXPORT_SYMBOL(apm_info);

#if defined(CONFIG_X86_SPEEDSTEP_SMI) || \
	defined(CONFIG_X86_SPEEDSTEP_SMI_MODULE)
struct ist_info ist_info;
EXPORT_SYMBOL(ist_info);
#else
struct ist_info ist_info;
#endif

#else
struct cpuinfo_x86 boot_cpu_data __read_mostly;
EXPORT_SYMBOL(boot_cpu_data);
#endif


#if !defined(CONFIG_X86_PAE) || defined(CONFIG_X86_64)
unsigned long mmu_cr4_features;
#else
unsigned long mmu_cr4_features = X86_CR4_PAE;
#endif

L
Linus Torvalds 已提交
205 206 207
/* Boot loader ID as an integer, for the benefit of proc_dointvec */
int bootloader_type;

208 209 210 211 212 213
/*
 * Early DMI memory
 */
int dmi_alloc_index;
char dmi_alloc_data[DMI_MAX_DATA];

L
Linus Torvalds 已提交
214 215 216 217
/*
 * Setup options
 */
struct screen_info screen_info;
218
EXPORT_SYMBOL(screen_info);
L
Linus Torvalds 已提交
219
struct edid_info edid_info;
220
EXPORT_SYMBOL_GPL(edid_info);
L
Linus Torvalds 已提交
221 222 223

extern int root_mountflags;

224
unsigned long saved_video_mode;
L
Linus Torvalds 已提交
225

226
#define RAMDISK_IMAGE_START_MASK	0x07FF
L
Linus Torvalds 已提交
227
#define RAMDISK_PROMPT_FLAG		0x8000
228
#define RAMDISK_LOAD_FLAG		0x4000
L
Linus Torvalds 已提交
229

230
static char __initdata command_line[COMMAND_LINE_SIZE];
L
Linus Torvalds 已提交
231 232 233 234 235 236 237 238 239 240 241 242 243

#if defined(CONFIG_EDD) || defined(CONFIG_EDD_MODULE)
struct edd edd;
#ifdef CONFIG_EDD_MODULE
EXPORT_SYMBOL(edd);
#endif
/**
 * copy_edd() - Copy the BIOS EDD information
 *              from boot_params into a safe place.
 *
 */
static inline void copy_edd(void)
{
244 245 246 247 248
     memcpy(edd.mbr_signature, boot_params.edd_mbr_sig_buffer,
	    sizeof(edd.mbr_signature));
     memcpy(edd.edd_info, boot_params.eddbuf, sizeof(edd.edd_info));
     edd.mbr_signature_nr = boot_params.edd_mbr_sig_buf_entries;
     edd.edd_info_nr = boot_params.eddbuf_entries;
L
Linus Torvalds 已提交
249 250 251 252 253 254 255
}
#else
static inline void copy_edd(void)
{
}
#endif

256 257
#ifdef CONFIG_BLK_DEV_INITRD

258
#ifdef CONFIG_X86_32
259

260 261
#define MAX_MAP_CHUNK	(NR_FIX_BTMAPS << PAGE_SHIFT)
static void __init relocate_initrd(void)
262
{
263

264 265 266 267
	u64 ramdisk_image = boot_params.hdr.ramdisk_image;
	u64 ramdisk_size  = boot_params.hdr.ramdisk_size;
	u64 end_of_lowmem = max_low_pfn << PAGE_SHIFT;
	u64 ramdisk_here;
268 269
	unsigned long slop, clen, mapaddr;
	char *p, *q;
270 271

	/* We need to move the initrd down into lowmem */
272 273
	ramdisk_here = find_e820_area(0, end_of_lowmem, ramdisk_size,
					 PAGE_SIZE);
274

275 276 277 278
	if (ramdisk_here == -1ULL)
		panic("Cannot find place for new RAMDISK of size %lld\n",
			 ramdisk_size);

279 280
	/* Note: this includes all the lowmem currently occupied by
	   the initrd, we rely on that fact to keep the data intact. */
281
	reserve_early(ramdisk_here, ramdisk_here + ramdisk_size,
282
			 "NEW RAMDISK");
283 284
	initrd_start = ramdisk_here + PAGE_OFFSET;
	initrd_end   = initrd_start + ramdisk_size;
285 286
	printk(KERN_INFO "Allocated new RAMDISK: %08llx - %08llx\n",
			 ramdisk_here, ramdisk_here + ramdisk_size);
287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306

	q = (char *)initrd_start;

	/* Copy any lowmem portion of the initrd */
	if (ramdisk_image < end_of_lowmem) {
		clen = end_of_lowmem - ramdisk_image;
		p = (char *)__va(ramdisk_image);
		memcpy(q, p, clen);
		q += clen;
		ramdisk_image += clen;
		ramdisk_size  -= clen;
	}

	/* Copy the highmem portion of the initrd */
	while (ramdisk_size) {
		slop = ramdisk_image & ~PAGE_MASK;
		clen = ramdisk_size;
		if (clen > MAX_MAP_CHUNK-slop)
			clen = MAX_MAP_CHUNK-slop;
		mapaddr = ramdisk_image & PAGE_MASK;
307
		p = early_ioremap(mapaddr, clen+slop);
308
		memcpy(q, p+slop, clen);
309
		early_iounmap(p, clen+slop);
310 311 312 313
		q += clen;
		ramdisk_image += clen;
		ramdisk_size  -= clen;
	}
314
	/* high pages is not converted by early_res_to_bootmem */
315 316
	ramdisk_image = boot_params.hdr.ramdisk_image;
	ramdisk_size  = boot_params.hdr.ramdisk_size;
317 318
	printk(KERN_INFO "Move RAMDISK from %016llx - %016llx to"
		" %08llx - %08llx\n",
319 320
		ramdisk_image, ramdisk_image + ramdisk_size - 1,
		ramdisk_here, ramdisk_here + ramdisk_size - 1);
321 322
}
#endif
Y
Yinghai Lu 已提交
323

324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367
static void __init reserve_initrd(void)
{
	u64 ramdisk_image = boot_params.hdr.ramdisk_image;
	u64 ramdisk_size  = boot_params.hdr.ramdisk_size;
	u64 ramdisk_end   = ramdisk_image + ramdisk_size;
	u64 end_of_lowmem = max_low_pfn << PAGE_SHIFT;

	if (!boot_params.hdr.type_of_loader ||
	    !ramdisk_image || !ramdisk_size)
		return;		/* No initrd provided by bootloader */

	initrd_start = 0;

	if (ramdisk_size >= (end_of_lowmem>>1)) {
		free_early(ramdisk_image, ramdisk_end);
		printk(KERN_ERR "initrd too large to handle, "
		       "disabling initrd\n");
		return;
	}

	printk(KERN_INFO "RAMDISK: %08llx - %08llx\n", ramdisk_image,
			ramdisk_end);


	if (ramdisk_end <= end_of_lowmem) {
		/* All in lowmem, easy case */
		/*
		 * don't need to reserve again, already reserved early
		 * in i386_start_kernel
		 */
		initrd_start = ramdisk_image + PAGE_OFFSET;
		initrd_end = initrd_start + ramdisk_size;
		return;
	}

#ifdef CONFIG_X86_32
	relocate_initrd();
#else
	printk(KERN_ERR "initrd extends beyond end of memory "
	       "(0x%08llx > 0x%08llx)\ndisabling initrd\n",
	       ramdisk_end, end_of_lowmem);
	initrd_start = 0;
#endif
	free_early(ramdisk_image, ramdisk_end);
368
}
Y
Yinghai Lu 已提交
369
#else
370
static void __init reserve_initrd(void)
Y
Yinghai Lu 已提交
371 372
{
}
373 374
#endif /* CONFIG_BLK_DEV_INITRD */

375
static void __init parse_setup_data(void)
376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396
{
	struct setup_data *data;
	u64 pa_data;

	if (boot_params.hdr.version < 0x0209)
		return;
	pa_data = boot_params.hdr.setup_data;
	while (pa_data) {
		data = early_ioremap(pa_data, PAGE_SIZE);
		switch (data->type) {
		case SETUP_E820_EXT:
			parse_e820_ext(data, pa_data);
			break;
		default:
			break;
		}
		pa_data = data->next;
		early_iounmap(data, PAGE_SIZE);
	}
}

397
static void __init e820_reserve_setup_data(void)
398 399 400
{
	struct setup_data *data;
	u64 pa_data;
401
	int found = 0;
402 403 404 405 406 407 408 409

	if (boot_params.hdr.version < 0x0209)
		return;
	pa_data = boot_params.hdr.setup_data;
	while (pa_data) {
		data = early_ioremap(pa_data, sizeof(*data));
		e820_update_range(pa_data, sizeof(*data)+data->len,
			 E820_RAM, E820_RESERVED_KERN);
410
		found = 1;
411 412 413
		pa_data = data->next;
		early_iounmap(data, sizeof(*data));
	}
414 415 416
	if (!found)
		return;

417
	sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
418
	memcpy(&e820_saved, &e820, sizeof(struct e820map));
419 420 421 422
	printk(KERN_INFO "extended physical RAM map:\n");
	e820_print_map("reserve setup_data");
}

423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440
static void __init reserve_early_setup_data(void)
{
	struct setup_data *data;
	u64 pa_data;
	char buf[32];

	if (boot_params.hdr.version < 0x0209)
		return;
	pa_data = boot_params.hdr.setup_data;
	while (pa_data) {
		data = early_ioremap(pa_data, sizeof(*data));
		sprintf(buf, "setup data %x", data->type);
		reserve_early(pa_data, pa_data+sizeof(*data)+data->len, buf);
		pa_data = data->next;
		early_iounmap(data, sizeof(*data));
	}
}

441 442 443 444 445
/*
 * --------- Crashkernel reservation ------------------------------
 */

#ifdef CONFIG_KEXEC
446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473

/**
 * Reserve @size bytes of crashkernel memory at any suitable offset.
 *
 * @size: Size of the crashkernel memory to reserve.
 * Returns the base address on success, and -1ULL on failure.
 */
unsigned long long find_and_reserve_crashkernel(unsigned long long size)
{
	const unsigned long long alignment = 16<<20; 	/* 16M */
	unsigned long long start = 0LL;

	while (1) {
		int ret;

		start = find_e820_area(start, ULONG_MAX, size, alignment);
		if (start == -1ULL)
			return start;

		/* try to reserve it */
		ret = reserve_bootmem_generic(start, size, BOOTMEM_EXCLUSIVE);
		if (ret >= 0)
			return start;

		start += alignment;
	}
}

474 475 476 477 478 479 480 481 482 483 484 485
static inline unsigned long long get_total_mem(void)
{
	unsigned long long total;

	total = max_low_pfn - min_low_pfn;
#ifdef CONFIG_HIGHMEM
	total += highend_pfn - highstart_pfn;
#endif

	return total << PAGE_SHIFT;
}

486
static void __init reserve_crashkernel(void)
487 488 489 490 491 492 493 494 495
{
	unsigned long long total_mem;
	unsigned long long crash_size, crash_base;
	int ret;

	total_mem = get_total_mem();

	ret = parse_crashkernel(boot_command_line, total_mem,
			&crash_size, &crash_base);
496 497 498 499 500 501 502 503 504
	if (ret != 0 || crash_size <= 0)
		return;

	/* 0 means: find the address automatically */
	if (crash_base <= 0) {
		crash_base = find_and_reserve_crashkernel(crash_size);
		if (crash_base == -1ULL) {
			pr_info("crashkernel reservation failed. "
				"No suitable area found.\n");
505 506
			return;
		}
507 508 509 510 511 512
	} else {
		ret = reserve_bootmem_generic(crash_base, crash_size,
					BOOTMEM_EXCLUSIVE);
		if (ret < 0) {
			pr_info("crashkernel reservation failed - "
				"memory is in use\n");
513 514
			return;
		}
515
	}
516

517 518 519 520 521
	printk(KERN_INFO "Reserving %ldMB of memory at %ldMB "
			"for crashkernel (System RAM: %ldMB)\n",
			(unsigned long)(crash_size >> 20),
			(unsigned long)(crash_base >> 20),
			(unsigned long)(total_mem >> 20));
522

523 524 525
	crashk_res.start = crash_base;
	crashk_res.end   = crash_base + crash_size - 1;
	insert_resource(&iomem_resource, &crashk_res);
526 527
}
#else
528
static void __init reserve_crashkernel(void)
529 530 531 532
{
}
#endif

533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555
static struct resource standard_io_resources[] = {
	{ .name = "dma1", .start = 0x00, .end = 0x1f,
		.flags = IORESOURCE_BUSY | IORESOURCE_IO },
	{ .name = "pic1", .start = 0x20, .end = 0x21,
		.flags = IORESOURCE_BUSY | IORESOURCE_IO },
	{ .name = "timer0", .start = 0x40, .end = 0x43,
		.flags = IORESOURCE_BUSY | IORESOURCE_IO },
	{ .name = "timer1", .start = 0x50, .end = 0x53,
		.flags = IORESOURCE_BUSY | IORESOURCE_IO },
	{ .name = "keyboard", .start = 0x60, .end = 0x60,
		.flags = IORESOURCE_BUSY | IORESOURCE_IO },
	{ .name = "keyboard", .start = 0x64, .end = 0x64,
		.flags = IORESOURCE_BUSY | IORESOURCE_IO },
	{ .name = "dma page reg", .start = 0x80, .end = 0x8f,
		.flags = IORESOURCE_BUSY | IORESOURCE_IO },
	{ .name = "pic2", .start = 0xa0, .end = 0xa1,
		.flags = IORESOURCE_BUSY | IORESOURCE_IO },
	{ .name = "dma2", .start = 0xc0, .end = 0xdf,
		.flags = IORESOURCE_BUSY | IORESOURCE_IO },
	{ .name = "fpu", .start = 0xf0, .end = 0xff,
		.flags = IORESOURCE_BUSY | IORESOURCE_IO }
};

556
static void __init reserve_standard_io_resources(void)
557 558 559 560 561 562 563 564 565
{
	int i;

	/* request I/O space for devices used on all i[345]86 PCs */
	for (i = 0; i < ARRAY_SIZE(standard_io_resources); i++)
		request_resource(&ioport_resource, &standard_io_resources[i]);

}

566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581
#ifdef CONFIG_PROC_VMCORE
/* elfcorehdr= specifies the location of elf core header
 * stored by the crashed kernel. This option will be passed
 * by kexec loader to the capture kernel.
 */
static int __init setup_elfcorehdr(char *arg)
{
	char *end;
	if (!arg)
		return -EINVAL;
	elfcorehdr_addr = memparse(arg, &end);
	return end > arg ? 0 : -EINVAL;
}
early_param("elfcorehdr", setup_elfcorehdr);
#endif

L
Linus Torvalds 已提交
582 583 584 585 586 587 588
/*
 * Determine if we were loaded by an EFI loader.  If so, then we have also been
 * passed the efi memmap, systab, etc., so we should use these data structures
 * for initialization.  Note, the efi init code path is determined by the
 * global efi_enabled. This allows the same kernel image to be used on existing
 * systems (with a traditional BIOS) as well as on EFI systems.
 */
589 590 591 592 593 594
/*
 * setup_arch - architecture-specific boot-time initializations
 *
 * Note: On x86_64, fixmaps are ready for use even before this is called.
 */

L
Linus Torvalds 已提交
595 596
void __init setup_arch(char **cmdline_p)
{
597
#ifdef CONFIG_X86_32
L
Linus Torvalds 已提交
598
	memcpy(&boot_cpu_data, &new_cpu_data, sizeof(new_cpu_data));
I
Ingo Molnar 已提交
599
	visws_early_detect();
L
Linus Torvalds 已提交
600 601
	pre_setup_arch_hook();
	early_cpu_init();
602 603 604
#else
	printk(KERN_INFO "Command line: %s\n", boot_command_line);
#endif
L
Linus Torvalds 已提交
605

606 607
	early_ioremap_init();

608 609 610
	ROOT_DEV = old_decode_dev(boot_params.hdr.root_dev);
	screen_info = boot_params.screen_info;
	edid_info = boot_params.edid_info;
611
#ifdef CONFIG_X86_32
612 613
	apm_info.bios = boot_params.apm_bios_info;
	ist_info = boot_params.ist_info;
614
	if (boot_params.sys_desc_table.length != 0) {
615 616 617 618
		set_mca_bus(boot_params.sys_desc_table.table[3] & 0x2);
		machine_id = boot_params.sys_desc_table.table[0];
		machine_submodel_id = boot_params.sys_desc_table.table[1];
		BIOS_revision = boot_params.sys_desc_table.table[2];
L
Linus Torvalds 已提交
619
	}
620 621
#endif
	saved_video_mode = boot_params.hdr.vid_mode;
622
	bootloader_type = boot_params.hdr.type_of_loader;
L
Linus Torvalds 已提交
623 624

#ifdef CONFIG_BLK_DEV_RAM
625 626 627
	rd_image_start = boot_params.hdr.ram_size & RAMDISK_IMAGE_START_MASK;
	rd_prompt = ((boot_params.hdr.ram_size & RAMDISK_PROMPT_FLAG) != 0);
	rd_doload = ((boot_params.hdr.ram_size & RAMDISK_LOAD_FLAG) != 0);
L
Linus Torvalds 已提交
628
#endif
629 630
#ifdef CONFIG_EFI
	if (!strncmp((char *)&boot_params.efi_info.efi_loader_signature,
631 632 633 634 635 636
#ifdef CONFIG_X86_32
		     "EL32",
#else
		     "EL64",
#endif
	 4)) {
637 638 639 640 641
		efi_enabled = 1;
		efi_reserve_early();
	}
#endif

L
Linus Torvalds 已提交
642
	ARCH_SETUP
643

644
	setup_memory_map();
645
	parse_setup_data();
646 647
	/* update the e820_saved too */
	e820_reserve_setup_data();
648

L
Linus Torvalds 已提交
649 650
	copy_edd();

651
	if (!boot_params.hdr.root_flags)
L
Linus Torvalds 已提交
652 653 654 655
		root_mountflags &= ~MS_RDONLY;
	init_mm.start_code = (unsigned long) _text;
	init_mm.end_code = (unsigned long) _etext;
	init_mm.end_data = (unsigned long) _edata;
656
#ifdef CONFIG_X86_32
L
Linus Torvalds 已提交
657
	init_mm.brk = init_pg_tables_end + PAGE_OFFSET;
658 659 660
#else
	init_mm.brk = (unsigned long) &_end;
#endif
L
Linus Torvalds 已提交
661 662 663 664 665

	code_resource.start = virt_to_phys(_text);
	code_resource.end = virt_to_phys(_etext)-1;
	data_resource.start = virt_to_phys(_etext);
	data_resource.end = virt_to_phys(_edata)-1;
B
Bernhard Walle 已提交
666 667
	bss_resource.start = virt_to_phys(&__bss_start);
	bss_resource.end = virt_to_phys(&__bss_stop)-1;
L
Linus Torvalds 已提交
668

669 670 671
#ifdef CONFIG_X86_64
	early_cpu_init();
#endif
672 673 674
	strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE);
	*cmdline_p = command_line;

675
	parse_early_param();
L
Linus Torvalds 已提交
676

677
	/* after early param, so could get panic from serial */
678
	reserve_early_setup_data();
679

680
	if (acpi_mps_check()) {
I
Ingo Molnar 已提交
681
#ifdef CONFIG_X86_LOCAL_APIC
682
		disable_apic = 1;
I
Ingo Molnar 已提交
683
#endif
684 685 686
		clear_cpu_cap(&boot_cpu_data, X86_FEATURE_APIC);
	}

687
	finish_e820_parsing();
688

689
#ifdef CONFIG_X86_32
690
	probe_roms();
691
#endif
692 693 694 695 696 697

	/* after parse_early_param, so could debug it */
	insert_resource(&iomem_resource, &code_resource);
	insert_resource(&iomem_resource, &data_resource);
	insert_resource(&iomem_resource, &bss_resource);

698 699 700
	if (efi_enabled)
		efi_init();

701
#ifdef CONFIG_X86_32
Y
Yinghai Lu 已提交
702 703 704 705 706 707 708
	if (ppro_with_ram_bug()) {
		e820_update_range(0x70000000ULL, 0x40000ULL, E820_RAM,
				  E820_RESERVED);
		sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
		printk(KERN_INFO "fixed physical RAM map:\n");
		e820_print_map("bad_ppro");
	}
709 710 711
#else
	early_gart_iommu_check();
#endif
Y
Yinghai Lu 已提交
712

713 714 715 716
	/*
	 * partially used pages are not usable - thus
	 * we are rounding upwards:
	 */
717
	max_pfn = e820_end_of_ram_pfn();
718

Y
Yinghai Lu 已提交
719 720
	/* preallocate 4k for mptable mpc */
	early_reserve_e820_mpc_new();
721 722
	/* update e820 for memory not covered by WB MTRRs */
	mtrr_bp_init();
723
	if (mtrr_trim_uncached_memory(max_pfn))
724
		max_pfn = e820_end_of_ram_pfn();
725

726
#ifdef CONFIG_X86_32
727
	/* max_low_pfn get updated here */
728
	find_low_pfn_range();
729 730 731 732 733 734 735
#else
	num_physpages = max_pfn;

	check_efer();

	/* How many end-of-memory variables you have, grandma! */
	/* need this before calling reserve_initrd */
736 737 738 739 740
	if (max_pfn > (1UL<<(32 - PAGE_SHIFT)))
		max_low_pfn = e820_end_of_low_ram_pfn();
	else
		max_low_pfn = max_pfn;

741 742
	high_memory = (void *)__va(max_pfn * PAGE_SIZE - 1) + 1;
#endif
743

744
	/* max_pfn_mapped is updated here */
745 746 747 748 749 750 751 752 753 754 755
	max_low_pfn_mapped = init_memory_mapping(0, max_low_pfn<<PAGE_SHIFT);
	max_pfn_mapped = max_low_pfn_mapped;

#ifdef CONFIG_X86_64
	if (max_pfn > max_low_pfn) {
		max_pfn_mapped = init_memory_mapping(1UL<<32,
						     max_pfn<<PAGE_SHIFT);
		/* can we preseve max_low_pfn ?*/
		max_low_pfn = max_pfn;
	}
#endif
756

757 758 759 760 761 762 763 764 765
	/*
	 * NOTE: On x86-32, only from this point on, fixmaps are ready for use.
	 */

#ifdef CONFIG_PROVIDE_OHCI1394_DMA_INIT
	if (init_ohci1394_dma_early)
		init_ohci1394_dma_on_all_controllers();
#endif

766 767
	reserve_initrd();

768 769 770 771
#ifdef CONFIG_X86_64
	vsmp_init();
#endif

772 773 774 775 776 777 778 779 780 781
	dmi_scan_machine();

	io_delay_init();

	/*
	 * Parse the ACPI tables for possible boot-time SMP configuration.
	 */
	acpi_boot_table_init();

#ifdef CONFIG_ACPI_NUMA
Y
Yinghai Lu 已提交
782 783 784 785
	/*
	 * Parse SRAT to discover nodes.
	 */
	acpi_numa_init();
786 787
#endif

788
	initmem_init(0, max_pfn);
789

790 791 792 793
#ifdef CONFIG_X86_64
	dma32_reserve_bootmem();
#endif

794 795 796 797 798 799
#ifdef CONFIG_ACPI_SLEEP
	/*
	 * Reserve low memory region for sleep support.
	 */
	acpi_reserve_bootmem();
#endif
800
#ifdef CONFIG_X86_FIND_SMP_CONFIG
801 802 803 804 805 806 807 808 809
	/*
	 * Find and reserve possible boot-time SMP configuration:
	 */
	find_smp_config();
#endif
	reserve_crashkernel();

	reserve_ibft_region();

810 811 812 813
#ifdef CONFIG_KVM_CLOCK
	kvmclock_init();
#endif

814
#if defined(CONFIG_VMI) && defined(CONFIG_X86_32)
815 816 817 818 819 820
	/*
	 * Must be after max_low_pfn is determined, and before kernel
	 * pagetables are setup.
	 */
	vmi_init();
#endif
L
Linus Torvalds 已提交
821

822
	paravirt_pagetable_setup_start(swapper_pg_dir);
L
Linus Torvalds 已提交
823
	paging_init();
824
	paravirt_pagetable_setup_done(swapper_pg_dir);
825

826 827 828 829
#ifdef CONFIG_X86_64
	map_vsyscall();
#endif

L
Linus Torvalds 已提交
830
#ifdef CONFIG_X86_GENERICARCH
831
	generic_apic_probe();
832
#endif
L
Linus Torvalds 已提交
833

834
	early_quirks();
835

836 837 838
	/*
	 * Read APIC and some other early information from ACPI tables.
	 */
L
Linus Torvalds 已提交
839
	acpi_boot_init();
840

841
#if defined(CONFIG_X86_MPPARSE) || defined(CONFIG_X86_VISWS)
842 843 844
	/*
	 * get boot-time SMP configuration:
	 */
845 846 847
	if (smp_found_config)
		get_smp_config();
#endif
848

849
	prefill_possible_map();
850 851 852 853
#ifdef CONFIG_X86_64
	init_cpu_to_node();
#endif

Y
Yinghai Lu 已提交
854 855 856 857 858 859 860 861
#ifdef CONFIG_X86_NUMAQ
	/*
	 * need to check online nodes num, call it
	 * here before time_init/tsc_init
	 */
	numaq_tsc_disable();
#endif

862 863
	init_apic_mappings();
	ioapic_init_mappings();
864 865

#if defined(CONFIG_SMP) && defined(CONFIG_X86_PC) && defined(CONFIG_X86_32)
866 867 868 869 870
	if (def_to_bigsmp)
		printk(KERN_WARNING "More than 8 CPUs detected and "
			"CONFIG_X86_PC cannot handle it.\nUse "
			"CONFIG_X86_GENERICARCH or CONFIG_X86_BIGSMP.\n");
#endif
871
	kvm_guest_init();
L
Linus Torvalds 已提交
872

873
	e820_reserve_resources();
874
	e820_mark_nosave_regions(max_low_pfn);
L
Linus Torvalds 已提交
875

876
#ifdef CONFIG_X86_32
877
	request_resource(&iomem_resource, &video_ram_resource);
878
#endif
879
	reserve_standard_io_resources();
880 881 882

	e820_setup_gap();

L
Linus Torvalds 已提交
883 884 885 886 887 888 889 890 891
#ifdef CONFIG_VT
#if defined(CONFIG_VGA_CONSOLE)
	if (!efi_enabled || (efi_mem_type(0xa0000) != EFI_CONVENTIONAL_MEMORY))
		conswitchp = &vga_con;
#elif defined(CONFIG_DUMMY_CONSOLE)
	conswitchp = &dummy_con;
#endif
#endif
}