setup.c 30.3 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
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>
Linus Torvalds's avatar
Linus Torvalds committed
28 29
#include <linux/ioport.h>
#include <linux/acpi.h>
Feng Tang's avatar
Feng Tang committed
30
#include <linux/sfi.h>
Linus Torvalds's avatar
Linus Torvalds committed
31 32 33
#include <linux/apm_bios.h>
#include <linux/initrd.h>
#include <linux/bootmem.h>
34
#include <linux/memblock.h>
Linus Torvalds's avatar
Linus Torvalds committed
35 36 37 38 39 40 41 42
#include <linux/seq_file.h>
#include <linux/console.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>
Linus Torvalds's avatar
Linus Torvalds committed
44
#include <linux/nodemask.h>
45
#include <linux/kexec.h>
46
#include <linux/dmi.h>
Dave Hansen's avatar
Dave Hansen committed
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
#include <linux/dma-contiguous.h>
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/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
#include <linux/jiffies.h>
72

Linus Torvalds's avatar
Linus Torvalds committed
73
#include <video/edid.h>
74

75
#include <asm/mtrr.h>
76
#include <asm/apic.h>
77
#include <asm/realmode.h>
Linus Torvalds's avatar
Linus Torvalds committed
78 79 80
#include <asm/e820.h>
#include <asm/mpspec.h>
#include <asm/setup.h>
Yinghai Lu's avatar
Yinghai Lu committed
81
#include <asm/efi.h>
Ingo Molnar's avatar
Ingo Molnar committed
82 83
#include <asm/timer.h>
#include <asm/i8259.h>
Linus Torvalds's avatar
Linus Torvalds committed
84
#include <asm/sections.h>
85
#include <asm/dmi.h>
Linus Torvalds's avatar
Linus Torvalds committed
86 87
#include <asm/io_apic.h>
#include <asm/ist.h>
88
#include <asm/setup_arch.h>
89
#include <asm/bios_ebda.h>
90
#include <asm/cacheflush.h>
91
#include <asm/processor.h>
Yinghai Lu's avatar
Yinghai Lu committed
92
#include <asm/bugs.h>
Linus Torvalds's avatar
Linus Torvalds committed
93

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

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

#include <asm/percpu.h>
#include <asm/topology.h>
#include <asm/apicdef.h>
110
#include <asm/amd_nb.h>
111
#include <asm/mce.h>
112
#include <asm/alternative.h>
113
#include <asm/prom.h>
114

115
/*
116 117 118 119 120
 * max_low_pfn_mapped: highest direct mapped pfn under 4GB
 * max_pfn_mapped:     highest direct mapped pfn over 4GB
 *
 * The direct mapping only covers E820_RAM regions, so the ranges and gaps are
 * represented by pfn_mapped
121 122 123 124
 */
unsigned long max_low_pfn_mapped;
unsigned long max_pfn_mapped;

125
#ifdef CONFIG_DMI
126
RESERVE_BRK(dmi_alloc, 65536);
127
#endif
128

Ingo Molnar's avatar
Ingo Molnar committed
129

130 131 132
static __initdata unsigned long _brk_start = (unsigned long)__brk_base;
unsigned long _brk_end = (unsigned long)__brk_base;

Ingo Molnar's avatar
Ingo Molnar committed
133 134 135 136 137 138
#ifdef CONFIG_X86_64
int default_cpu_present_to_apicid(int mps_cpu)
{
	return __default_cpu_present_to_apicid(mps_cpu);
}

Thomas Gleixner's avatar
Thomas Gleixner committed
139
int default_check_phys_apicid_present(int phys_apicid)
Ingo Molnar's avatar
Ingo Molnar committed
140
{
Thomas Gleixner's avatar
Thomas Gleixner committed
141
	return __default_check_phys_apicid_present(phys_apicid);
Ingo Molnar's avatar
Ingo Molnar committed
142 143 144
}
#endif

145 146
struct boot_params boot_params;

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

171 172

