setup.c 25.5 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
#include <linux/ioport.h>
#include <linux/acpi.h>
F
Feng Tang 已提交
30
#include <linux/sfi.h>
L
Linus Torvalds 已提交
31 32 33 34 35 36 37 38 39 40 41 42
#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>
43
#include <linux/iscsi_ibft.h>
L
Linus Torvalds 已提交
44
#include <linux/nodemask.h>
45
#include <linux/kexec.h>
46
#include <linux/dmi.h>
D
Dave Hansen 已提交
47
#include <linux/pfn.h>
48
#include <linux/pci.h>
49
#include <asm/pci-direct.h>
50
#include <linux/init_ohci1394_dma.h>
51
#include <linux/kvm_para.h>
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>
70
#include <linux/tboot.h>
71

L
Linus Torvalds 已提交
72
#include <video/edid.h>
73

74
#include <asm/mtrr.h>
75
#include <asm/apic.h>
76
#include <asm/trampoline.h>
L
Linus Torvalds 已提交
77 78 79
#include <asm/e820.h>
#include <asm/mpspec.h>
#include <asm/setup.h>
Y
Yinghai Lu 已提交
80
#include <asm/efi.h>
I
Ingo Molnar 已提交
81 82
#include <asm/timer.h>
#include <asm/i8259.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 <asm/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
#include <asm/system.h>
#include <asm/vsyscall.h>
96
#include <asm/cpu.h>
97 98
#include <asm/desc.h>
#include <asm/dma.h>
99
#include <asm/iommu.h>
100
#include <asm/gart.h>
101 102 103 104
#include <asm/mmu_context.h>
#include <asm/proto.h>

#include <asm/paravirt.h>
105
#include <asm/hypervisor.h>
106 107 108 109

#include <asm/percpu.h>
#include <asm/topology.h>
#include <asm/apicdef.h>
D
David Rientjes 已提交
110
#include <asm/k8.h>
Y
Yinghai Lu 已提交
111 112 113
#ifdef CONFIG_X86_64
#include <asm/numa_64.h>
#endif
114
#include <asm/mce.h>
115

116 117 118 119 120 121 122 123
/*
 * end_pfn only includes RAM, while max_pfn_mapped includes all e820 entries.
 * The direct mapping extends to max_pfn_mapped, so that we can directly access
 * apertures, ACPI and other tables without having to play with fixmaps.
 */
unsigned long max_low_pfn_mapped;
unsigned long max_pfn_mapped;

124 125
RESERVE_BRK(dmi_alloc, 65536);

I
Ingo Molnar 已提交
126 127
unsigned int boot_cpu_id __read_mostly;

128 129 130
static __initdata unsigned long _brk_start = (unsigned long)__brk_base;
unsigned long _brk_end = (unsigned long)__brk_base;

I
Ingo Molnar 已提交
131 132 133 134 135 136
#ifdef CONFIG_X86_64
int default_cpu_present_to_apicid(int mps_cpu)
{
	return __default_cpu_present_to_apicid(mps_cpu);
}

T
Thomas Gleixner 已提交
137
int default_check_phys_apicid_present(int phys_apicid)
I
Ingo Molnar 已提交
138
{
T
Thomas Gleixner 已提交
139
	return __default_check_phys_apicid_present(phys_apicid);
I
Ingo Molnar 已提交
140 141 142
}
#endif

143 144 145 146 147 148
#ifndef CONFIG_DEBUG_BOOT_PARAMS
struct boot_params __initdata boot_params;
#else
struct boot_params boot_params;
#endif

L
Linus Torvalds 已提交
149 150 151
/*
 * Machine setup..
 */
152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172
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
};

173 174

