setup.c 27.8 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
#include <linux/apm_bios.h>
#include <linux/initrd.h>
#include <linux/bootmem.h>
34
#include <linux/memblock.h>
L
Linus Torvalds 已提交
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>
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
#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

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

75
#include <asm/mtrr.h>
76
#include <asm/apic.h>
77
#include <asm/realmode.h>
L
Linus Torvalds 已提交
78 79 80
#include <asm/e820.h>
#include <asm/mpspec.h>
#include <asm/setup.h>
Y
Yinghai Lu 已提交
81
#include <asm/efi.h>
I
Ingo Molnar 已提交
82 83
#include <asm/timer.h>
#include <asm/i8259.h>
L
Linus Torvalds 已提交
84
#include <asm/sections.h>
85
#include <asm/dmi.h>
L
Linus Torvalds 已提交
86 87
#include <asm/io_apic.h>
#include <asm/ist.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
#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>
Y
Yinghai Lu 已提交
111 112 113
#ifdef CONFIG_X86_64
#include <asm/numa_64.h>
#endif
114
#include <asm/mce.h>
115
#include <asm/alternative.h>
116
#include <asm/prom.h>
117

118 119 120 121 122 123 124 125
/*
 * 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;

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

I
Ingo Molnar 已提交
130

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

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

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

146 147
struct boot_params boot_params;

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
L
Linus Torvalds 已提交
174
/* cpu data as detected by the assembly code in head.S */
175
struct cpuinfo_x86 new_cpu_data __cpuinitdata = {0, 0, 0, 0, -1, 1, 0, 0, -1};
L
Linus Torvalds 已提交
176
/* common cpu data for all cpus */
177
struct cpuinfo_x86 boot_cpu_data __read_mostly = {0, 0, 0, 0, -1, 1, 0, 0, -1};
178
EXPORT_SYMBOL(boot_cpu_data);
L
Linus Torvalds 已提交
179

180 181
unsigned int def_to_bigsmp;

L
Linus Torvalds 已提交
182 183 184 185 186
/* for MCA, but anyone else can use it if they want */
unsigned int machine_id;
unsigned int machine_submodel_id;
unsigned int BIOS_revision;

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

212 213
/* Boot loader ID and version as integers, for the benefit of proc_dointvec */
int bootloader_type, bootloader_version;
L
Linus Torvalds 已提交
214 215 216 217 218

/*
 * Setup options
 */
struct screen_info screen_info;
219
EXPORT_SYMBOL(screen_info);
L
Linus Torvalds 已提交
220
struct edid_info edid_info;
221
EXPORT_SYMBOL_GPL(edid_info);
L
Linus Torvalds 已提交
222 223 224

extern int root_mountflags;

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

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

231
static char __initdata command_line[COMMAND_LINE_SIZE];
232 233 234
#ifdef CONFIG_CMDLINE_BOOL
static char __initdata builtin_cmdline[COMMAND_LINE_SIZE] = CONFIG_CMDLINE;
#endif
L
Linus Torvalds 已提交
235 236 237 238 239 240 241 242 243 244 245

#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.
 *
 */
246
static inline void __init copy_edd(void)
L
Linus Torvalds 已提交
247
{
248 249 250 251 252
     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 已提交
253 254
}
#else
255
static inline void __init copy_edd(void)
L
Linus Torvalds 已提交
256 257 258 259
{
}
#endif

260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278
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;
}

279 280 281 282 283 284 285 286 287 288 289 290
#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)
{
}
291
static void __init cleanup_highmap(void)
292 293
{
}
294 295
#endif