#ifdef CONFIG_X86_32
Linus Torvalds's avatar
Linus Torvalds committed
173
/* cpu data as detected by the assembly code in head.S */
174 175 176 177
struct cpuinfo_x86 new_cpu_data __cpuinitdata = {
	.wp_works_ok = -1,
	.fdiv_bug = -1,
};
Linus Torvalds's avatar
Linus Torvalds committed
178
/* common cpu data for all cpus */
179 180 181 182
struct cpuinfo_x86 boot_cpu_data __read_mostly = {
	.wp_works_ok = -1,
	.fdiv_bug = -1,
};
183
EXPORT_SYMBOL(boot_cpu_data);
Linus Torvalds's avatar
Linus Torvalds committed
184

185 186
unsigned int def_to_bigsmp;

Linus Torvalds's avatar
Linus Torvalds committed
187 188 189 190 191
/* for MCA, but anyone else can use it if they want */
unsigned int machine_id;
unsigned int machine_submodel_id;
unsigned int BIOS_revision;

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

217 218
/* Boot loader ID and version as integers, for the benefit of proc_dointvec */
int bootloader_type, bootloader_version;
Linus Torvalds's avatar
Linus Torvalds committed
219 220 221 222 223

/*
 * Setup options
 */
struct screen_info screen_info;
224
EXPORT_SYMBOL(screen_info);
Linus Torvalds's avatar
Linus Torvalds committed
225
struct edid_info edid_info;
226
EXPORT_SYMBOL_GPL(edid_info);
Linus Torvalds's avatar
Linus Torvalds committed
227 228 229

extern int root_mountflags;

230
unsigned long saved_video_mode;
Linus Torvalds's avatar
Linus Torvalds committed
231

232
#define RAMDISK_IMAGE_START_MASK	0x07FF
Linus Torvalds's avatar
Linus Torvalds committed
233
#define RAMDISK_PROMPT_FLAG		0x8000
234
#define RAMDISK_LOAD_FLAG		0x4000
Linus Torvalds's avatar
Linus Torvalds committed
235

236
static char __initdata command_line[COMMAND_LINE_SIZE];
237 238 239
#ifdef CONFIG_CMDLINE_BOOL
static char __initdata builtin_cmdline[COMMAND_LINE_SIZE] = CONFIG_CMDLINE;
#endif
Linus Torvalds's avatar
Linus Torvalds committed
240 241 242 243 244 245 246 247 248 249 250

#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.
 *
 */
251
static inline void __init copy_edd(void)
Linus Torvalds's avatar
Linus Torvalds committed
252
{
253 254 255 256 257
     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;
Linus Torvalds's avatar
Linus Torvalds committed
258 259
}
#else
260
static inline void __init copy_edd(void)
Linus Torvalds's avatar
Linus Torvalds committed
261 262 263 264
{
}
#endif

265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283
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;
}

284
#ifdef CONFIG_X86_32
285
static void __init cleanup_highmap(void)
286 287
{
}
288 289
#endif

