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
#include <asm/e820.h>
#include <asm/mpspec.h>
#include <asm/setup.h>
Y
Yinghai Lu 已提交
77
#include <asm/efi.h>
I
Ingo Molnar 已提交
78 79
#include <asm/timer.h>
#include <asm/i8259.h>
L
Linus Torvalds 已提交
80
#include <asm/sections.h>
81
#include <asm/dmi.h>
L
Linus Torvalds 已提交
82 83
#include <asm/io_apic.h>
#include <asm/ist.h>
84
#include <asm/vmi.h>
85
#include <asm/setup_arch.h>
86
#include <asm/bios_ebda.h>
B
Bernhard Walle 已提交
87
#include <asm/cacheflush.h>
88
#include <asm/processor.h>
Y
Yinghai Lu 已提交
89
#include <asm/bugs.h>
L
Linus Torvalds 已提交
90

91 92
#include <asm/system.h>
#include <asm/vsyscall.h>
93
#include <asm/cpu.h>
94 95
#include <asm/desc.h>
#include <asm/dma.h>
96
#include <asm/iommu.h>
97
#include <asm/gart.h>
98 99 100 101
#include <asm/mmu_context.h>
#include <asm/proto.h>

#include <asm/paravirt.h>
102
#include <asm/hypervisor.h>
103 104 105 106

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

Y
Yinghai Lu 已提交
111 112 113 114
#ifndef ARCH_SETUP
#define ARCH_SETUP
#endif

115 116 117 118 119 120 121 122
/*
 * 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;

123 124
RESERVE_BRK(dmi_alloc, 65536);

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

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

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

int default_check_phys_apicid_present(int boot_cpu_physical_apicid)
{
	return __default_check_phys_apicid_present(boot_cpu_physical_apicid);
}
#endif

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

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

172 173

#ifdef CONFIG_X86_32
174 175 176 177 178 179 180
static struct resource video_ram_resource = {
	.name	= "Video RAM area",
	.start	= 0xa0000,
	.end	= 0xbffff,
	.flags	= IORESOURCE_BUSY | IORESOURCE_MEM
};

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

193 194
unsigned int def_to_bigsmp;

L
Linus Torvalds 已提交
195 196 197 198 199
/* for MCA, but anyone else can use it if they want */
unsigned int machine_id;
unsigned int machine_submodel_id;
unsigned int BIOS_revision;

200 201 202 203 204 205 206 207 208 209 210 211
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
212 213 214
struct cpuinfo_x86 boot_cpu_data __read_mostly = {
	.x86_phys_bits = MAX_PHYSMEM_BITS,
};
215 216 217 218 219 220 221 222 223 224
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

225 226
/* Boot loader ID and version as integers, for the benefit of proc_dointvec */
int bootloader_type, bootloader_version;
L
Linus Torvalds 已提交
227 228 229 230 231

/*
 * Setup options
 */
struct screen_info screen_info;
232
EXPORT_SYMBOL(screen_info);
L
Linus Torvalds 已提交
233
struct edid_info edid_info;
234
EXPORT_SYMBOL_GPL(edid_info);
L
Linus Torvalds 已提交
235 236 237

extern int root_mountflags;

238
unsigned long saved_video_mode;
L
Linus Torvalds 已提交
239

240
#define RAMDISK_IMAGE_START_MASK	0x07FF
L
Linus Torvalds 已提交
241
#define RAMDISK_PROMPT_FLAG		0x8000
242
#define RAMDISK_LOAD_FLAG		0x4000
L
Linus Torvalds 已提交
243

244
static char __initdata command_line[COMMAND_LINE_SIZE];
245 246 247
#ifdef CONFIG_CMDLINE_BOOL
static char __initdata builtin_cmdline[COMMAND_LINE_SIZE] = CONFIG_CMDLINE;
#endif
L
Linus Torvalds 已提交
248 249 250 251 252 253 254 255 256 257 258 259 260

#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)
{
261 262 263 264 265
     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 已提交
266 267 268 269 270 271 272
}
#else
static inline void copy_edd(void)
{
}
#endif