#ifdef CONFIG_X86_32
L
Linus Torvalds 已提交
175
/* cpu data as detected by the assembly code in head.S */
176
struct cpuinfo_x86 new_cpu_data __cpuinitdata = {0, 0, 0, 0, -1, 1, 0, 0, -1};
L
Linus Torvalds 已提交
177
/* common cpu data for all cpus */
178
struct cpuinfo_x86 boot_cpu_data __read_mostly = {0, 0, 0, 0, -1, 1, 0, 0, -1};
179
EXPORT_SYMBOL(boot_cpu_data);
180 181 182 183 184 185
static void set_mca_bus(int x)
{
#ifdef CONFIG_MCA
	MCA_bus = x;
#endif
}
L
Linus Torvalds 已提交
186

187 188
unsigned int def_to_bigsmp;

L
Linus Torvalds 已提交
189 190 191 192 193
/* for MCA, but anyone else can use it if they want */
unsigned int machine_id;
unsigned int machine_submodel_id;
unsigned int BIOS_revision;

194 195 196 197 198 199 200 201 202 203 204 205
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
206 207 208
struct cpuinfo_x86 boot_cpu_data __read_mostly = {
	.x86_phys_bits = MAX_PHYSMEM_BITS,
};
209 210 211 212 213 214 215 216 217 218
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

219 220
/* Boot loader ID and version as integers, for the benefit of proc_dointvec */
int bootloader_type, bootloader_version;
L
Linus Torvalds 已提交
221 222 223 224 225

/*
 * Setup options
 */
struct screen_info screen_info;
226
EXPORT_SYMBOL(screen_info);
L
Linus Torvalds 已提交
227
struct edid_info edid_info;
228
EXPORT_SYMBOL_GPL(edid_info);
L
Linus Torvalds 已提交
229 230 231

extern int root_mountflags;

232
unsigned long saved_video_mode;
L
Linus Torvalds 已提交
233

234
#define RAMDISK_IMAGE_START_MASK	0x07FF
L
Linus Torvalds 已提交
235
#define RAMDISK_PROMPT_FLAG		0x8000
236
#define RAMDISK_LOAD_FLAG		0x4000
L
Linus Torvalds 已提交
237

238
static char __initdata command_line[COMMAND_LINE_SIZE];
239 240 241
#ifdef CONFIG_CMDLINE_BOOL
static char __initdata builtin_cmdline[COMMAND_LINE_SIZE] = CONFIG_CMDLINE;
#endif
L
Linus Torvalds 已提交
242 243 244 245 246 247 248 249 250 251 252

#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.
 *
 */
253
static inline void __init copy_edd(void)
L
Linus Torvalds 已提交
254
{
255 256 257 258 259
     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 已提交
260 261
}
#else
262
static inline void __init copy_edd(void)
L
Linus Torvalds 已提交
263 264 265 266
{
}
#endif

267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285
void * __init extend_brk(size_t size, size_t align)
{
	size_t mask = align - 1;
	void *ret;

	BUG_ON(_brk_start == 0);
	BUG_ON(align & mask);

	_brk_end = (_brk_end + mask) & ~mask;
	BUG_ON((char *)(_brk_end + size) > __brk_limit);

	ret = (void *)_brk_end;
	_brk_end += size;

	memset(ret, 0, size);

	return ret;
}

286 287 288 289 290 291 292 293 294 295 296 297 298 299
#ifdef CONFIG_X86_64
static void __init init_gbpages(void)
{
	if (direct_gbpages && cpu_has_gbpages)
		printk(KERN_INFO "Using GB pages for direct mapping\n");
	else
		direct_gbpages = 0;
}
#else
static inline void init_gbpages(void)
{
}
#endif

300 301 302 303 304 305 306 307 308 309
static void __init reserve_brk(void)
{
	if (_brk_end > _brk_start)
		reserve_early(__pa(_brk_start), __pa(_brk_end), "BRK");

	/* Mark brk area as locked down and no longer taking any
	   new allocations */
	_brk_start = 0;
}

310 311
#ifdef CONFIG_BLK_DEV_INITRD