290 291 292
static void __init reserve_brk(void)
{
	if (_brk_end > _brk_start)
293 294
		memblock_reserve(__pa_symbol(_brk_start),
				 _brk_end - _brk_start);
295 296 297 298 299 300

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

301 302
#ifdef CONFIG_BLK_DEV_INITRD

Yinghai Lu's avatar
Yinghai Lu committed
303 304 305 306
static u64 __init get_ramdisk_image(void)
{
	u64 ramdisk_image = boot_params.hdr.ramdisk_image;

307 308
	ramdisk_image |= (u64)boot_params.ext_ramdisk_image << 32;

Yinghai Lu's avatar
Yinghai Lu committed
309 310 311 312 313 314
	return ramdisk_image;
}
static u64 __init get_ramdisk_size(void)
{
	u64 ramdisk_size = boot_params.hdr.ramdisk_size;

315 316
	ramdisk_size |= (u64)boot_params.ext_ramdisk_size << 32;

Yinghai Lu's avatar
Yinghai Lu committed
317 318 319
	return ramdisk_size;
}

320 321
#define MAX_MAP_CHUNK	(NR_FIX_BTMAPS << PAGE_SHIFT)
static void __init relocate_initrd(void)
322
{
323
	/* Assume only end is not page aligned */
Yinghai Lu's avatar
Yinghai Lu committed
324 325
	u64 ramdisk_image = get_ramdisk_image();
	u64 ramdisk_size  = get_ramdisk_size();
326
	u64 area_size     = PAGE_ALIGN(ramdisk_size);
327
	u64 ramdisk_here;
328 329
	unsigned long slop, clen, mapaddr;
	char *p, *q;
330

331
	/* We need to move the initrd down into directly mapped mem */
332
	ramdisk_here = memblock_find_in_range(0, PFN_PHYS(max_pfn_mapped),
333
						 area_size, PAGE_SIZE);
334

Tejun Heo's avatar
Tejun Heo committed
335
	if (!ramdisk_here)
336 337 338
		panic("Cannot find place for new RAMDISK of size %lld\n",
			 ramdisk_size);

339
	/* Note: this includes all the mem currently occupied by
340
	   the initrd, we rely on that fact to keep the data intact. */
341
	memblock_reserve(ramdisk_here, area_size);
342 343
	initrd_start = ramdisk_here + PAGE_OFFSET;
	initrd_end   = initrd_start + ramdisk_size;
344 345
	printk(KERN_INFO "Allocated new RAMDISK: [mem %#010llx-%#010llx]\n",
			 ramdisk_here, ramdisk_here + ramdisk_size - 1);
346 347 348

	q = (char *)initrd_start;

349
	/* Copy the initrd */
350 351 352 353 354 355
	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;
356
		p = early_memremap(mapaddr, clen+slop);
357
		memcpy(q, p+slop, clen);
358
		early_iounmap(p, clen+slop);
359 360 361 362
		q += clen;
		ramdisk_image += clen;
		ramdisk_size  -= clen;
	}
363

Yinghai Lu's avatar
Yinghai Lu committed
364 365
	ramdisk_image = get_ramdisk_image();
	ramdisk_size  = get_ramdisk_size();
366 367
	printk(KERN_INFO "Move RAMDISK from [mem %#010llx-%#010llx] to"
		" [mem %#010llx-%#010llx]\n",
368 369
		ramdisk_image, ramdisk_image + ramdisk_size - 1,
		ramdisk_here, ramdisk_here + ramdisk_size - 1);
370
}
Yinghai Lu's avatar
Yinghai Lu committed
371

372 373 374
static void __init early_reserve_initrd(void)
{
	/* Assume only end is not page aligned */
Yinghai Lu's avatar
Yinghai Lu committed
375 376
	u64 ramdisk_image = get_ramdisk_image();
	u64 ramdisk_size  = get_ramdisk_size();
377 378 379 380 381 382 383 384
	u64 ramdisk_end   = PAGE_ALIGN(ramdisk_image + ramdisk_size);

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

	memblock_reserve(ramdisk_image, ramdisk_end - ramdisk_image);
}
385 386
static void __init reserve_initrd(void)
{
387
	/* Assume only end is not page aligned */
Yinghai Lu's avatar
Yinghai Lu committed
388 389
	u64 ramdisk_image = get_ramdisk_image();
	u64 ramdisk_size  = get_ramdisk_size();
390
	u64 ramdisk_end   = PAGE_ALIGN(ramdisk_image + ramdisk_size);
391
	u64 mapped_size;
392 393 394 395 396 397 398

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

	initrd_start = 0;

Yinghai Lu's avatar
Yinghai Lu committed
399
	mapped_size = memblock_mem_size(max_pfn_mapped);
400
	if (ramdisk_size >= (mapped_size>>1))
401 402
		panic("initrd too large to handle, "
		       "disabling initrd (%lld needed, %lld available)\n",
403
		       ramdisk_size, mapped_size>>1);
404

405 406
	printk(KERN_INFO "RAMDISK: [mem %#010llx-%#010llx]\n", ramdisk_image,
			ramdisk_end - 1);
407

408
	if (pfn_range_is_mapped(PFN_DOWN(ramdisk_image),
409 410
				PFN_DOWN(ramdisk_end))) {
		/* All are mapped, easy case */
411 412 413 414 415 416
		initrd_start = ramdisk_image + PAGE_OFFSET;
		initrd_end = initrd_start + ramdisk_size;
		return;
	}

	relocate_initrd();
417

418
	memblock_free(ramdisk_image, ramdisk_end - ramdisk_image);
419
}
Yinghai Lu's avatar
Yinghai Lu committed
420
#else
421 422 423
static void __init early_reserve_initrd(void)
{
}
424
static void __init reserve_initrd(void)
Yinghai Lu's avatar
Yinghai Lu committed
425 426
{
}
427 428
#endif /* CONFIG_BLK_DEV_INITRD */

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

	pa_data = boot_params.hdr.setup_data;
	while (pa_data) {
436 437 438 439 440 441 442 443 444 445 446 447
		u32 data_len, map_len;

		map_len = max(PAGE_SIZE - (pa_data & ~PAGE_MASK),
			      (u64)sizeof(struct setup_data));
		data = early_memremap(pa_data, map_len);
		data_len = data->len + sizeof(struct setup_data);
		if (data_len > map_len) {
			early_iounmap(data, map_len);
			data = early_memremap(pa_data, data_len);
			map_len = data_len;
		}

448 449
		switch (data->type) {
		case SETUP_E820_EXT:
450
			parse_e820_ext(data);
451
			break;
452 453
		case SETUP_DTB:
			add_dtb(pa_data);
454 455 456 457 458
			break;
		default:
			break;
		}
		pa_data = data->next;
459
		early_iounmap(data, map_len);
460 461 462
	}
}

