setup.c 32.9 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
#include <linux/seq_file.h>
#include <linux/console.h>
#include <linux/root_dev.h>
#include <linux/highmem.h>
39
#include <linux/export.h>
Linus Torvalds's avatar
Linus Torvalds committed
40 41 42
#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

73
#include <linux/usb/xhci-dbgp.h>
Linus Torvalds's avatar
Linus Torvalds committed
74
#include <video/edid.h>
75

76
#include <asm/mtrr.h>
77
#include <asm/apic.h>
78
#include <asm/realmode.h>
79
#include <asm/e820/api.h>
Linus Torvalds's avatar
Linus Torvalds committed
80 81
#include <asm/mpspec.h>
#include <asm/setup.h>
Yinghai Lu's avatar
Yinghai Lu committed
82
#include <asm/efi.h>
Ingo Molnar's avatar
Ingo Molnar committed
83 84
#include <asm/timer.h>
#include <asm/i8259.h>
Linus Torvalds's avatar
Linus Torvalds committed
85 86 87
#include <asm/sections.h>
#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>
Andrey Ryabinin's avatar
Andrey Ryabinin committed
93
#include <asm/kasan.h>
Linus Torvalds's avatar
Linus Torvalds committed
94

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

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

#include <asm/percpu.h>
#include <asm/topology.h>
#include <asm/apicdef.h>
111
#include <asm/amd_nb.h>
112
#include <asm/mce.h>
113
#include <asm/alternative.h>
114
#include <asm/prom.h>
115
#include <asm/microcode.h>
116
#include <asm/mmu_context.h>
117
#include <asm/kaslr.h>
118

119
/*
120 121 122
 * max_low_pfn_mapped: highest direct mapped pfn under 4GB
 * max_pfn_mapped:     highest direct mapped pfn over 4GB
 *
123
 * The direct mapping only covers E820_TYPE_RAM regions, so the ranges and gaps are
124
 * represented by pfn_mapped
125 126 127 128
 */
unsigned long max_low_pfn_mapped;
unsigned long max_pfn_mapped;

129
#ifdef CONFIG_DMI
130
RESERVE_BRK(dmi_alloc, 65536);
131
#endif
132

Ingo Molnar's avatar
Ingo Molnar committed
133

134 135 136
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
137 138 139 140 141 142
#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
143
int default_check_phys_apicid_present(int phys_apicid)
Ingo Molnar's avatar
Ingo Molnar committed
144
{
Thomas Gleixner's avatar
Thomas Gleixner committed
145
	return __default_check_phys_apicid_present(phys_apicid);
Ingo Molnar's avatar
Ingo Molnar committed
146 147 148
}
#endif

149 150
struct boot_params boot_params;

151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175
/*
 * Machine setup..
 */
static struct resource data_resource = {
	.name	= "Kernel data",
	.start	= 0,
	.end	= 0,
	.flags	= IORESOURCE_BUSY | IORESOURCE_SYSTEM_RAM
};

static struct resource code_resource = {
	.name	= "Kernel code",
	.start	= 0,
	.end	= 0,
	.flags	= IORESOURCE_BUSY | IORESOURCE_SYSTEM_RAM
};

static struct resource bss_resource = {
	.name	= "Kernel bss",
	.start	= 0,
	.end	= 0,
	.flags	= IORESOURCE_BUSY | IORESOURCE_SYSTEM_RAM
};


176
#ifdef CONFIG_X86_32
177 178 179
/* cpu data as detected by the assembly code in head_32.S */
struct cpuinfo_x86 new_cpu_data;

Linus Torvalds's avatar
Linus Torvalds committed
180
/* common cpu data for all cpus */
181
struct cpuinfo_x86 boot_cpu_data __read_mostly;
182
EXPORT_SYMBOL(boot_cpu_data);
Linus Torvalds's avatar
Linus Torvalds committed
183

184 185
unsigned int def_to_bigsmp;

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

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


#if !defined(CONFIG_X86_PAE) || defined(CONFIG_X86_64)
211
__visible unsigned long mmu_cr4_features __ro_after_init;
212
#else
213
__visible unsigned long mmu_cr4_features __ro_after_init = X86_CR4_PAE;
214 215
#endif

216 217
/* 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
218 219 220 221 222

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

extern int root_mountflags;

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

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

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

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

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

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

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

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

300 301
u64 relocated_ramdisk;

302 303
#ifdef CONFIG_BLK_DEV_INITRD

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

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

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

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

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

321
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

328
	/* We need to move the initrd down into directly mapped mem */