312 313
#define MAX_MAP_CHUNK	(NR_FIX_BTMAPS << PAGE_SHIFT)
static void __init relocate_initrd(void)
314
{
315

316 317
	u64 ramdisk_image = boot_params.hdr.ramdisk_image;
	u64 ramdisk_size  = boot_params.hdr.ramdisk_size;
318
	u64 end_of_lowmem = max_low_pfn_mapped << PAGE_SHIFT;
319
	u64 ramdisk_here;
320 321
	unsigned long slop, clen, mapaddr;
	char *p, *q;
322 323

	/* We need to move the initrd down into lowmem */
324 325
	ramdisk_here = find_e820_area(0, end_of_lowmem, ramdisk_size,
					 PAGE_SIZE);
326

327 328 329 330
	if (ramdisk_here == -1ULL)
		panic("Cannot find place for new RAMDISK of size %lld\n",
			 ramdisk_size);

331 332
	/* Note: this includes all the lowmem currently occupied by
	   the initrd, we rely on that fact to keep the data intact. */
333
	reserve_early(ramdisk_here, ramdisk_here + ramdisk_size,
334
			 "NEW RAMDISK");
335 336
	initrd_start = ramdisk_here + PAGE_OFFSET;
	initrd_end   = initrd_start + ramdisk_size;
337 338
	printk(KERN_INFO "Allocated new RAMDISK: %08llx - %08llx\n",
			 ramdisk_here, ramdisk_here + ramdisk_size);
339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358

	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;
359
		p = early_memremap(mapaddr, clen+slop);
360
		memcpy(q, p+slop, clen);
361
		early_iounmap(p, clen+slop);
362 363 364 365
		q += clen;
		ramdisk_image += clen;
		ramdisk_size  -= clen;
	}
366
	/* high pages is not converted by early_res_to_bootmem */
367 368
	ramdisk_image = boot_params.hdr.ramdisk_image;
	ramdisk_size  = boot_params.hdr.ramdisk_size;
369 370
	printk(KERN_INFO "Move RAMDISK from %016llx - %016llx to"
		" %08llx - %08llx\n",
371 372
		ramdisk_image, ramdisk_image + ramdisk_size - 1,
		ramdisk_here, ramdisk_here + ramdisk_size - 1);
373
}
Y
Yinghai Lu 已提交
374

375 376 377 378 379
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;
380
	u64 end_of_lowmem = max_low_pfn_mapped << PAGE_SHIFT;
381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410

	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;
	}

	relocate_initrd();
411

412
	free_early(ramdisk_image, ramdisk_end);
413
}
Y
Yinghai Lu 已提交
414
#else
415
static void __init reserve_initrd(void)
Y
Yinghai Lu 已提交
416 417
{
}
418 419
#endif /* CONFIG_BLK_DEV_INITRD */

420
static void __init parse_setup_data(void)
421 422 423 424 425 426 427 428
{
	struct setup_data *data;
	u64 pa_data;

	if (boot_params.hdr.version < 0x0209)
		return;
	pa_data = boot_params.hdr.setup_data;
	while (pa_data) {
429
		data = early_memremap(pa_data, PAGE_SIZE);
430 431 432 433 434 435 436 437 438 439 440 441
		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);
	}
}

442
static void __init e820_reserve_setup_data(void)
443 444 445
{
	struct setup_data *data;
	u64 pa_data;
446
	int found = 0;
447 448 449 450 451

	if (boot_params.hdr.version < 0x0209)
		return;
	pa_data = boot_params.hdr.setup_data;
	while (pa_data) {
452
		data = early_memremap(pa_data, sizeof(*data));
453 454
		e820_update_range(pa_data, sizeof(*data)+data->len,
			 E820_RAM, E820_RESERVED_KERN);
455
		found = 1;
456 457 458
		pa_data = data->next;
		early_iounmap(data, sizeof(*data));
	}
459 460 461
	if (!found)
		return;

462
	sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
463
	memcpy(&e820_saved, &e820, sizeof(struct e820map));
464 465 466 467
	printk(KERN_INFO "extended physical RAM map:\n");
	e820_print_map("reserve setup_data");
}