463
static void __init e820_reserve_setup_data(void)
464 465 466
{
	struct setup_data *data;
	u64 pa_data;
467
	int found = 0;
468 469 470

	pa_data = boot_params.hdr.setup_data;
	while (pa_data) {
471
		data = early_memremap(pa_data, sizeof(*data));
472 473
		e820_update_range(pa_data, sizeof(*data)+data->len,
			 E820_RAM, E820_RESERVED_KERN);
474
		found = 1;
475 476 477
		pa_data = data->next;
		early_iounmap(data, sizeof(*data));
	}
478 479 480
	if (!found)
		return;

481
	sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
482
	memcpy(&e820_saved, &e820, sizeof(struct e820map));
483 484 485 486
	printk(KERN_INFO "extended physical RAM map:\n");
	e820_print_map("reserve setup_data");
}

487
static void __init memblock_x86_reserve_range_setup_data(void)
488 489 490 491 492 493
{
	struct setup_data *data;
	u64 pa_data;

	pa_data = boot_params.hdr.setup_data;
	while (pa_data) {
494
		data = early_memremap(pa_data, sizeof(*data));
495
		memblock_reserve(pa_data, sizeof(*data) + data->len);
496 497 498 499 500
		pa_data = data->next;
		early_iounmap(data, sizeof(*data));
	}
}

501 502 503 504 505
/*
 * --------- Crashkernel reservation ------------------------------
 */

#ifdef CONFIG_KEXEC
506

507 508 509
/*
 * Keep the crash kernel below this limit.  On 32 bits earlier kernels
 * would limit the kernel to the low 512 MiB due to mapping restrictions.
510
 * On 64bit, old kexec-tools need to under 896MiB.
511 512
 */
#ifdef CONFIG_X86_32
513 514
# define CRASH_KERNEL_ADDR_LOW_MAX	(512 << 20)
# define CRASH_KERNEL_ADDR_HIGH_MAX	(512 << 20)
515
#else
516 517
# define CRASH_KERNEL_ADDR_LOW_MAX	(896UL<<20)
# define CRASH_KERNEL_ADDR_HIGH_MAX	MAXMEM
518 519
#endif

