setup.c 26.4 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
#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/kallsyms.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 已提交
70
#include <video/edid.h>
71

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

90 91 92 93 94
#include <asm/system.h>
#include <asm/vsyscall.h>
#include <asm/smp.h>
#include <asm/desc.h>
#include <asm/dma.h>
95
#include <asm/iommu.h>
96 97 98 99 100 101 102 103 104
#include <asm/mmu_context.h>
#include <asm/proto.h>

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

#include <asm/percpu.h>
#include <asm/topology.h>
#include <asm/apicdef.h>
Y
Yinghai Lu 已提交
105 106 107
#ifdef CONFIG_X86_64
#include <asm/numa_64.h>
#endif
108

Y
Yinghai Lu 已提交
109 110 111 112
#ifndef ARCH_SETUP
#define ARCH_SETUP
#endif

113 114 115 116 117 118
#ifndef CONFIG_DEBUG_BOOT_PARAMS
struct boot_params __initdata boot_params;
#else
struct boot_params boot_params;
#endif

L
Linus Torvalds 已提交
119 120 121
/*
 * Machine setup..
 */
122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142
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
};

143 144

#ifdef CONFIG_X86_32
145 146 147 148 149 150
/* 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;

151 152 153 154 155 156 157
static struct resource video_ram_resource = {
	.name	= "Video RAM area",
	.start	= 0xa0000,
	.end	= 0xbffff,
	.flags	= IORESOURCE_BUSY | IORESOURCE_MEM
};

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

170 171
unsigned int def_to_bigsmp;

L
Linus Torvalds 已提交
172 173 174 175 176
/* for MCA, but anyone else can use it if they want */
unsigned int machine_id;
unsigned int machine_submodel_id;
unsigned int BIOS_revision;

177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199
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 已提交
200 201 202
/* Boot loader ID as an integer, for the benefit of proc_dointvec */
int bootloader_type;

203 204 205 206 207 208
/*
 * Early DMI memory
 */
int dmi_alloc_index;
char dmi_alloc_data[DMI_MAX_DATA];

L
Linus Torvalds 已提交
209 210 211 212
/*
 * Setup options
 */
struct screen_info screen_info;
213
EXPORT_SYMBOL(screen_info);
L
Linus Torvalds 已提交
214
struct edid_info edid_info;
215
EXPORT_SYMBOL_GPL(edid_info);
L
Linus Torvalds 已提交
216 217 218

extern int root_mountflags;

219
unsigned long saved_video_mode;
L
Linus Torvalds 已提交
220

221
#define RAMDISK_IMAGE_START_MASK	0x07FF
L
Linus Torvalds 已提交
222
#define RAMDISK_PROMPT_FLAG		0x8000
223
#define RAMDISK_LOAD_FLAG		0x4000
L
Linus Torvalds 已提交
224

225
static char __initdata command_line[COMMAND_LINE_SIZE];
226 227 228
#ifdef CONFIG_CMDLINE_BOOL
static char __initdata builtin_cmdline[COMMAND_LINE_SIZE] = CONFIG_CMDLINE;
#endif
L
Linus Torvalds 已提交
229 230 231 232 233 234 235 236 237 238 239 240 241

#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)
{
242 243 244 245 246
     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 已提交
247 248 249 250 251 252 253
}
#else
static inline void copy_edd(void)
{
}
#endif

254 255
#ifdef CONFIG_BLK_DEV_INITRD

256
#ifdef CONFIG_X86_32
257

258 259
#define MAX_MAP_CHUNK	(NR_FIX_BTMAPS << PAGE_SHIFT)
static void __init relocate_initrd(void)
260
{
261

262 263 264 265
	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;
266 267
	unsigned long slop, clen, mapaddr;
	char *p, *q;
268 269

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

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

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

	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;
305
		p = early_memremap(mapaddr, clen+slop);
306
		memcpy(q, p+slop, clen);
307
		early_iounmap(p, clen+slop);
308 309 310 311
		q += clen;
		ramdisk_image += clen;
		ramdisk_size  -= clen;
	}