468 469 470 471 472 473 474 475 476 477
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) {
478
		data = early_memremap(pa_data, sizeof(*data));
479 480 481 482 483 484 485
		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));
	}
}

486 487 488 489 490
/*
 * --------- Crashkernel reservation ------------------------------
 */

#ifdef CONFIG_KEXEC
491

492 493 494 495
static inline unsigned long long get_total_mem(void)
{
	unsigned long long total;

496
	total = max_pfn - min_low_pfn;
497 498 499 500

	return total << PAGE_SHIFT;
}

501
static void __init reserve_crashkernel(void)
502 503 504 505 506 507 508 509 510
{
	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);
511 512 513 514 515
	if (ret != 0 || crash_size <= 0)
		return;

	/* 0 means: find the address automatically */
	if (crash_base <= 0) {
516 517 518 519
		const unsigned long long alignment = 16<<20;	/* 16M */

		crash_base = find_e820_area(alignment, ULONG_MAX, crash_size,
				 alignment);
520
		if (crash_base == -1ULL) {
521
			pr_info("crashkernel reservation failed - No suitable area found.\n");
522 523
			return;
		}
524
	} else {
525 526 527 528 529 530
		unsigned long long start;

		start = find_e820_area(crash_base, ULONG_MAX, crash_size,
				 1<<20);
		if (start != crash_base) {
			pr_info("crashkernel reservation failed - memory is in use.\n");
531 532
			return;
		}
533
	}
534
	reserve_early(crash_base, crash_base + crash_size, "CRASH KERNEL");
535

536 537 538 539 540
	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));
541

542 543 544
	crashk_res.start = crash_base;
	crashk_res.end   = crash_base + crash_size - 1;
	insert_resource(&iomem_resource, &crashk_res);
545 546
}
#else
547
static void __init reserve_crashkernel(void)
548 549 550 551
{
}
#endif

552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574
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 }
};

575
void __init reserve_standard_io_resources(void)
576 577 578 579 580 581 582 583 584
{
	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]);

}

585 586 587 588 589 590 591
/*
 * 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
592 593 594 595 596 597 598 599 600 601 602 603 604 605 606
/* 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

607
#ifdef CONFIG_X86_RESERVE_LOW_64K
608 609 610
static int __init dmi_low_memory_corruption(const struct dmi_system_id *d)
{
	printk(KERN_NOTICE
611
		"%s detected: BIOS may corrupt low RAM, working around it.\n",
612 613
		d->ident);

614 615
	e820_update_range(0, 0x10000, E820_RAM, E820_RESERVED);
	sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
616 617 618

	return 0;
}
619
#endif
620 621 622

/* List of systems that have known low memory corruption BIOS problems */
static struct dmi_system_id __initdata bad_bios_dmi_table[] = {
I
Ingo Molnar 已提交
623
#ifdef CONFIG_X86_RESERVE_LOW_64K
624 625 626 627 628 629 630
	{
		.callback = dmi_low_memory_corruption,
		.ident = "AMI BIOS",
		.matches = {
			DMI_MATCH(DMI_BIOS_VENDOR, "American Megatrends Inc."),
		},
	},
631 632 633 634
	{
		.callback = dmi_low_memory_corruption,
		.ident = "Phoenix BIOS",
		.matches = {
635
			DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies"),
636 637
		},
	},
638
	{
639 640 641 642 643 644
		.callback = dmi_low_memory_corruption,
		.ident = "Phoenix/MSC BIOS",
		.matches = {
			DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix/MSC"),
		},
	},
645
	/*
646 647 648
	 * AMI BIOS with low memory corruption was found on Intel DG45ID and
	 * DG45FC boards.
	 * It has a different DMI_BIOS_VENDOR = "Intel Corp.", for now we will
649 650 651
	 * match only DMI_BOARD_NAME and see if there is more bad products
	 * with this vendor.
	 */
652
	{
653 654 655 656 657 658
		.callback = dmi_low_memory_corruption,
		.ident = "AMI BIOS",
		.matches = {
			DMI_MATCH(DMI_BOARD_NAME, "DG45ID"),
		},
	},
659 660 661 662 663 664 665
	{
		.callback = dmi_low_memory_corruption,
		.ident = "AMI BIOS",
		.matches = {
			DMI_MATCH(DMI_BOARD_NAME, "DG45FC"),
		},
	},
I
Ingo Molnar 已提交
666
#endif
667
	{}
668 669
};