520 521 522 523 524 525 526
static void __init reserve_crashkernel_low(void)
{
#ifdef CONFIG_X86_64
	const unsigned long long alignment = 16<<20;	/* 16M */
	unsigned long long low_base = 0, low_size = 0;
	unsigned long total_low_mem;
	unsigned long long base;
527
	bool auto_set = false;
528 529 530
	int ret;

	total_low_mem = memblock_mem_size(1UL<<(32-PAGE_SHIFT));
531
	/* crashkernel=Y,low */
532 533
	ret = parse_crashkernel_low(boot_command_line, total_low_mem,
						&low_size, &base);
534 535 536 537 538 539 540 541 542 543 544
	if (ret != 0) {
		/*
		 * two parts from lib/swiotlb.c:
		 *	swiotlb size: user specified with swiotlb= or default.
		 *	swiotlb overflow buffer: now is hardcoded to 32k.
		 *		We round it to 8M for other buffers that
		 *		may need to stay low too.
		 */
		low_size = swiotlb_size_or_default() + (8UL<<20);
		auto_set = true;
	} else {
545
		/* passed with crashkernel=0,low ? */
546 547 548
		if (!low_size)
			return;
	}
549 550 551 552 553

	low_base = memblock_find_in_range(low_size, (1ULL<<32),
					low_size, alignment);

	if (!low_base) {
554 555
		if (!auto_set)
			pr_info("crashkernel low reservation failed - No suitable area found.\n");
556 557 558 559 560 561 562 563 564 565 566 567

		return;
	}

	memblock_reserve(low_base, low_size);
	pr_info("Reserving %ldMB of low memory at %ldMB for crashkernel (System low RAM: %ldMB)\n",
			(unsigned long)(low_size >> 20),
			(unsigned long)(low_base >> 20),
			(unsigned long)(total_low_mem >> 20));
	crashk_low_res.start = low_base;
	crashk_low_res.end   = low_base + low_size - 1;
	insert_resource(&iomem_resource, &crashk_low_res);
568
#endif
569
}
570

571
static void __init reserve_crashkernel(void)
572
{
573
	const unsigned long long alignment = 16<<20;	/* 16M */
574 575
	unsigned long long total_mem;
	unsigned long long crash_size, crash_base;
576
	bool high = false;
577 578
	int ret;

579
	total_mem = memblock_phys_mem_size();
580

581
	/* crashkernel=XM */
582 583
	ret = parse_crashkernel(boot_command_line, total_mem,
			&crash_size, &crash_base);
584
	if (ret != 0 || crash_size <= 0) {
585
		/* crashkernel=X,high */
586 587 588 589 590 591
		ret = parse_crashkernel_high(boot_command_line, total_mem,
				&crash_size, &crash_base);
		if (ret != 0 || crash_size <= 0)
			return;
		high = true;
	}
592 593 594

	/* 0 means: find the address automatically */
	if (crash_base <= 0) {
595
		/*
596
		 *  kexec want bzImage is below CRASH_KERNEL_ADDR_MAX
597 598
		 */
		crash_base = memblock_find_in_range(alignment,
599 600 601
					high ? CRASH_KERNEL_ADDR_HIGH_MAX :
					       CRASH_KERNEL_ADDR_LOW_MAX,
					crash_size, alignment);
602

Tejun Heo's avatar
Tejun Heo committed
603
		if (!crash_base) {
604
			pr_info("crashkernel reservation failed - No suitable area found.\n");
605 606
			return;
		}
607

608
	} else {
609 610
		unsigned long long start;

611 612
		start = memblock_find_in_range(crash_base,
				 crash_base + crash_size, crash_size, 1<<20);
613 614
		if (start != crash_base) {
			pr_info("crashkernel reservation failed - memory is in use.\n");
615 616
			return;
		}
617
	}
618
	memblock_reserve(crash_base, crash_size);
619

620 621 622 623 624
	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));
625

626 627 628
	crashk_res.start = crash_base;
	crashk_res.end   = crash_base + crash_size - 1;
	insert_resource(&iomem_resource, &crashk_res);
629 630 631

	if (crash_base >= (1ULL<<32))
		reserve_crashkernel_low();
632 633
}
#else
634
static void __init reserve_crashkernel(void)
635 636 637 638
{
}
#endif

639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661
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 }
};

662
void __init reserve_standard_io_resources(void)
663 664 665 666 667 668 669 670 671
{
	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]);

}

672 673 674 675 676 677 678
static __init void reserve_ibft_region(void)
{
	unsigned long addr, size = 0;

	addr = find_ibft_region(&size);

	if (size)
679
		memblock_reserve(addr, size);
680 681
}

682 683
static bool __init snb_gfx_workaround_needed(void)
{
684
#ifdef CONFIG_PCI
685 686
	int i;
	u16 vendor, devid;
687
	static const __initconst u16 snb_ids[] = {
688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708
		0x0102,
		0x0112,
		0x0122,
		0x0106,
		0x0116,
		0x0126,
		0x010a,
	};

	/* Assume no if something weird is going on with PCI */
	if (!early_pci_allowed())
		return false;

	vendor = read_pci_config_16(0, 2, 0, PCI_VENDOR_ID);
	if (vendor != 0x8086)
		return false;

	devid = read_pci_config_16(0, 2, 0, PCI_DEVICE_ID);
	for (i = 0; i < ARRAY_SIZE(snb_ids); i++)
		if (devid == snb_ids[i])
			return true;
709
#endif
710 711 712 713 714 715 716 717 718 719

	return false;
}