312
	/* high pages is not converted by early_res_to_bootmem */
313 314
	ramdisk_image = boot_params.hdr.ramdisk_image;
	ramdisk_size  = boot_params.hdr.ramdisk_size;
315 316
	printk(KERN_INFO "Move RAMDISK from %016llx - %016llx to"
		" %08llx - %08llx\n",
317 318
		ramdisk_image, ramdisk_image + ramdisk_size - 1,
		ramdisk_here, ramdisk_here + ramdisk_size - 1);
319 320
}
#endif
Y
Yinghai Lu 已提交
321

322 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
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);
366
}
Y
Yinghai Lu 已提交
367
#else
368
static void __init reserve_initrd(void)
Y
Yinghai Lu 已提交
369 370
{
}
371 372
#endif /* CONFIG_BLK_DEV_INITRD */

373
static void __init parse_setup_data(void)
374 375 376 377 378 379 380 381
{
	struct setup_data *data;
	u64 pa_data;

	if (boot_params.hdr.version < 0x0209)
		return;
	pa_data = boot_params.hdr.setup_data;
	while (pa_data) {
382
		data = early_memremap(pa_data, PAGE_SIZE);
383 384 385 386 387 388 389 390 391 392 393 394
		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);
	}
}

395
static void __init e820_reserve_setup_data(void)
396 397 398
{
	struct setup_data *data;
	u64 pa_data;
399
	int found = 0;
400 401 402 403 404

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

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

421 422 423 424 425 426 427 428 429 430
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) {
431
		data = early_memremap(pa_data, sizeof(*data));
432 433 434 435 436 437 438
		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));
	}
}

439 440 441 442 443
/*
 * --------- Crashkernel reservation ------------------------------
 */

#ifdef CONFIG_KEXEC
444 445 446 447 448 449 450

/**
 * 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.
 */
451
unsigned long long __init find_and_reserve_crashkernel(unsigned long long size)
452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471
{
	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;
	}
}

472 473 474 475 476 477 478 479 480 481 482 483
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;
}

484
static void __init reserve_crashkernel(void)
485 486 487 488 489 490 491 492 493
{
	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);
494 495 496 497 498 499 500 501 502
	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");
503 504
			return;
		}
505 506 507 508 509 510
	} else {
		ret = reserve_bootmem_generic(crash_base, crash_size,
					BOOTMEM_EXCLUSIVE);
		if (ret < 0) {
			pr_info("crashkernel reservation failed - "
				"memory is in use\n");
511 512
			return;
		}
513
	}
514

515 516 517 518 519
	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));
520

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

531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553
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 }
};

554
static void __init reserve_standard_io_resources(void)
555 556 557 558 559 560 561 562 563
{
	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]);

}

564 565 566 567 568 569 570
/*
 * Note: elfcorehdr_addr is not just limited to vmcore. It is also used by
 * is_kdump_kernel() to determine if we are booting after a panic. Hence
 * ifdef it under CONFIG_CRASH_DUMP and not CONFIG_PROC_VMCORE.
 */

#ifdef CONFIG_CRASH_DUMP
571 572 573 574 575 576 577 578 579 580 581 582 583 584 585
/* 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

Y
Yinghai Lu 已提交
586 587 588 589
static struct x86_quirks default_x86_quirks __initdata;

struct x86_quirks *x86_quirks __initdata = &default_x86_quirks;

590 591 592 593 594 595 596 597
/*
 * Some BIOSes seem to corrupt the low 64k of memory during events
 * like suspend/resume and unplugging an HDMI cable.  Reserve all
 * remaining free memory in that area and fill it with a distinct
 * pattern.
 */
#ifdef CONFIG_X86_CHECK_BIOS_CORRUPTION
#define MAX_SCAN_AREAS	8
598

599 600
static int __read_mostly memory_corruption_check = -1;