670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686
static void __init trim_bios_range(void)
{
	/*
	 * A special case is the first 4Kb of memory;
	 * This is a BIOS owned area, not kernel ram, but generally
	 * not listed as such in the E820 table.
	 */
	e820_update_range(0, PAGE_SIZE, E820_RAM, E820_RESERVED);
	/*
	 * special case: Some BIOSen report the PC BIOS
	 * area (640->1Mb) as ram even though it is not.
	 * take them out.
	 */
	e820_remove_range(BIOS_BEGIN, BIOS_END - BIOS_BEGIN, E820_RAM, 1);
	sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
}

L
Linus Torvalds 已提交
687 688 689 690 691 692 693
/*
 * 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.
 */
694 695 696 697 698 699
/*
 * setup_arch - architecture-specific boot-time initializations
 *
 * Note: On x86_64, fixmaps are ready for use even before this is called.
 */

L
Linus Torvalds 已提交
700 701
void __init setup_arch(char **cmdline_p)
{
D
David Rientjes 已提交
702 703 704
	int acpi = 0;
	int k8 = 0;

705
#ifdef CONFIG_X86_32
L
Linus Torvalds 已提交
706
	memcpy(&boot_cpu_data, &new_cpu_data, sizeof(new_cpu_data));
I
Ingo Molnar 已提交
707
	visws_early_detect();
708 709 710
#else
	printk(KERN_INFO "Command line: %s\n", boot_command_line);
#endif
L
Linus Torvalds 已提交
711

712 713 714
	/* VMI may relocate the fixmap; do this before touching ioremap area */
	vmi_init();

715
	early_cpu_init();
716 717
	early_ioremap_init();

718 719 720
	ROOT_DEV = old_decode_dev(boot_params.hdr.root_dev);
	screen_info = boot_params.screen_info;
	edid_info = boot_params.edid_info;
721
#ifdef CONFIG_X86_32
722 723
	apm_info.bios = boot_params.apm_bios_info;
	ist_info = boot_params.ist_info;
724
	if (boot_params.sys_desc_table.length != 0) {
725 726 727 728
		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 已提交
729
	}
730 731
#endif
	saved_video_mode = boot_params.hdr.vid_mode;
732
	bootloader_type = boot_params.hdr.type_of_loader;
733 734 735 736 737 738
	if ((bootloader_type >> 4) == 0xe) {
		bootloader_type &= 0xf;
		bootloader_type |= (boot_params.hdr.ext_loader_type+0x10) << 4;
	}
	bootloader_version  = bootloader_type & 0xf;
	bootloader_version |= boot_params.hdr.ext_loader_ver << 4;
L
Linus Torvalds 已提交
739 740

#ifdef CONFIG_BLK_DEV_RAM
741 742 743
	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 已提交
744
#endif
745 746
#ifdef CONFIG_EFI
	if (!strncmp((char *)&boot_params.efi_info.efi_loader_signature,
747 748 749 750 751 752
#ifdef CONFIG_X86_32
		     "EL32",
#else
		     "EL64",
#endif
	 4)) {
753 754 755 756 757
		efi_enabled = 1;
		efi_reserve_early();
	}
#endif

758
	x86_init.oem.arch_setup();
759

760
	setup_memory_map();
761
	parse_setup_data();
762 763
	/* update the e820_saved too */
	e820_reserve_setup_data();
764

L
Linus Torvalds 已提交
765 766
	copy_edd();

767
	if (!boot_params.hdr.root_flags)
L
Linus Torvalds 已提交
768 769 770 771
		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;
772
	init_mm.brk = _brk_end;
L
Linus Torvalds 已提交
773 774 775 776 777

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

781 782 783 784 785 786 787 788 789 790 791 792 793
#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

794 795 796 797
	strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE);
	*cmdline_p = command_line;

	/*
798 799 800 801 802
	 * x86_configure_nx() is called before parse_early_param() to detect
	 * whether hardware doesn't support NX (so that the early EHCI debug
	 * console setup can safely call set_fixmap()). It may then be called
	 * again from within noexec_setup() during parsing early parameters
	 * to honor the respective command line option.
803
	 */