273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291
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;
}

292 293 294 295 296 297 298 299 300 301 302 303 304 305
#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

306 307 308 309 310 311 312 313 314 315
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;
}

316 317
#ifdef CONFIG_BLK_DEV_INITRD

318 319
#define MAX_MAP_CHUNK	(NR_FIX_BTMAPS << PAGE_SHIFT)
static void __init relocate_initrd(void)
320
{
321

322 323
	u64 ramdisk_image = boot_params.hdr.ramdisk_image;
	u64 ramdisk_size  = boot_params.hdr.ramdisk_size;
324
	u64 end_of_lowmem = max_low_pfn_mapped << PAGE_SHIFT;
325
	u64 ramdisk_here;
326 327
	unsigned long slop, clen, mapaddr;
	char *p, *q;
328 329

	/* We need to move the initrd down into lowmem */
330 331
	ramdisk_here = find_e820_area(0, end_of_lowmem, ramdisk_size,
					 PAGE_SIZE);
332

333 334 335 336
	if (ramdisk_here == -1ULL)
		panic("Cannot find place for new RAMDISK of size %lld\n",
			 ramdisk_size);

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

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

381 382 383 384 385
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;
386
	u64 end_of_lowmem = max_low_pfn_mapped << PAGE_SHIFT;
387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416

	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();
417

418
	free_early(ramdisk_image, ramdisk_end);
419
}
Y
Yinghai Lu 已提交
420
#else
421
static void __init reserve_initrd(void)
Y
Yinghai Lu 已提交
422 423
{
}
424 425
#endif /* CONFIG_BLK_DEV_INITRD */

426
static void __init parse_setup_data(void)
427 428 429 430 431 432 433 434
{
	struct setup_data *data;
	u64 pa_data;

	if (boot_params.hdr.version < 0x0209)
		return;
	pa_data = boot_params.hdr.setup_data;
	while (pa_data) {
435
		data = early_memremap(pa_data, PAGE_SIZE);
436 437 438 439 440 441 442 443 444 445 446 447
		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);
	}
}

448
static void __init e820_reserve_setup_data(void)
449 450 451
{
	struct setup_data *data;
	u64 pa_data;
452
	int found = 0;
453 454 455 456 457

	if (boot_params.hdr.version < 0x0209)
		return;
	pa_data = boot_params.hdr.setup_data;
	while (pa_data) {
458
		data = early_memremap(pa_data, sizeof(*data));
459 460
		e820_update_range(pa_data, sizeof(*data)+data->len,
			 E820_RAM, E820_RESERVED_KERN);
461
		found = 1;
462 463 464
		pa_data = data->next;
		early_iounmap(data, sizeof(*data));
	}
465 466 467
	if (!found)
		return;

468
	sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
469
	memcpy(&e820_saved, &e820, sizeof(struct e820map));
470 471 472 473
	printk(KERN_INFO "extended physical RAM map:\n");
	e820_print_map("reserve setup_data");
}

474 475 476 477 478 479 480 481 482 483
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) {
484
		data = early_memremap(pa_data, sizeof(*data));
485 486 487 488 489 490 491
		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));
	}
}

492 493 494 495 496
/*
 * --------- Crashkernel reservation ------------------------------
 */

#ifdef CONFIG_KEXEC
497 498 499 500 501 502 503

/**
 * 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.
 */
504
static
505
unsigned long long __init find_and_reserve_crashkernel(unsigned long long size)
506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525
{
	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;
	}
}

526 527 528 529 530 531 532 533 534 535 536 537
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;
}

538
static void __init reserve_crashkernel(void)
539 540 541 542 543 544 545 546 547
{
	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);
548 549 550 551 552 553 554 555 556
	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");
557 558
			return;
		}
559 560 561 562 563 564
	} else {
		ret = reserve_bootmem_generic(crash_base, crash_size,
					BOOTMEM_EXCLUSIVE);
		if (ret < 0) {
			pr_info("crashkernel reservation failed - "
				"memory is in use\n");
565 566
			return;
		}
567
	}