601 602 603
static unsigned __read_mostly corruption_check_size = 64*1024;
static unsigned __read_mostly corruption_check_period = 60; /* seconds */

604 605 606
static struct e820entry scan_areas[MAX_SCAN_AREAS];
static int num_scan_areas;

607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642

static int set_corruption_check(char *arg)
{
	char *end;

	memory_corruption_check = simple_strtol(arg, &end, 10);

	return (*end == 0) ? 0 : -EINVAL;
}
early_param("memory_corruption_check", set_corruption_check);

static int set_corruption_check_period(char *arg)
{
	char *end;

	corruption_check_period = simple_strtoul(arg, &end, 10);

	return (*end == 0) ? 0 : -EINVAL;
}
early_param("memory_corruption_check_period", set_corruption_check_period);

static int set_corruption_check_size(char *arg)
{
	char *end;
	unsigned size;

	size = memparse(arg, &end);

	if (*end == '\0')
		corruption_check_size = size;

	return (size == corruption_check_size) ? 0 : -EINVAL;
}
early_param("memory_corruption_check_size", set_corruption_check_size);


643 644 645 646
static void __init setup_bios_corruption_check(void)
{
	u64 addr = PAGE_SIZE;	/* assume first page is reserved anyway */

647 648 649 650 651 652 653 654 655 656
	if (memory_corruption_check == -1) {
		memory_corruption_check =
#ifdef CONFIG_X86_BOOTPARAM_MEMORY_CORRUPTION_CHECK
			1
#else
			0
#endif
			;
	}

657 658 659 660 661 662 663 664 665
	if (corruption_check_size == 0)
		memory_corruption_check = 0;

	if (!memory_corruption_check)
		return;

	corruption_check_size = round_up(corruption_check_size, PAGE_SIZE);

	while(addr < corruption_check_size && num_scan_areas < MAX_SCAN_AREAS) {
666 667 668 669 670 671
		u64 size;
		addr = find_e820_area_size(addr, &size, PAGE_SIZE);

		if (addr == 0)
			break;

672 673
		if ((addr + size) > corruption_check_size)
			size = corruption_check_size - addr;
674 675 676 677 678 679 680 681 682 683 684 685 686 687 688

		if (size == 0)
			break;

		e820_update_range(addr, size, E820_RAM, E820_RESERVED);
		scan_areas[num_scan_areas].addr = addr;
		scan_areas[num_scan_areas].size = size;
		num_scan_areas++;

		/* Assume we've already mapped this early memory */
		memset(__va(addr), 0, size);

		addr += size;
	}

689
	printk(KERN_INFO "Scanning %d areas for low memory corruption\n",
690 691 692 693
	       num_scan_areas);
	update_e820();
}

694
static struct timer_list periodic_check_timer;
695 696 697 698 699 700

void check_for_bios_corruption(void)
{
	int i;
	int corruption = 0;

701
	if (!memory_corruption_check)
702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717
		return;

	for(i = 0; i < num_scan_areas; i++) {
		unsigned long *addr = __va(scan_areas[i].addr);
		unsigned long size = scan_areas[i].size;

		for(; size; addr++, size -= sizeof(unsigned long)) {
			if (!*addr)
				continue;
			printk(KERN_ERR "Corrupted low memory at %p (%lx phys) = %08lx\n",
			       addr, __pa(addr), *addr);
			corruption = 1;
			*addr = 0;
		}
	}

718
	WARN(corruption, KERN_ERR "Memory corruption detected in low memory\n");
719 720
}

721 722 723
static void periodic_check_for_corruption(unsigned long data)
{
	check_for_bios_corruption();
724
	mod_timer(&periodic_check_timer, round_jiffies(jiffies + corruption_check_period*HZ));
725 726 727 728
}

void start_periodic_check_for_corruption(void)
{
729
	if (!memory_corruption_check || corruption_check_period == 0)
730 731
		return;

732 733 734
	printk(KERN_INFO "Scanning for low memory corruption every %d seconds\n",
	       corruption_check_period);

735 736 737 738
	init_timer(&periodic_check_timer);
	periodic_check_timer.function = &periodic_check_for_corruption;
	periodic_check_for_corruption(0);
}
739 740
#endif