329 330
	relocated_ramdisk = memblock_find_in_range(0, PFN_PHYS(max_pfn_mapped),
						   area_size, PAGE_SIZE);
331

332
	if (!relocated_ramdisk)
333
		panic("Cannot find place for new RAMDISK of size %lld\n",
334
		      ramdisk_size);
335

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

Mark Salter's avatar
Mark Salter committed
344 345
	copy_from_early_mem((void *)initrd_start, ramdisk_image, ramdisk_size);

346 347
	printk(KERN_INFO "Move RAMDISK from [mem %#010llx-%#010llx] to"
		" [mem %#010llx-%#010llx]\n",
348
		ramdisk_image, ramdisk_image + ramdisk_size - 1,
349
		relocated_ramdisk, relocated_ramdisk + ramdisk_size - 1);
350
}
Yinghai Lu's avatar
Yinghai Lu committed
351

352 353 354
static void __init early_reserve_initrd(void)
{
	/* Assume only end is not page aligned */
Yinghai Lu's avatar
Yinghai Lu committed
355 356
	u64 ramdisk_image = get_ramdisk_image();
	u64 ramdisk_size  = get_ramdisk_size();
357 358 359 360 361 362 363 364
	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);
}
365 366
static void __init reserve_initrd(void)
{
367
	/* Assume only end is not page aligned */
Yinghai Lu's avatar
Yinghai Lu committed
368 369
	u64 ramdisk_image = get_ramdisk_image();
	u64 ramdisk_size  = get_ramdisk_size();
370
	u64 ramdisk_end   = PAGE_ALIGN(ramdisk_image + ramdisk_size);
371
	u64 mapped_size;
372 373 374 375 376 377 378

	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
379
	mapped_size = memblock_mem_size(max_pfn_mapped);
380
	if (ramdisk_size >= (mapped_size>>1))
381 382
		panic("initrd too large to handle, "
		       "disabling initrd (%lld needed, %lld available)\n",
383
		       ramdisk_size, mapped_size>>1);
384

385 386
	printk(KERN_INFO "RAMDISK: [mem %#010llx-%#010llx]\n", ramdisk_image,
			ramdisk_end - 1);
387

388
	if (pfn_range_is_mapped(PFN_DOWN(ramdisk_image),
389 390
				PFN_DOWN(ramdisk_end))) {
		/* All are mapped, easy case */
391 392 393 394 395 396
		initrd_start = ramdisk_image + PAGE_OFFSET;
		initrd_end = initrd_start + ramdisk_size;
		return;
	}

	relocate_initrd();
397

398
	memblock_free(ramdisk_image, ramdisk_end - ramdisk_image);
399
}
400

Yinghai Lu's avatar
Yinghai Lu committed
401
#else
402 403 404
static void __init early_reserve_initrd(void)
{
}
405
static void __init reserve_initrd(void)
Yinghai Lu's avatar
Yinghai Lu committed
406 407
{
}
408 409
#endif /* CONFIG_BLK_DEV_INITRD */

410
static void __init parse_setup_data(void)
411 412
{
	struct setup_data *data;
413
	u64 pa_data, pa_next;
414 415 416

	pa_data = boot_params.hdr.setup_data;
	while (pa_data) {
417
		u32 data_len, data_type;
418

419
		data = early_memremap(pa_data, sizeof(*data));
420
		data_len = data->len + sizeof(struct setup_data);
421 422
		data_type = data->type;
		pa_next = data->next;
423
		early_memunmap(data, sizeof(*data));
424

425
		switch (data_type) {
426
		case SETUP_E820_EXT:
427
			e820__memory_setup_extended(pa_data, data_len);
428
			break;
429 430
		case SETUP_DTB:
			add_dtb(pa_data);
431
			break;
432 433 434
		case SETUP_EFI:
			parse_efi_setup(pa_data, data_len);
			break;
435 436 437
		default:
			break;
		}
438
		pa_data = pa_next;
439 440 441
	}
}

442
static void __init memblock_x86_reserve_range_setup_data(void)
443 444 445 446 447 448
{
	struct setup_data *data;
	u64 pa_data;

	pa_data = boot_params.hdr.setup_data;
	while (pa_data) {
449
		data = early_memremap(pa_data, sizeof(*data));
450
		memblock_reserve(pa_data, sizeof(*data) + data->len);
451
		pa_data = data->next;
452
		early_memunmap(data, sizeof(*data));
453 454 455
	}
}