804
	x86_configure_nx();
805 806 807

	parse_early_param();

808
	x86_report_nx();
809

810 811
	/* Must be before kernel pagetables are setup */
	vmi_activate();
A
Alok Kataria 已提交
812

813
	/* after early param, so could get panic from serial */
814
	reserve_early_setup_data();
815

816
	if (acpi_mps_check()) {
I
Ingo Molnar 已提交
817
#ifdef CONFIG_X86_LOCAL_APIC
818
		disable_apic = 1;
I
Ingo Molnar 已提交
819
#endif
820
		setup_clear_cpu_cap(X86_FEATURE_APIC);
821 822
	}

823 824 825 826 827
#ifdef CONFIG_PCI
	if (pci_early_dump_regs)
		early_dump_pci_devices();
#endif

828
	finish_e820_parsing();
829

B
Brian Maly 已提交
830 831 832
	if (efi_enabled)
		efi_init();

833 834 835 836
	dmi_scan_machine();

	dmi_check_system(bad_bios_dmi_table);

837 838 839 840
	/*
	 * VMware detection requires dmi to be available, so this
	 * needs to be done after dmi_scan_machine, for the BP.
	 */
841
	init_hypervisor_platform();
842

843
	x86_init.resources.probe_roms();
844 845 846 847 848 849

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

850
	trim_bios_range();
851
#ifdef CONFIG_X86_32
Y
Yinghai Lu 已提交
852 853 854 855 856 857 858
	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");
	}
859 860 861
#else
	early_gart_iommu_check();
#endif
Y
Yinghai Lu 已提交
862

863 864 865 866
	/*
	 * partially used pages are not usable - thus
	 * we are rounding upwards:
	 */
867
	max_pfn = e820_end_of_ram_pfn();
868

Y
Yinghai Lu 已提交
869 870
	/* preallocate 4k for mptable mpc */
	early_reserve_e820_mpc_new();
871 872
	/* update e820 for memory not covered by WB MTRRs */
	mtrr_bp_init();
873
	if (mtrr_trim_uncached_memory(max_pfn))
874
		max_pfn = e820_end_of_ram_pfn();
875

876
#ifdef CONFIG_X86_32
877
	/* max_low_pfn get updated here */
878
	find_low_pfn_range();
879 880 881
#else
	num_physpages = max_pfn;

Y
Yinghai Lu 已提交
882
	check_x2apic();
883 884 885

	/* How many end-of-memory variables you have, grandma! */
	/* need this before calling reserve_initrd */
886 887 888 889 890
	if (max_pfn > (1UL<<(32 - PAGE_SHIFT)))
		max_low_pfn = e820_end_of_low_ram_pfn();
	else
		max_low_pfn = max_pfn;

891
	high_memory = (void *)__va(max_pfn * PAGE_SIZE - 1) + 1;
892
	max_pfn_mapped = KERNEL_IMAGE_SIZE >> PAGE_SHIFT;
893
#endif
894

895 896 897 898
#ifdef CONFIG_X86_CHECK_BIOS_CORRUPTION
	setup_bios_corruption_check();
#endif

899 900 901
	printk(KERN_DEBUG "initial memory mapped : 0 - %08lx\n",
			max_pfn_mapped<<PAGE_SHIFT);

902 903
	reserve_brk();