741 742 743
static int __init dmi_low_memory_corruption(const struct dmi_system_id *d)
{
	printk(KERN_NOTICE
744
		"%s detected: BIOS may corrupt low RAM, working it around.\n",
745 746
		d->ident);

747 748
	e820_update_range(0, 0x10000, E820_RAM, E820_RESERVED);
	sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
749 750 751 752 753 754

	return 0;
}

/* List of systems that have known low memory corruption BIOS problems */
static struct dmi_system_id __initdata bad_bios_dmi_table[] = {
I
Ingo Molnar 已提交
755
#ifdef CONFIG_X86_RESERVE_LOW_64K
756 757 758 759 760 761 762
	{
		.callback = dmi_low_memory_corruption,
		.ident = "AMI BIOS",
		.matches = {
			DMI_MATCH(DMI_BIOS_VENDOR, "American Megatrends Inc."),
		},
	},
763 764 765 766 767 768 769
	{
		.callback = dmi_low_memory_corruption,
		.ident = "Phoenix BIOS",
		.matches = {
			DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies, LTD"),
		},
	},
I
Ingo Molnar 已提交
770
#endif
771
	{}
772 773
};

L
Linus Torvalds 已提交
774 775 776 777 778 779 780
/*
 * 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.
 */
781 782 783 784 785 786
/*
 * setup_arch - architecture-specific boot-time initializations
 *
 * Note: On x86_64, fixmaps are ready for use even before this is called.
 */

L
Linus Torvalds 已提交
787 788
void __init setup_arch(char **cmdline_p)
{
789
#ifdef CONFIG_X86_32
L
Linus Torvalds 已提交
790
	memcpy(&boot_cpu_data, &new_cpu_data, sizeof(new_cpu_data));
I
Ingo Molnar 已提交
791
	visws_early_detect();
L
Linus Torvalds 已提交
792
	pre_setup_arch_hook();
793 794 795
#else
	printk(KERN_INFO "Command line: %s\n", boot_command_line);
#endif
L
Linus Torvalds 已提交
796

797
	early_cpu_init();
798 799
	early_ioremap_init();

800 801 802
	ROOT_DEV = old_decode_dev(boot_params.hdr.root_dev);
	screen_info = boot_params.screen_info;
	edid_info = boot_params.edid_info;
803
#ifdef CONFIG_X86_32
804 805
	apm_info.bios = boot_params.apm_bios_info;
	ist_info = boot_params.ist_info;
806
	if (boot_params.sys_desc_table.length != 0) {
807 808 809 810
		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 已提交
811
	}
812 813
#endif
	saved_video_mode = boot_params.hdr.vid_mode;
814
	bootloader_type = boot_params.hdr.type_of_loader;
L
Linus Torvalds 已提交
815 816

#ifdef CONFIG_BLK_DEV_RAM
817 818 819
	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 已提交
820
#endif
821 822
#ifdef CONFIG_EFI
	if (!strncmp((char *)&boot_params.efi_info.efi_loader_signature,
823 824 825 826 827 828
#ifdef CONFIG_X86_32
		     "EL32",
#else
		     "EL64",
#endif
	 4)) {
829 830 831 832 833
		efi_enabled = 1;
		efi_reserve_early();
	}
#endif

L
Linus Torvalds 已提交
834
	ARCH_SETUP
835

836
	setup_memory_map();
837
	parse_setup_data();
838 839
	/* update the e820_saved too */
	e820_reserve_setup_data();
840

L
Linus Torvalds 已提交
841 842
	copy_edd();

843
	if (!boot_params.hdr.root_flags)
L
Linus Torvalds 已提交
844 845 846 847
		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;
848
#ifdef CONFIG_X86_32
L
Linus Torvalds 已提交
849
	init_mm.brk = init_pg_tables_end + PAGE_OFFSET;
850 851 852
#else
	init_mm.brk = (unsigned long) &_end;
#endif
L
Linus Torvalds 已提交
853 854 855 856 857

	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 已提交
858 859
	bss_resource.start = virt_to_phys(&__bss_start);
	bss_resource.end = virt_to_phys(&__bss_stop)-1;
L
Linus Torvalds 已提交
860

861 862 863 864 865 866 867 868 869 870 871 872 873
#ifdef CONFIG_CMDLINE_BOOL
#ifdef CONFIG_CMDLINE_OVERRIDE
	strlcpy(boot_command_line, builtin_cmdline, COMMAND_LINE_SIZE);
#else
	if (builtin_cmdline[0]) {
		/* append boot loader cmdline to builtin */
		strlcat(builtin_cmdline, " ", COMMAND_LINE_SIZE);
		strlcat(builtin_cmdline, boot_command_line, COMMAND_LINE_SIZE);
		strlcpy(boot_command_line, builtin_cmdline, COMMAND_LINE_SIZE);
	}
#endif
#endif

874 875 876
	strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE);
	*cmdline_p = command_line;