/*
 * Sandy Bridge graphics has trouble with certain ranges, exclude
 * them from allocation.
 */
static void __init trim_snb_memory(void)
{
720
	static const __initconst unsigned long bad_pages[] = {
721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758
		0x20050000,
		0x20110000,
		0x20130000,
		0x20138000,
		0x40004000,
	};
	int i;

	if (!snb_gfx_workaround_needed())
		return;

	printk(KERN_DEBUG "reserving inaccessible SNB gfx pages\n");

	/*
	 * Reserve all memory below the 1 MB mark that has not
	 * already been reserved.
	 */
	memblock_reserve(0, 1<<20);
	
	for (i = 0; i < ARRAY_SIZE(bad_pages); i++) {
		if (memblock_reserve(bad_pages[i], PAGE_SIZE))
			printk(KERN_WARNING "failed to reserve 0x%08lx\n",
			       bad_pages[i]);
	}
}

/*
 * Here we put platform-specific memory range workarounds, i.e.
 * memory known to be corrupt or otherwise in need to be reserved on
 * specific platforms.
 *
 * If this gets used more widely it could use a real dispatch mechanism.
 */
static void __init trim_platform_memory_ranges(void)
{
	trim_snb_memory();
}

759 760 761 762 763 764
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.
765 766 767
	 *
	 * This typically reserves additional memory (64KiB by default)
	 * since some BIOSes are known to corrupt low memory.  See the
768
	 * Kconfig help text for X86_RESERVE_LOW.
769
	 */
770
	e820_update_range(0, PAGE_SIZE, E820_RAM, E820_RESERVED);
771

772 773 774 775 776 777
	/*
	 * 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);
778

779 780 781
	sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
}

782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802
/* called before trim_bios_range() to spare extra sanitize */
static void __init e820_add_kernel_range(void)
{
	u64 start = __pa_symbol(_text);
	u64 size = __pa_symbol(_end) - start;

	/*
	 * Complain if .text .data and .bss are not marked as E820_RAM and
	 * attempt to fix it by adding the range. We may have a confused BIOS,
	 * or the user may have used memmap=exactmap or memmap=xxM$yyM to
	 * exclude kernel range. If we really are running on top non-RAM,
	 * we will crash later anyways.
	 */
	if (e820_all_mapped(start, start + size, E820_RAM))
		return;

	pr_warn(".text .data .bss are not marked as E820_RAM!\n");
	e820_remove_range(start, size, E820_RAM, 0);
	e820_add_region(start, size, E820_RAM);
}

803 804
static unsigned reserve_low = CONFIG_X86_RESERVE_LOW << 10;

805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826
static int __init parse_reservelow(char *p)
{
	unsigned long long size;

	if (!p)
		return -EINVAL;

	size = memparse(p, &p);

	if (size < 4096)
		size = 4096;

	if (size > 640*1024)
		size = 640*1024;

	reserve_low = size;

	return 0;
}

early_param("reservelow", parse_reservelow);

827 828 829 830 831
static void __init trim_low_memory_range(void)
{
	memblock_reserve(0, ALIGN(reserve_low, PAGE_SIZE));
}
	
Linus Torvalds's avatar
Linus Torvalds committed
832 833 834 835 836 837 838
/*
 * 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.
 */
839 840 841 842 843 844
/*
 * setup_arch - architecture-specific boot-time initializations
 *
 * Note: On x86_64, fixmaps are ready for use even before this is called.
 */