568

569 570 571 572 573
	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));
574

575 576 577
	crashk_res.start = crash_base;
	crashk_res.end   = crash_base + crash_size - 1;
	insert_resource(&iomem_resource, &crashk_res);
578 579
}
#else
580
static void __init reserve_crashkernel(void)
581 582 583 584
{
}
#endif

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

608
static void __init reserve_standard_io_resources(void)
609 610 611 612 613 614 615 616 617
{
	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]);

}

618 619 620 621 622 623 624
/*
 * 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
625 626 627 628 629 630 631 632 633 634 635 636 637 638 639
/* 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

640
static struct x86_quirks default_x86_quirks __initdata;
641

Y
Yinghai Lu 已提交
642
struct x86_quirks *x86_quirks __initdata = &default_x86_quirks;
643

644
#ifdef CONFIG_X86_RESERVE_LOW_64K
645 646 647
static int __init dmi_low_memory_corruption(const struct dmi_system_id *d)
{
	printk(KERN_NOTICE
648
		"%s detected: BIOS may corrupt low RAM, working around it.\n",
649 650
		d->ident);

651 652
	e820_update_range(0, 0x10000, E820_RAM, E820_RESERVED);
	sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
653 654 655

	return 0;
}
656
#endif
657 658 659

/* List of systems that have known low memory corruption BIOS problems */
static struct dmi_system_id __initdata bad_bios_dmi_table[] = {
I
Ingo Molnar 已提交
660
#ifdef CONFIG_X86_RESERVE_LOW_64K
661 662 663 664 665 666 667
	{
		.callback = dmi_low_memory_corruption,
		.ident = "AMI BIOS",
		.matches = {
			DMI_MATCH(DMI_BIOS_VENDOR, "American Megatrends Inc."),
		},
	},
668 669 670 671
	{
		.callback = dmi_low_memory_corruption,
		.ident = "Phoenix BIOS",
		.matches = {
672
			DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies"),
673 674
		},
	},
675 676 677 678 679 680 681 682 683 684 685 686 687
	{
	/*
	 * AMI BIOS with low memory corruption was found on Intel DG45ID board.
	 * It hase different DMI_BIOS_VENDOR = "Intel Corp.", for now we will
	 * match only DMI_BOARD_NAME and see if there is more bad products
	 * with this vendor.
	 */
		.callback = dmi_low_memory_corruption,
		.ident = "AMI BIOS",
		.matches = {
			DMI_MATCH(DMI_BOARD_NAME, "DG45ID"),
		},
	},
I
Ingo Molnar 已提交
688
#endif
689
	{}
690 691
};

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

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

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

717
	early_cpu_init();
718 719
	early_ioremap_init();

720 721 722
	ROOT_DEV = old_decode_dev(boot_params.hdr.root_dev);
	screen_info = boot_params.screen_info;
	edid_info = boot_params.edid_info;
723
#ifdef CONFIG_X86_32
724 725
	apm_info.bios = boot_params.apm_bios_info;
	ist_info = boot_params.ist_info;
726
	if (boot_params.sys_desc_table.length != 0) {
727 728 729 730
		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 已提交
731
	}
732 733
#endif
	saved_video_mode = boot_params.hdr.vid_mode;
734
	bootloader_type = boot_params.hdr.type_of_loader;
735 736 737 738 739 740
	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 已提交
741 742

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

L
Linus Torvalds 已提交
760
	ARCH_SETUP
761

762
	setup_memory_map();
763
	parse_setup_data();
764 765
	/* update the e820_saved too */
	e820_reserve_setup_data();
766

L
Linus Torvalds 已提交
767 768
	copy_edd();

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

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

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

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

799
	parse_early_param();
L
Linus Torvalds 已提交
800

801 802 803 804
#ifdef CONFIG_X86_64
	check_efer();
#endif

805 806
	/* Must be before kernel pagetables are setup */
	vmi_activate();
A
Alok Kataria 已提交
807

808
	/* after early param, so could get panic from serial */
809
	reserve_early_setup_data();