877
	parse_early_param();
L
Linus Torvalds 已提交
878

879 880 881 882
#ifdef CONFIG_X86_64
	check_efer();
#endif

A
Alok Kataria 已提交
883 884 885 886 887 888 889 890
#if defined(CONFIG_VMI) && defined(CONFIG_X86_32)
	/*
	 * Must be before kernel pagetables are setup
	 * or fixmap area is touched.
	 */
	vmi_init();
#endif

891
	/* after early param, so could get panic from serial */
892
	reserve_early_setup_data();
893

894
	if (acpi_mps_check()) {
I
Ingo Molnar 已提交
895
#ifdef CONFIG_X86_LOCAL_APIC
896
		disable_apic = 1;
I
Ingo Molnar 已提交
897
#endif
898
		setup_clear_cpu_cap(X86_FEATURE_APIC);
899 900
	}

901 902 903 904 905
#ifdef CONFIG_PCI
	if (pci_early_dump_regs)
		early_dump_pci_devices();
#endif

906
	finish_e820_parsing();
907

908 909 910 911
	dmi_scan_machine();

	dmi_check_system(bad_bios_dmi_table);

912
#ifdef CONFIG_X86_32
913
	probe_roms();
914
#endif
915 916 917 918 919 920

	/* 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);

921 922 923
	if (efi_enabled)
		efi_init();

924
#ifdef CONFIG_X86_32
Y
Yinghai Lu 已提交
925 926 927 928 929 930 931
	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");
	}
932 933 934
#else
	early_gart_iommu_check();
#endif
Y
Yinghai Lu 已提交
935

936 937 938 939
	/*
	 * partially used pages are not usable - thus
	 * we are rounding upwards:
	 */
940
	max_pfn = e820_end_of_ram_pfn();
941

Y
Yinghai Lu 已提交
942 943
	/* preallocate 4k for mptable mpc */
	early_reserve_e820_mpc_new();
944 945
	/* update e820 for memory not covered by WB MTRRs */
	mtrr_bp_init();
946
	if (mtrr_trim_uncached_memory(max_pfn))
947
		max_pfn = e820_end_of_ram_pfn();
948

949
#ifdef CONFIG_X86_32
950
	/* max_low_pfn get updated here */
951
	find_low_pfn_range();
952 953 954
#else
	num_physpages = max_pfn;

955 956
 	if (cpu_has_x2apic)
 		check_x2apic();
957 958 959

	/* How many end-of-memory variables you have, grandma! */
	/* need this before calling reserve_initrd */
960 961 962 963 964
	if (max_pfn > (1UL<<(32 - PAGE_SHIFT)))
		max_low_pfn = e820_end_of_low_ram_pfn();
	else
		max_low_pfn = max_pfn;

965 966
	high_memory = (void *)__va(max_pfn * PAGE_SIZE - 1) + 1;