456 457 458 459
/*
 * --------- Crashkernel reservation ------------------------------
 */

460
#ifdef CONFIG_KEXEC_CORE
461

462 463 464
/* 16M alignment for crash kernel regions */
#define CRASH_ALIGN		(16 << 20)

465 466 467
/*
 * 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.
468
 * On 64bit, old kexec-tools need to under 896MiB.
469 470
 */
#ifdef CONFIG_X86_32
471 472
# define CRASH_ADDR_LOW_MAX	(512 << 20)
# define CRASH_ADDR_HIGH_MAX	(512 << 20)
473
#else
474 475
# define CRASH_ADDR_LOW_MAX	(896UL << 20)
# define CRASH_ADDR_HIGH_MAX	MAXMEM
476 477
#endif

478
static int __init reserve_crashkernel_low(void)
479 480
{
#ifdef CONFIG_X86_64
481
	unsigned long long base, low_base = 0, low_size = 0;
482 483 484
	unsigned long total_low_mem;
	int ret;

485 486
	total_low_mem = memblock_mem_size(1UL << (32 - PAGE_SHIFT));

487
	/* crashkernel=Y,low */
488
	ret = parse_crashkernel_low(boot_command_line, total_low_mem, &low_size, &base);
489
	if (ret) {
490 491
		/*
		 * two parts from lib/swiotlb.c:
492 493 494 495 496 497
		 * -swiotlb size: user-specified with swiotlb= or default.
		 *
		 * -swiotlb overflow buffer: now hardcoded to 32k. We round it
		 * to 8M for other buffers that may need to stay low too. Also
		 * make sure we allocate enough extra low memory so that we
		 * don't run out of DMA buffers for 32-bit devices.
498
		 */
499
		low_size = max(swiotlb_size_or_default() + (8UL << 20), 256UL << 20);
500
	} else {
501
		/* passed with crashkernel=0,low ? */
502
		if (!low_size)
503
			return 0;
504
	}
505

506
	low_base = memblock_find_in_range(low_size, 1ULL << 32, low_size, CRASH_ALIGN);
507
	if (!low_base) {
508 509 510
		pr_err("Cannot reserve %ldMB crashkernel low memory, please try smaller size.\n",
		       (unsigned long)(low_size >> 20));
		return -ENOMEM;
511 512
	}

513 514 515 516
	ret = memblock_reserve(low_base, low_size);
	if (ret) {
		pr_err("%s: Error reserving crashkernel low memblock.\n", __func__);
		return ret;
517 518 519
	}

	pr_info("Reserving %ldMB of low memory at %ldMB for crashkernel (System low RAM: %ldMB)\n",
520 521 522 523
		(unsigned long)(low_size >> 20),
		(unsigned long)(low_base >> 20),
		(unsigned long)(total_low_mem >> 20));

524 525 526
	crashk_low_res.start = low_base;
	crashk_low_res.end   = low_base + low_size - 1;
	insert_resource(&iomem_resource, &crashk_low_res);
527
#endif
528
	return 0;
529
}
530

531
static void __init reserve_crashkernel(void)
532
{
533
	unsigned long long crash_size, crash_base, total_mem;
534
	bool high = false;
535 536
	int ret;

537
	total_mem = memblock_phys_mem_size();
538

539
	/* crashkernel=XM */
540
	ret = parse_crashkernel(boot_command_line, total_mem, &crash_size, &crash_base);
541
	if (ret != 0 || crash_size <= 0) {
542
		/* crashkernel=X,high */
543
		ret = parse_crashkernel_high(boot_command_line, total_mem,
544
					     &crash_size, &crash_base);
545 546 547 548
		if (ret != 0 || crash_size <= 0)
			return;
		high = true;
	}
549 550 551

	/* 0 means: find the address automatically */
	if (crash_base <= 0) {
552
		/*
553 554 555
		 * Set CRASH_ADDR_LOW_MAX upper bound for crash memory,
		 * as old kexec-tools loads bzImage below that, unless
		 * "crashkernel=size[KMG],high" is specified.
556
		 */
557
		crash_base = memblock_find_in_range(CRASH_ALIGN,
558 559
						    high ? CRASH_ADDR_HIGH_MAX
							 : CRASH_ADDR_LOW_MAX,
560
						    crash_size, CRASH_ALIGN);
Tejun Heo's avatar
Tejun Heo committed
561
		if (!crash_base) {
562
			pr_info("crashkernel reservation failed - No suitable area found.\n");
563 564
			return;
		}
565

566
	} else {
567 568
		unsigned long long start;

569
		start = memblock_find_in_range(crash_base,
570 571
					       crash_base + crash_size,
					       crash_size, 1 << 20);
572 573
		if (start != crash_base) {
			pr_info("crashkernel reservation failed - memory is in use.\n");
574 575
			return;
		}
576
	}
577 578 579 580 581
	ret = memblock_reserve(crash_base, crash_size);
	if (ret) {
		pr_err("%s: Error reserving crashkernel memblock.\n", __func__);
		return;
	}
582

583 584 585 586
	if (crash_base >= (1ULL << 32) && reserve_crashkernel_low()) {
		memblock_free(crash_base, crash_size);
		return;
	}
587

588 589 590 591
	pr_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));