810

811
	if (acpi_mps_check()) {
I
Ingo Molnar 已提交
812
#ifdef CONFIG_X86_LOCAL_APIC
813
		disable_apic = 1;
I
Ingo Molnar 已提交
814
#endif
815
		setup_clear_cpu_cap(X86_FEATURE_APIC);
816 817
	}

818 819 820 821 822
#ifdef CONFIG_PCI
	if (pci_early_dump_regs)
		early_dump_pci_devices();
#endif

823
	finish_e820_parsing();
824

B
Brian Maly 已提交
825 826 827
	if (efi_enabled)
		efi_init();

828 829 830 831
	dmi_scan_machine();

	dmi_check_system(bad_bios_dmi_table);

832 833 834 835 836 837
	/*
	 * VMware detection requires dmi to be available, so this
	 * needs to be done after dmi_scan_machine, for the BP.
	 */
	init_hypervisor(&boot_cpu_data);

838
#ifdef CONFIG_X86_32
839
	probe_roms();
840
#endif
841 842 843 844 845 846

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

847

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

860 861 862 863
	/*
	 * partially used pages are not usable - thus
	 * we are rounding upwards:
	 */
864
	max_pfn = e820_end_of_ram_pfn();
865

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

873
#ifdef CONFIG_X86_32
874
	/* max_low_pfn get updated here */
875
	find_low_pfn_range();
876 877 878
#else
	num_physpages = max_pfn;

Y
Yinghai Lu 已提交
879
	check_x2apic();
880 881 882

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

888
	high_memory = (void *)__va(max_pfn * PAGE_SIZE - 1) + 1;
889
	max_pfn_mapped = KERNEL_IMAGE_SIZE >> PAGE_SHIFT;
890
#endif
891

892 893 894 895
#ifdef CONFIG_X86_CHECK_BIOS_CORRUPTION
	setup_bios_corruption_check();
#endif

896 897 898
	printk(KERN_DEBUG "initial memory mapped : 0 - %08lx\n",
			max_pfn_mapped<<PAGE_SHIFT);

899 900
	reserve_brk();

901 902
	init_gbpages();

903
	/* max_pfn_mapped is updated here */
904 905 906 907 908 909 910 911 912 913 914
	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
915

916 917 918 919 920 921 922 923 924
	/*
	 * 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

925 926
	reserve_initrd();

927 928
	vsmp_init();

929 930 931 932 933 934 935
	io_delay_init();

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

936 937
	early_acpi_boot_init();

938
#ifdef CONFIG_ACPI_NUMA
Y
Yinghai Lu 已提交
939 940 941 942
	/*
	 * Parse SRAT to discover nodes.
	 */
	acpi_numa_init();
943 944
#endif

945
	initmem_init(0, max_pfn);
946

947 948 949 950 951 952 953 954 955 956
#ifdef CONFIG_ACPI_SLEEP
	/*
	 * Reserve low memory region for sleep support.
	 */
	acpi_reserve_bootmem();
#endif
	/*
	 * Find and reserve possible boot-time SMP configuration:
	 */
	find_smp_config();
957

958 959
	reserve_crashkernel();

960 961 962 963 964 965 966 967 968
#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

969 970
	reserve_ibft_region();

971 972 973 974
#ifdef CONFIG_KVM_CLOCK
	kvmclock_init();
#endif

975
	paravirt_pagetable_setup_start(swapper_pg_dir);
L
Linus Torvalds 已提交
976
	paging_init();
977
	paravirt_pagetable_setup_done(swapper_pg_dir);
978
	paravirt_post_allocator_init();
979

980 981 982 983
#ifdef CONFIG_X86_64
	map_vsyscall();
#endif

984
	generic_apic_probe();
L
Linus Torvalds 已提交
985

986
	early_quirks();
987

988 989 990
	/*
	 * Read APIC and some other early information from ACPI tables.
	 */
L
Linus Torvalds 已提交
991
	acpi_boot_init();
992

993
#if defined(CONFIG_X86_MPPARSE) || defined(CONFIG_X86_VISWS)
994 995 996
	/*
	 * get boot-time SMP configuration:
	 */