#endif
967

968 969 970 971
#ifdef CONFIG_X86_CHECK_BIOS_CORRUPTION
	setup_bios_corruption_check();
#endif

972
	/* max_pfn_mapped is updated here */
973 974 975 976 977 978 979 980 981 982 983
	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
984

985 986 987 988 989 990 991 992 993
	/*
	 * 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

994 995
	reserve_initrd();

996 997 998 999
#ifdef CONFIG_X86_64
	vsmp_init();
#endif

1000 1001 1002 1003 1004 1005 1006
	io_delay_init();

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

1007 1008
	early_acpi_boot_init();

1009
#ifdef CONFIG_ACPI_NUMA
Y
Yinghai Lu 已提交
1010 1011 1012 1013
	/*
	 * Parse SRAT to discover nodes.
	 */
	acpi_numa_init();
1014 1015
#endif

1016
	initmem_init(0, max_pfn);
1017

1018 1019 1020 1021 1022 1023
#ifdef CONFIG_ACPI_SLEEP
	/*
	 * Reserve low memory region for sleep support.
	 */
	acpi_reserve_bootmem();
#endif
1024
#ifdef CONFIG_X86_FIND_SMP_CONFIG
1025 1026 1027 1028 1029 1030 1031
	/*
	 * Find and reserve possible boot-time SMP configuration:
	 */
	find_smp_config();
#endif
	reserve_crashkernel();

1032 1033 1034 1035 1036 1037 1038 1039 1040
#ifdef CONFIG_X86_64
	/*
	 * dma32_reserve_bootmem() allocates bootmem which may conflict
	 * with the crashkernel command line, so do that after
	 * reserve_crashkernel()
	 */
	dma32_reserve_bootmem();
#endif

1041 1042
	reserve_ibft_region();

1043 1044 1045 1046
#ifdef CONFIG_KVM_CLOCK
	kvmclock_init();
#endif

1047
	paravirt_pagetable_setup_start(swapper_pg_dir);
L
Linus Torvalds 已提交
1048
	paging_init();
1049
	paravirt_pagetable_setup_done(swapper_pg_dir);
1050
	paravirt_post_allocator_init();
1051

1052 1053 1054 1055
#ifdef CONFIG_X86_64
	map_vsyscall();
#endif

L
Linus Torvalds 已提交
1056
#ifdef CONFIG_X86_GENERICARCH
1057
	generic_apic_probe();
1058
#endif
L
Linus Torvalds 已提交
1059

1060
	early_quirks();
1061

1062 1063 1064
	/*
	 * Read APIC and some other early information from ACPI tables.
	 */
L
Linus Torvalds 已提交
1065
	acpi_boot_init();
1066

1067
#if defined(CONFIG_X86_MPPARSE) || defined(CONFIG_X86_VISWS)
1068 1069 1070
	/*
	 * get boot-time SMP configuration:
	 */
1071 1072 1073
	if (smp_found_config)
		get_smp_config();
#endif
1074

1075
	prefill_possible_map();
Y
Yinghai Lu 已提交
1076

1077 1078 1079 1080
#ifdef CONFIG_X86_64
	init_cpu_to_node();
#endif

1081 1082
	init_apic_mappings();
	ioapic_init_mappings();
1083

1084 1085 1086
	/* need to wait for io_apic is mapped */
	nr_irqs = probe_nr_irqs();

1087
	kvm_guest_init();
L
Linus Torvalds 已提交
1088

1089
	e820_reserve_resources();
1090
	e820_mark_nosave_regions(max_low_pfn);
L
Linus Torvalds 已提交
1091

1092
#ifdef CONFIG_X86_32
1093
	request_resource(&iomem_resource, &video_ram_resource);
1094
#endif
1095
	reserve_standard_io_resources();
1096 1097 1098

	e820_setup_gap();

L
Linus Torvalds 已提交
1099 1100 1101 1102 1103 1104 1105 1106 1107
#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
}
1108 1109