296 297 298
static void __init reserve_brk(void)
{
	if (_brk_end > _brk_start)
299 300
		memblock_reserve(__pa(_brk_start),
				 __pa(_brk_end) - __pa(_brk_start));
301 302 303 304 305 306

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

307 308
#ifdef CONFIG_BLK_DEV_INITRD

309 310
#define MAX_MAP_CHUNK	(NR_FIX_BTMAPS << PAGE_SHIFT)
static void __init relocate_initrd(void)
311
{
312
	/* Assume only end is not page aligned */
313 314
	u64 ramdisk_image = boot_params.hdr.ramdisk_image;
	u64 ramdisk_size  = boot_params.hdr.ramdisk_size;
315
	u64 area_size     = PAGE_ALIGN(ramdisk_size);
316
	u64 end_of_lowmem = max_low_pfn_mapped << PAGE_SHIFT;
317
	u64 ramdisk_here;
318 319
	unsigned long slop, clen, mapaddr;
	char *p, *q;
320 321

	/* We need to move the initrd down into lowmem */
322
	ramdisk_here = memblock_find_in_range(0, end_of_lowmem, area_size,
323
					 PAGE_SIZE);
324

T
Tejun Heo 已提交
325
	if (!ramdisk_here)
326 327 328
		panic("Cannot find place for new RAMDISK of size %lld\n",
			 ramdisk_size);

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

	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;
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
	/* high pages is not converted by early_res_to_bootmem */
364 365
	ramdisk_image = boot_params.hdr.ramdisk_image;
	ramdisk_size  = boot_params.hdr.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
}
Y
Yinghai Lu 已提交
371

372 373
static void __init reserve_initrd(void)
{
374
	/* Assume only end is not page aligned */
375 376
	u64 ramdisk_image = boot_params.hdr.ramdisk_image;
	u64 ramdisk_size  = boot_params.hdr.ramdisk_size;
377
	u64 ramdisk_end   = PAGE_ALIGN(ramdisk_image + ramdisk_size);
378
	u64 end_of_lowmem = max_low_pfn_mapped << PAGE_SHIFT;
379 380 381 382 383 384 385 386

	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)) {
387 388 389
		panic("initrd too large to handle, "
		       "disabling initrd (%lld needed, %lld available)\n",
		       ramdisk_size, end_of_lowmem>>1);
390 391
	}

392 393
	printk(KERN_INFO "RAMDISK: [mem %#010llx-%#010llx]\n", ramdisk_image,
			ramdisk_end - 1);
394 395 396 397 398 399 400 401 402 403 404 405 406 407


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

409
	memblock_free(ramdisk_image, ramdisk_end - ramdisk_image);
410
}
Y
Yinghai Lu 已提交
411
#else
412
static void __init reserve_initrd(void)
Y
Yinghai Lu 已提交
413 414
{
}
415 416
#endif /* CONFIG_BLK_DEV_INITRD */

417
static void __init parse_setup_data(void)
418 419 420 421 422 423 424 425
{
	struct setup_data *data;
	u64 pa_data;

	if (boot_params.hdr.version < 0x0209)
		return;
	pa_data = boot_params.hdr.setup_data;
	while (pa_data) {
426 427 428 429 430 431 432 433 434 435 436 437
		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;
		}

438 439
		switch (data->type) {
		case SETUP_E820_EXT:
440
			parse_e820_ext(data);
441
			break;
442 443
		case SETUP_DTB:
			add_dtb(pa_data);
444 445 446 447 448
			break;
		default:
			break;
		}
		pa_data = data->next;
449
		early_iounmap(data, map_len);
450 451 452
	}
}

453
static void __init e820_reserve_setup_data(void)
454 455 456
{
	struct setup_data *data;
	u64 pa_data;
457
	int found = 0;
458 459 460 461 462

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

473
	sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
474
	memcpy(&e820_saved, &e820, sizeof(struct e820map));
475 476 477 478
	printk(KERN_INFO "extended physical RAM map:\n");
	e820_print_map("reserve setup_data");
}

479
static void __init memblock_x86_reserve_range_setup_data(void)
480 481 482 483 484 485 486 487
{
	struct setup_data *data;
	u64 pa_data;

	if (boot_params.hdr.version < 0x0209)
		return;
	pa_data = boot_params.hdr.setup_data;
	while (pa_data) {
488
		data = early_memremap(pa_data, sizeof(*data));
489
		memblock_reserve(pa_data, sizeof(*data) + data->len);
490 491 492 493 494
		pa_data = data->next;
		early_iounmap(data, sizeof(*data));
	}
}