904 905 906 907 908 909 910
	/*
	 * Find and reserve possible boot-time SMP configuration:
	 */
	find_smp_config();

	reserve_trampoline_memory();

911 912 913 914 915 916 917
#ifdef CONFIG_ACPI_SLEEP
	/*
	 * Reserve low memory region for sleep support.
	 * even before init_memory_mapping
	 */
	acpi_reserve_wakeup_memory();
#endif
918 919
	init_gbpages();

920
	/* max_pfn_mapped is updated here */
921 922 923 924 925 926 927 928 929 930 931
	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
932

933 934 935 936 937 938 939 940 941
	/*
	 * 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

942 943
	reserve_initrd();

944 945
	reserve_crashkernel();

946 947
	vsmp_init();

948 949 950 951 952 953 954
	io_delay_init();

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

955 956
	early_acpi_boot_init();

957
#ifdef CONFIG_ACPI_NUMA
Y
Yinghai Lu 已提交
958 959 960
	/*
	 * Parse SRAT to discover nodes.
	 */
961
	acpi = acpi_numa_init();
962 963
#endif

D
David Rientjes 已提交
964
#ifdef CONFIG_K8_NUMA
965 966
	if (!acpi)
		k8 = !k8_numa_init(0, max_pfn);
D
David Rientjes 已提交
967 968 969
#endif

	initmem_init(0, max_pfn, acpi, k8);
970

971 972 973 974 975 976 977 978 979
#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

980 981
	reserve_ibft_region();

982 983 984 985
#ifdef CONFIG_KVM_CLOCK
	kvmclock_init();
#endif

986
	x86_init.paging.pagetable_setup_start(swapper_pg_dir);
L
Linus Torvalds 已提交
987
	paging_init();
988
	x86_init.paging.pagetable_setup_done(swapper_pg_dir);
989

990 991
	tboot_probe();

992 993 994 995
#ifdef CONFIG_X86_64
	map_vsyscall();
#endif

996
	generic_apic_probe();
L
Linus Torvalds 已提交
997

998
	early_quirks();
999

1000 1001 1002
	/*
	 * Read APIC and some other early information from ACPI tables.
	 */
L
Linus Torvalds 已提交
1003
	acpi_boot_init();
1004

F
Feng Tang 已提交
1005
	sfi_init();
1006

1007 1008 1009
	/*
	 * get boot-time SMP configuration:
	 */
1010 1011
	if (smp_found_config)
		get_smp_config();
1012

1013
	prefill_possible_map();
Y
Yinghai Lu 已提交
1014

1015 1016 1017 1018
#ifdef CONFIG_X86_64
	init_cpu_to_node();
#endif

1019 1020
	init_apic_mappings();
	ioapic_init_mappings();
1021

1022
	/* need to wait for io_apic is mapped */
1023
	probe_nr_irqs_gsi();
1024

1025
	kvm_guest_init();
L
Linus Torvalds 已提交
1026

1027
	e820_reserve_resources();
1028
	e820_mark_nosave_regions(max_low_pfn);
L
Linus Torvalds 已提交
1029

1030
	x86_init.resources.reserve_resources();
1031 1032 1033

	e820_setup_gap();

L
Linus Torvalds 已提交
1034 1035 1036 1037 1038 1039 1040 1041
#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
1042
	x86_init.oem.banner();
1043 1044

	mcheck_init();
L
Linus Torvalds 已提交
1045
}
1046

1047 1048
#ifdef CONFIG_X86_32

1049 1050 1051 1052 1053
static struct resource video_ram_resource = {
	.name	= "Video RAM area",
	.start	= 0xa0000,
	.end	= 0xbffff,
	.flags	= IORESOURCE_BUSY | IORESOURCE_MEM
1054 1055
};

1056
void __init i386_reserve_resources(void)
1057
{
1058 1059
	request_resource(&iomem_resource, &video_ram_resource);
	reserve_standard_io_resources();
1060 1061 1062
}

#endif /* CONFIG_X86_32 */