592

593 594 595
	crashk_res.start = crash_base;
	crashk_res.end   = crash_base + crash_size - 1;
	insert_resource(&iomem_resource, &crashk_res);
596 597
}
#else
598
static void __init reserve_crashkernel(void)
599 600 601 602
{
}
#endif

603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625
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 }
};

626
void __init reserve_standard_io_resources(void)
627 628 629 630 631 632 633 634 635
{
	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]);

}

636 637 638 639 640 641 642
static __init void reserve_ibft_region(void)
{
	unsigned long addr, size = 0;

	addr = find_ibft_region(&size);

	if (size)
643
		memblock_reserve(addr, size);
644 645
}

646 647
static bool __init snb_gfx_workaround_needed(void)
{
648
#ifdef CONFIG_PCI
649 650
	int i;
	u16 vendor, devid;
651
	static const __initconst u16 snb_ids[] = {
652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672
		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;
673
#endif
674 675 676 677 678 679 680 681 682 683

	return false;
}

/*
 * Sandy Bridge graphics has trouble with certain ranges, exclude
 * them from allocation.
 */
static void __init trim_snb_memory(void)
{
684
	static const __initconst unsigned long bad_pages[] = {
685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722
		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();
}

723 724 725 726 727 728
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.
729 730 731
	 *
	 * This typically reserves additional memory (64KiB by default)
	 * since some BIOSes are known to corrupt low memory.  See the
732
	 * Kconfig help text for X86_RESERVE_LOW.
733
	 */
734
	e820__range_update(0, PAGE_SIZE, E820_TYPE_RAM, E820_TYPE_RESERVED);
735

736 737 738 739 740
	/*
	 * special case: Some BIOSen report the PC BIOS
	 * area (640->1Mb) as ram even though it is not.
	 * take them out.
	 */
741
	e820__range_remove(BIOS_BEGIN, BIOS_END - BIOS_BEGIN, E820_TYPE_RAM, 1);
742

743
	e820__update_table(e820_table);
744 745
}

746 747 748 749 750 751 752
/* 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;

	/*
753
	 * Complain if .text .data and .bss are not marked as E820_TYPE_RAM and
754 755 756 757 758
	 * 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.
	 */
759
	if (e820__mapped_all(start, start + size, E820_TYPE_RAM))
760 761
		return;

762 763 764
	pr_warn(".text .data .bss are not marked as E820_TYPE_RAM!\n");
	e820__range_remove(start, size, E820_TYPE_RAM, 0);
	e820__range_add(start, size, E820_TYPE_RAM);
765 766
}

767 768
static unsigned reserve_low = CONFIG_X86_RESERVE_LOW << 10;

769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790
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);

791 792 793 794 795
static void __init trim_low_memory_range(void)
{
	memblock_reserve(0, ALIGN(reserve_low, PAGE_SIZE));
}
	
796 797 798 799 800 801
/*
 * Dump out kernel offset information on panic.
 */
static int
dump_kernel_offset(struct notifier_block *self, unsigned long v, void *p)
{
802 803
	if (kaslr_enabled()) {
		pr_emerg("Kernel Offset: 0x%lx from 0x%lx (relocation range: 0x%lx-0x%lx)\n",
Jiri Kosina's avatar
Jiri Kosina committed
804
			 kaslr_offset(),
805 806 807 808 809 810
			 __START_KERNEL,
			 __START_KERNEL_map,
			 MODULES_VADDR-1);
	} else {
		pr_emerg("Kernel Offset: disabled\n");
	}
811 812 813 814

	return 0;
}