Linus Torvalds's avatar
Linus Torvalds committed
845 846
void __init setup_arch(char **cmdline_p)
{
847 848 849
	memblock_reserve(__pa_symbol(_text),
			 (unsigned long)__bss_stop - (unsigned long)_text);

850 851
	early_reserve_initrd();

852 853 854 855 856 857
	/*
	 * At this point everything still needed from the boot loader
	 * or BIOS or kernel text should be early reserved or marked not
	 * RAM in e820. All other memory is free game.
	 */

858
#ifdef CONFIG_X86_32
Linus Torvalds's avatar
Linus Torvalds committed
859
	memcpy(&boot_cpu_data, &new_cpu_data, sizeof(new_cpu_data));
Ingo Molnar's avatar
Ingo Molnar committed
860
	visws_early_detect();
861 862 863 864 865 866 867 868 869 870 871

	/*
	 * copy kernel address range established so far and switch
	 * to the proper swapper page table
	 */
	clone_pgd_range(swapper_pg_dir     + KERNEL_PGD_BOUNDARY,
			initial_page_table + KERNEL_PGD_BOUNDARY,
			KERNEL_PGD_PTRS);

	load_cr3(swapper_pg_dir);
	__flush_tlb_all();
872 873 874
#else
	printk(KERN_INFO "Command line: %s\n", boot_command_line);
#endif
Linus Torvalds's avatar
Linus Torvalds committed
875

876 877 878 879
	/*
	 * If we have OLPC OFW, we might end up relocating the fixmap due to
	 * reserve_top(), so do this before touching the ioremap area.
	 */
880 881
	olpc_ofw_detect();

882
	early_trap_init();
883
	early_cpu_init();
884 885
	early_ioremap_init();

886 887
	setup_olpc_ofw_pgd();

888 889 890
	ROOT_DEV = old_decode_dev(boot_params.hdr.root_dev);
	screen_info = boot_params.screen_info;
	edid_info = boot_params.edid_info;
891
#ifdef CONFIG_X86_32
892 893
	apm_info.bios = boot_params.apm_bios_info;
	ist_info = boot_params.ist_info;
894
	if (boot_params.sys_desc_table.length != 0) {
895 896 897
		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];
Linus Torvalds's avatar
Linus Torvalds committed
898
	}
899 900
#endif
	saved_video_mode = boot_params.hdr.vid_mode;
901
	bootloader_type = boot_params.hdr.type_of_loader;
902 903 904 905 906 907
	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;
Linus Torvalds's avatar
Linus Torvalds committed
908 909

#ifdef CONFIG_BLK_DEV_RAM
910 911 912
	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);
Linus Torvalds's avatar
Linus Torvalds committed
913
#endif
914 915
#ifdef CONFIG_EFI
	if (!strncmp((char *)&boot_params.efi_info.efi_loader_signature,
916
		     "EL32", 4)) {
917
		set_bit(EFI_BOOT, &x86_efi_facility);
918 919
	} else if (!strncmp((char *)&boot_params.efi_info.efi_loader_signature,
		     "EL64", 4)) {
920 921
		set_bit(EFI_BOOT, &x86_efi_facility);
		set_bit(EFI_64BIT, &x86_efi_facility);
922
	}
923 924 925

	if (efi_enabled(EFI_BOOT))
		efi_memblock_x86_reserve_range();
926 927
#endif

928
	x86_init.oem.arch_setup();
929

930
	iomem_resource.end = (1ULL << boot_cpu_data.x86_phys_bits) - 1;
931
	setup_memory_map();
932
	parse_setup_data();
933 934
	/* update the e820_saved too */
	e820_reserve_setup_data();
935

Linus Torvalds's avatar
Linus Torvalds committed
936 937
	copy_edd();

938
	if (!boot_params.hdr.root_flags)
Linus Torvalds's avatar
Linus Torvalds committed
939 940 941 942
		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;
943
	init_mm.brk = _brk_end;
Linus Torvalds's avatar
Linus Torvalds committed
944

945 946 947 948 949 950
	code_resource.start = __pa_symbol(_text);
	code_resource.end = __pa_symbol(_etext)-1;
	data_resource.start = __pa_symbol(_etext);
	data_resource.end = __pa_symbol(_edata)-1;
	bss_resource.start = __pa_symbol(__bss_start);
	bss_resource.end = __pa_symbol(__bss_stop)-1;
Linus Torvalds's avatar
Linus Torvalds committed
951

952 953 954 955 956 957 958 959 960 961 962 963 964
#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

965 966 967 968
	strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE);
	*cmdline_p = command_line;

	/*
969 970 971 972 973
	 * 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.
974
	 */
975
	x86_configure_nx();