997 998 999
	if (smp_found_config)
		get_smp_config();
#endif
1000

1001
	prefill_possible_map();
Y
Yinghai Lu 已提交
1002

1003 1004 1005 1006
#ifdef CONFIG_X86_64
	init_cpu_to_node();
#endif

1007 1008
	init_apic_mappings();
	ioapic_init_mappings();
1009

1010
	/* need to wait for io_apic is mapped */
1011
	probe_nr_irqs_gsi();
1012

1013
	kvm_guest_init();
L
Linus Torvalds 已提交
1014

1015
	e820_reserve_resources();
1016
	e820_mark_nosave_regions(max_low_pfn);
L
Linus Torvalds 已提交
1017

1018
#ifdef CONFIG_X86_32
1019
	request_resource(&iomem_resource, &video_ram_resource);
1020
#endif
1021
	reserve_standard_io_resources();
1022 1023 1024

	e820_setup_gap();

L
Linus Torvalds 已提交
1025 1026 1027 1028 1029 1030 1031 1032 1033
#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
}
1034

1035 1036 1037
#ifdef CONFIG_X86_32

/**
I
Ingo Molnar 已提交
1038
 * x86_quirk_intr_init - post gate setup interrupt initialisation
1039 1040 1041 1042 1043 1044 1045
 *
 * Description:
 *	Fill in any interrupts that may have been left out by the general
 *	init_IRQ() routine.  interrupts having to do with the machine rather
 *	than the devices on the I/O bus (like APIC interrupts in intel MP
 *	systems) are started here.
 **/
I
Ingo Molnar 已提交
1046
void __init x86_quirk_intr_init(void)
1047 1048 1049 1050 1051 1052 1053 1054
{
	if (x86_quirks->arch_intr_init) {
		if (x86_quirks->arch_intr_init())
			return;
	}
}

/**
I
Ingo Molnar 已提交
1055
 * x86_quirk_trap_init - initialise system specific traps
1056 1057 1058 1059 1060
 *
 * Description:
 *	Called as the final act of trap_init().  Used in VISWS to initialise
 *	the various board specific APIC traps.
 **/
I
Ingo Molnar 已提交
1061
void __init x86_quirk_trap_init(void)
1062 1063 1064 1065 1066 1067 1068 1069 1070
{
	if (x86_quirks->arch_trap_init) {
		if (x86_quirks->arch_trap_init())
			return;
	}
}

static struct irqaction irq0  = {
	.handler = timer_interrupt,
I
Ingo Molnar 已提交
1071
	.flags = IRQF_DISABLED | IRQF_NOBALANCING | IRQF_IRQPOLL | IRQF_TIMER,
1072 1073 1074 1075
	.name = "timer"
};

/**
I
Ingo Molnar 已提交
1076
 * x86_quirk_pre_time_init - do any specific initialisations before.
1077 1078
 *
 **/
I
Ingo Molnar 已提交
1079
void __init x86_quirk_pre_time_init(void)
1080 1081 1082 1083 1084 1085
{
	if (x86_quirks->arch_pre_time_init)
		x86_quirks->arch_pre_time_init();
}

/**
I
Ingo Molnar 已提交
1086
 * x86_quirk_time_init - do any specific initialisations for the system timer.
1087 1088 1089 1090 1091
 *
 * Description:
 *	Must plug the system timer interrupt source at HZ into the IRQ listed
 *	in irq_vectors.h:TIMER_IRQ
 **/
I
Ingo Molnar 已提交
1092
void __init x86_quirk_time_init(void)
1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107
{
	if (x86_quirks->arch_time_init) {
		/*
		 * A nonzero return code does not mean failure, it means
		 * that the architecture quirk does not want any
		 * generic (timer) setup to be performed after this:
		 */
		if (x86_quirks->arch_time_init())
			return;
	}

	irq0.mask = cpumask_of_cpu(0);
	setup_irq(0, &irq0);
}
#endif /* CONFIG_X86_32 */