495 496 497 498 499
/*
 * --------- Crashkernel reservation ------------------------------
 */

#ifdef CONFIG_KEXEC
500

501 502 503 504 505 506 507 508 509 510 511 512
/*
 * 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.
 * On 64 bits, kexec-tools currently limits us to 896 MiB; increase this
 * limit once kexec-tools are fixed.
 */
#ifdef CONFIG_X86_32
# define CRASH_KERNEL_ADDR_MAX	(512 << 20)
#else
# define CRASH_KERNEL_ADDR_MAX	(896 << 20)
#endif

513
static void __init reserve_crashkernel(void)
514 515 516 517 518
{
	unsigned long long total_mem;
	unsigned long long crash_size, crash_base;
	int ret;

519
	total_mem = memblock_phys_mem_size();
520 521 522

	ret = parse_crashkernel(boot_command_line, total_mem,
			&crash_size, &crash_base);
523 524 525 526 527
	if (ret != 0 || crash_size <= 0)
		return;

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

530
		/*
531
		 *  kexec want bzImage is below CRASH_KERNEL_ADDR_MAX
532 533
		 */
		crash_base = memblock_find_in_range(alignment,
534
			       CRASH_KERNEL_ADDR_MAX, crash_size, alignment);
535

T
Tejun Heo 已提交
536
		if (!crash_base) {
537
			pr_info("crashkernel reservation failed - No suitable area found.\n");
538 539
			return;
		}
540
	} else {
541 542
		unsigned long long start;

543 544
		start = memblock_find_in_range(crash_base,
				 crash_base + crash_size, crash_size, 1<<20);
545 546
		if (start != crash_base) {
			pr_info("crashkernel reservation failed - memory is in use.\n");
547 548
			return;
		}
549
	}
550
	memblock_reserve(crash_base, crash_size);
551

552 553 554 555 556
	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));
557

558 559 560
	crashk_res.start = crash_base;
	crashk_res.end   = crash_base + crash_size - 1;
	insert_resource(&iomem_resource, &crashk_res);
561 562
}
#else
563
static void __init reserve_crashkernel(void)
564 565 566 567
{
}
#endif

568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590
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 }
};

591
void __init reserve_standard_io_resources(void)
592 593 594 595 596 597 598 599 600
{
	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]);

}

601 602 603 604 605 606 607
static __init void reserve_ibft_region(void)
{
	unsigned long addr, size = 0;

	addr = find_ibft_region(&size);

	if (size)
608
		memblock_reserve(addr, size);
609 610
}

611
static unsigned reserve_low = CONFIG_X86_RESERVE_LOW << 10;
612