976 977 978

	parse_early_param();

979
	x86_report_nx();
980

981
	/* after early param, so could get panic from serial */
982
	memblock_x86_reserve_range_setup_data();
983

984
	if (acpi_mps_check()) {
Ingo Molnar's avatar
Ingo Molnar committed
985
#ifdef CONFIG_X86_LOCAL_APIC
986
		disable_apic = 1;
Ingo Molnar's avatar
Ingo Molnar committed
987
#endif
988
		setup_clear_cpu_cap(X86_FEATURE_APIC);
989 990
	}

991 992 993 994 995
#ifdef CONFIG_PCI
	if (pci_early_dump_regs)
		early_dump_pci_devices();
#endif

996
	finish_e820_parsing();
997

998
	if (efi_enabled(EFI_BOOT))
Brian Maly's avatar
Brian Maly committed
999 1000
		efi_init();

1001 1002
	dmi_scan_machine();

1003 1004 1005 1006
	/*
	 * VMware detection requires dmi to be available, so this
	 * needs to be done after dmi_scan_machine, for the BP.
	 */
1007
	init_hypervisor_platform();
1008

1009
	x86_init.resources.probe_roms();
1010 1011 1012 1013 1014 1015

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

1016
	e820_add_kernel_range();
1017
	trim_bios_range();
1018
#ifdef CONFIG_X86_32
Yinghai Lu's avatar
Yinghai Lu committed
1019 1020 1021 1022 1023 1024 1025
	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");
	}
1026 1027 1028
#else
	early_gart_iommu_check();
#endif
Yinghai Lu's avatar
Yinghai Lu committed
1029

1030 1031 1032 1033
	/*
	 * partially used pages are not usable - thus
	 * we are rounding upwards:
	 */
1034
	max_pfn = e820_end_of_ram_pfn();
1035

1036 1037
	/* update e820 for memory not covered by WB MTRRs */
	mtrr_bp_init();
1038
	if (mtrr_trim_uncached_memory(max_pfn))
1039
		max_pfn = e820_end_of_ram_pfn();
1040

1041
#ifdef CONFIG_X86_32
1042
	/* max_low_pfn get updated here */
1043
	find_low_pfn_range();
1044 1045 1046
#else
	num_physpages = max_pfn;

Yinghai Lu's avatar
Yinghai Lu committed
1047
	check_x2apic();
1048 1049 1050

	/* How many end-of-memory variables you have, grandma! */
	/* need this before calling reserve_initrd */
1051 1052 1053 1054 1055
	if (max_pfn > (1UL<<(32 - PAGE_SHIFT)))
		max_low_pfn = e820_end_of_low_ram_pfn();
	else
		max_low_pfn = max_pfn;

1056
	high_memory = (void *)__va(max_pfn * PAGE_SIZE - 1) + 1;
1057 1058
#endif

1059 1060 1061 1062 1063
	/*
	 * Find and reserve possible boot-time SMP configuration:
	 */
	find_smp_config();

1064 1065
	reserve_ibft_region();

1066 1067
	early_alloc_pgt_buf();

1068 1069 1070 1071 1072 1073 1074
	/*
	 * Need to conclude brk, before memblock_x86_fill()
	 *  it could use memblock_find_in_range, could overlap with
	 *  brk area.
	 */
	reserve_brk();

1075 1076
	cleanup_highmap();

1077
	memblock.current_limit = ISA_END_ADDRESS;
1078 1079
	memblock_x86_fill();

1080 1081 1082 1083
	/*
	 * The EFI specification says that boot service code won't be called
	 * after ExitBootServices(). This is, in fact, a lie.
	 */
1084
	if (efi_enabled(EFI_MEMMAP))
1085 1086
		efi_reserve_boot_services();

1087 1088 1089 1090 1091 1092 1093
	/* preallocate 4k for mptable mpc */
	early_reserve_e820_mpc_new();

#ifdef CONFIG_X86_CHECK_BIOS_CORRUPTION
	setup_bios_corruption_check();
#endif

1094
#ifdef CONFIG_X86_32
1095 1096
	printk(KERN_DEBUG "initial memory mapped: [mem 0x00000000-%#010lx]\n",
			(max_pfn_mapped<<PAGE_SHIFT) - 1);
1097
#endif