815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834
static void __init simple_udelay_calibration(void)
{
	unsigned int tsc_khz, cpu_khz;
	unsigned long lpj;

	if (!boot_cpu_has(X86_FEATURE_TSC))
		return;

	cpu_khz = x86_platform.calibrate_cpu();
	tsc_khz = x86_platform.calibrate_tsc();

	tsc_khz = tsc_khz ? : cpu_khz;
	if (!tsc_khz)
		return;

	lpj = tsc_khz * 1000;
	do_div(lpj, HZ);
	loops_per_jiffy = lpj;
}

Linus Torvalds's avatar
Linus Torvalds committed
835 836 837 838 839 840 841
/*
 * 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.
 */
842 843 844 845 846 847
/*
 * 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
848 849
void __init setup_arch(char **cmdline_p)
{
850 851 852
	memblock_reserve(__pa_symbol(_text),
			 (unsigned long)__bss_stop - (unsigned long)_text);

853 854
	early_reserve_initrd();

855 856 857 858 859 860
	/*
	 * 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.
	 */

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

	/*
	 * 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);
873 874 875 876 877 878 879 880 881
	/*
	 * Note: Quark X1000 CPUs advertise PGE incorrectly and require
	 * a cr3 based tlb flush, so the following __flush_tlb_all()
	 * will not flush anything because the cpu quirk which clears
	 * X86_FEATURE_PGE has not been invoked yet. Though due to the
	 * load_cr3() above the TLB has been flushed already. The
	 * quirk is invoked before subsequent calls to __flush_tlb_all()
	 * so proper operation is guaranteed.
	 */
882
	__flush_tlb_all();
883 884 885
#else
	printk(KERN_INFO "Command line: %s\n", boot_command_line);
#endif
Linus Torvalds's avatar
Linus Torvalds committed
886

887 888 889 890
	/*
	 * If we have OLPC OFW, we might end up relocating the fixmap due to
	 * reserve_top(), so do this before touching the ioremap area.
	 */
891 892
	olpc_ofw_detect();

893
	early_trap_init();
894
	early_cpu_init();
895 896
	early_ioremap_init();

897 898
	setup_olpc_ofw_pgd();

899 900 901
	ROOT_DEV = old_decode_dev(boot_params.hdr.root_dev);
	screen_info = boot_params.screen_info;
	edid_info = boot_params.edid_info;
902
#ifdef CONFIG_X86_32
903 904
	apm_info.bios = boot_params.apm_bios_info;
	ist_info = boot_params.ist_info;
905 906
#endif
	saved_video_mode = boot_params.hdr.vid_mode;
907
	bootloader_type = boot_params.hdr.type_of_loader;
908 909 910 911 912 913
	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
914 915

#ifdef CONFIG_BLK_DEV_RAM
916 917 918
	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
919
#endif
920 921
#ifdef CONFIG_EFI
	if (!strncmp((char *)&boot_params.efi_info.efi_loader_signature,
922
		     EFI32_LOADER_SIGNATURE, 4)) {
923
		set_bit(EFI_BOOT, &efi.flags);
924
	} else if (!strncmp((char *)&boot_params.efi_info.efi_loader_signature,
925
		     EFI64_LOADER_SIGNATURE, 4)) {
926 927
		set_bit(EFI_BOOT, &efi.flags);
		set_bit(EFI_64BIT, &efi.flags);
928
	}
929 930 931

	if (efi_enabled(EFI_BOOT))
		efi_memblock_x86_reserve_range();
932 933
#endif

934
	x86_init.oem.arch_setup();
935

936
	iomem_resource.end = (1ULL << boot_cpu_data.x86_phys_bits) - 1;
937
	e820__memory_setup();
938 939
	parse_setup_data();

Linus Torvalds's avatar
Linus Torvalds committed
940 941
	copy_edd();

942
	if (!boot_params.hdr.root_flags)
Linus Torvalds's avatar
Linus Torvalds committed
943 944 945 946
		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;
947
	init_mm.brk = _brk_end;
948 949

	mpx_mm_init(&init_mm);
Linus Torvalds's avatar
Linus Torvalds committed
950

951 952 953 954 955 956 957
	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;

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

971 972 973 974
	strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE);
	*cmdline_p = command_line;

	/*