613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687
static bool __init snb_gfx_workaround_needed(void)
{
	int i;
	u16 vendor, devid;
	static const u16 snb_ids[] = {
		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;

	return false;
}

/*
 * Sandy Bridge graphics has trouble with certain ranges, exclude
 * them from allocation.
 */
static void __init trim_snb_memory(void)
{
	static const unsigned long bad_pages[] = {
		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();
}

688 689 690 691 692 693
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.
694 695 696
	 *
	 * This typically reserves additional memory (64KiB by default)
	 * since some BIOSes are known to corrupt low memory.  See the
697
	 * Kconfig help text for X86_RESERVE_LOW.
698
	 */
699
	e820_update_range(0, ALIGN(reserve_low, PAGE_SIZE),
700 701
			  E820_RAM, E820_RESERVED);

702 703 704 705 706 707
	/*
	 * 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);
708

709 710 711
	sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
}

712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733
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);

L
Linus Torvalds 已提交
734 735 736 737 738 739 740
/*
 * 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.
 */
741 742 743 744 745 746
/*
 * setup_arch - architecture-specific boot-time initializations
 *
 * Note: On x86_64, fixmaps are ready for use even before this is called.
 */

L
Linus Torvalds 已提交
747 748
void __init setup_arch(char **cmdline_p)
{
749
#ifdef CONFIG_X86_32
L
Linus Torvalds 已提交
750
	memcpy(&boot_cpu_data, &new_cpu_data, sizeof(new_cpu_data));
I
Ingo Molnar 已提交
751
	visws_early_detect();
752 753 754 755 756 757 758 759 760 761 762

	/*
	 * 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();
763 764 765
#else
	printk(KERN_INFO "Command line: %s\n", boot_command_line);
#endif
L
Linus Torvalds 已提交
766

767 768 769 770
	/*
	 * If we have OLPC OFW, we might end up relocating the fixmap due to
	 * reserve_top(), so do this before touching the ioremap area.
	 */
771 772
	olpc_ofw_detect();

773
	early_trap_init();
774
	early_cpu_init();
775 776
	early_ioremap_init();

777 778
	setup_olpc_ofw_pgd();

779 780 781
	ROOT_DEV = old_decode_dev(boot_params.hdr.root_dev);
	screen_info = boot_params.screen_info;
	edid_info = boot_params.edid_info;
782
#ifdef CONFIG_X86_32
783 784
	apm_info.bios = boot_params.apm_bios_info;
	ist_info = boot_params.ist_info;
785
	if (boot_params.sys_desc_table.length != 0) {
786 787 788
		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 已提交
789
	}
790 791
#endif
	saved_video_mode = boot_params.hdr.vid_mode;
792
	bootloader_type = boot_params.hdr.type_of_loader;
793 794 795 796 797 798
	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 已提交
799 800

#ifdef CONFIG_BLK_DEV_RAM
801 802 803
	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 已提交
804
#endif
805 806
#ifdef CONFIG_EFI
	if (!strncmp((char *)&boot_params.efi_info.efi_loader_signature,
807
		     "EL32", 4)) {
808
		efi_enabled = 1;
809 810 811 812 813
		efi_64bit = false;
	} else if (!strncmp((char *)&boot_params.efi_info.efi_loader_signature,
		     "EL64", 4)) {
		efi_enabled = 1;
		efi_64bit = true;
814
	}
815 816
	if (efi_enabled && efi_memblock_x86_reserve_range())
		efi_enabled = 0;
817 818
#endif

819
	x86_init.oem.arch_setup();
820

821
	iomem_resource.end = (1ULL << boot_cpu_data.x86_phys_bits) - 1;
822
	setup_memory_map();
823
	parse_setup_data();
824 825
	/* update the e820_saved too */
	e820_reserve_setup_data();
826

L
Linus Torvalds 已提交
827 828
	copy_edd();

829
	if (!boot_params.hdr.root_flags)
L
Linus Torvalds 已提交
830 831 832 833
		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;
834
	init_mm.brk = _brk_end;
L
Linus Torvalds 已提交
835 836 837 838 839

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

843 844 845 846 847 848 849 850 851 852 853 854 855
#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

856 857 858 859
	strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE);
	*cmdline_p = command_line;

	/*
860 861 862 863 864
	 * 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.
865
	 */
866
	x86_configure_nx();
867 868 869

	parse_early_param();

870
	x86_report_nx();
871

872
	/* after early param, so could get panic from serial */
873
	memblock_x86_reserve_range_setup_data();
874

875
	if (acpi_mps_check()) {
I
Ingo Molnar 已提交
876
#ifdef CONFIG_X86_LOCAL_APIC
877
		disable_apic = 1;
I
Ingo Molnar 已提交
878
#endif
879
		setup_clear_cpu_cap(X86_FEATURE_APIC);
880 881
	}

882 883 884 885 886
#ifdef CONFIG_PCI
	if (pci_early_dump_regs)
		early_dump_pci_devices();
#endif

887
	finish_e820_parsing();
888

B
Brian Maly 已提交
889 890 891
	if (efi_enabled)
		efi_init();

892 893
	dmi_scan_machine();

894 895 896 897
	/*
	 * VMware detection requires dmi to be available, so this
	 * needs to be done after dmi_scan_machine, for the BP.
	 */
898
	init_hypervisor_platform();
899

900
	x86_init.resources.probe_roms();
901 902 903 904 905 906

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

907
	trim_bios_range();
908
#ifdef CONFIG_X86_32
Y
Yinghai Lu 已提交
909 910 911 912 913 914 915
	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");
	}
916 917 918
#else
	early_gart_iommu_check();
#endif
Y
Yinghai Lu 已提交
919

920 921 922 923
	/*
	 * partially used pages are not usable - thus
	 * we are rounding upwards:
	 */
924
	max_pfn = e820_end_of_ram_pfn();
925

926 927
	/* update e820 for memory not covered by WB MTRRs */
	mtrr_bp_init();
928
	if (mtrr_trim_uncached_memory(max_pfn))
929
		max_pfn = e820_end_of_ram_pfn();
930

931
#ifdef CONFIG_X86_32
932
	/* max_low_pfn get updated here */
933
	find_low_pfn_range();
934 935 936
#else
	num_physpages = max_pfn;

Y
Yinghai Lu 已提交
937
	check_x2apic();
938 939 940

	/* How many end-of-memory variables you have, grandma! */
	/* need this before calling reserve_initrd */
941 942 943 944 945
	if (max_pfn > (1UL<<(32 - PAGE_SHIFT)))
		max_low_pfn = e820_end_of_low_ram_pfn();
	else
		max_low_pfn = max_pfn;

946
	high_memory = (void *)__va(max_pfn * PAGE_SIZE - 1) + 1;
947 948
#endif

949 950 951 952 953
	/*
	 * Find and reserve possible boot-time SMP configuration:
	 */
	find_smp_config();

954 955
	reserve_ibft_region();

956 957 958 959 960 961 962
	/*
	 * Need to conclude brk, before memblock_x86_fill()
	 *  it could use memblock_find_in_range, could overlap with
	 *  brk area.
	 */
	reserve_brk();

963 964
	cleanup_highmap();

965 966 967
	memblock.current_limit = get_max_mapped();
	memblock_x86_fill();

968 969 970 971 972 973 974
	/*
	 * The EFI specification says that boot service code won't be called
	 * after ExitBootServices(). This is, in fact, a lie.
	 */
	if (efi_enabled)
		efi_reserve_boot_services();

975 976 977 978 979 980 981
	/* preallocate 4k for mptable mpc */
	early_reserve_e820_mpc_new();

#ifdef CONFIG_X86_CHECK_BIOS_CORRUPTION
	setup_bios_corruption_check();
#endif

982 983
	printk(KERN_DEBUG "initial memory mapped: [mem 0x00000000-%#010lx]\n",
			(max_pfn_mapped<<PAGE_SHIFT) - 1);
984

985
	setup_real_mode();
986

987 988
	trim_platform_memory_ranges();

989 990
	init_gbpages();

991
	/* max_pfn_mapped is updated here */
992 993 994
	max_low_pfn_mapped = init_memory_mapping(0, max_low_pfn<<PAGE_SHIFT);
	max_pfn_mapped = max_low_pfn_mapped;

995 996
#ifdef CONFIG_X86_64
	if (max_pfn > max_low_pfn) {
997
		int i;
998 999
		unsigned long start, end;
		unsigned long start_pfn, end_pfn;
1000

1001 1002
		for_each_mem_pfn_range(i, MAX_NUMNODES, &start_pfn, &end_pfn,
							 NULL) {
1003

1004 1005
			end = PFN_PHYS(end_pfn);
			if (end <= (1UL<<32))
1006 1007
				continue;

1008
			start = PFN_PHYS(start_pfn);
1009
			max_pfn_mapped = init_memory_mapping(
1010
						max((1UL<<32), start), end);
1011 1012
		}

1013 1014 1015 1016
		/* can we preseve max_low_pfn ?*/
		max_low_pfn = max_pfn;
	}
#endif
1017
	memblock.current_limit = get_max_mapped();
1018
	dma_contiguous_reserve(0);
1019

1020 1021 1022 1023 1024 1025 1026 1027
	/*
	 * 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
1028 1029
	/* Allocate bigger log buffer */
	setup_log_buf(1);
1030

1031 1032
	reserve_initrd();

D
David Rientjes 已提交
1033
#if defined(CONFIG_ACPI) && defined(CONFIG_BLK_DEV_INITRD)
1034
	acpi_initrd_override((void *)initrd_start, initrd_end - initrd_start);
D
David Rientjes 已提交
1035
#endif
1036

1037 1038
	reserve_crashkernel();

1039 1040
	vsmp_init();

1041 1042 1043 1044 1045 1046 1047
	io_delay_init();

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

1048 1049
	early_acpi_boot_init();

1050
	initmem_init();
1051
	memblock_find_dma_reserve();
1052

1053
#ifdef CONFIG_KVM_GUEST
1054 1055 1056
	kvmclock_init();
#endif

1057
	x86_init.paging.pagetable_init();
1058

1059 1060 1061
	if (boot_cpu_data.cpuid_level >= 0) {
		/* A CPU has %cr4 if and only if it has CPUID */
		mmu_cr4_features = read_cr4();
1062 1063
		if (trampoline_cr4_features)
			*trampoline_cr4_features = mmu_cr4_features;
1064 1065
	}

1066 1067 1068 1069 1070 1071
#ifdef CONFIG_X86_32
	/* sync back kernel address range */
	clone_pgd_range(initial_page_table + KERNEL_PGD_BOUNDARY,
			swapper_pg_dir     + KERNEL_PGD_BOUNDARY,
			KERNEL_PGD_PTRS);
#endif
1072

1073 1074
	tboot_probe();

1075 1076 1077 1078
#ifdef CONFIG_X86_64
	map_vsyscall();
#endif

1079
	generic_apic_probe();
L
Linus Torvalds 已提交
1080

1081
	early_quirks();
1082

1083 1084 1085
	/*
	 * Read APIC and some other early information from ACPI tables.
	 */
L
Linus Torvalds 已提交
1086
	acpi_boot_init();
F
Feng Tang 已提交
1087
	sfi_init();
1088
	x86_dtb_init();
1089

1090 1091 1092
	/*
	 * get boot-time SMP configuration:
	 */
1093 1094
	if (smp_found_config)
		get_smp_config();
1095

1096
	prefill_possible_map();
Y
Yinghai Lu 已提交
1097

1098 1099
	init_cpu_to_node();

1100
	init_apic_mappings();
I
Ingo Molnar 已提交
1101 1102
	if (x86_io_apic_ops.init)
		x86_io_apic_ops.init();
1103

1104
	kvm_guest_init();
L
Linus Torvalds 已提交
1105

1106
	e820_reserve_resources();
1107
	e820_mark_nosave_regions(max_low_pfn);
L
Linus Torvalds 已提交
1108

1109
	x86_init.resources.reserve_resources();
1110 1111 1112

	e820_setup_gap();

L
Linus Torvalds 已提交
1113 1114 1115 1116 1117 1118 1119 1120
#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
1121
	x86_init.oem.banner();
1122

1123 1124
	x86_init.timers.wallclock_init();

1125
	mcheck_init();
1126

1127
	arch_init_ideal_nops();
1128 1129

	register_refined_jiffies(CLOCK_TICK_RATE);
1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141

#ifdef CONFIG_EFI
	/* Once setup is done above, disable efi_enabled on mismatched
	 * firmware/kernel archtectures since there is no support for
	 * runtime services.
	 */
	if (efi_enabled && IS_ENABLED(CONFIG_X86_64) != efi_64bit) {
		pr_info("efi: Setup done, disabling due to 32/64-bit mismatch\n");
		efi_unmap_memmap();
		efi_enabled = 0;
	}
#endif
L
Linus Torvalds 已提交
1142
}
1143

1144 1145
#ifdef CONFIG_X86_32

1146 1147 1148 1149 1150
static struct resource video_ram_resource = {
	.name	= "Video RAM area",
	.start	= 0xa0000,
	.end	= 0xbffff,
	.flags	= IORESOURCE_BUSY | IORESOURCE_MEM
1151 1152
};

1153
void __init i386_reserve_resources(void)
1154
{
1155 1156
	request_resource(&iomem_resource, &video_ram_resource);
	reserve_standard_io_resources();
1157 1158 1159
}

#endif /* CONFIG_X86_32 */