setup.c 23.4 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
/*
 *  Copyright (C) 1995  Linus Torvalds
 *
 *  Support of BIGMEM added by Gerhard Wichert, Siemens AG, July 1999
 *
 *  Memory region support
 *	David Parsons <orc@pell.chi.il.us>, July-August 1999
 *
 *  Added E820 sanitization routine (removes overlapping memory regions);
 *  Brian Moyle <bmoyle@mvista.com>, February 2001
 *
 * Moved CPU detection code to cpu/${cpu}.c
 *    Patrick Mochel <mochel@osdl.org>, March 2002
 *
 *  Provisions for empty E820 memory regions (reported by certain BIOSes).
 *  Alex Achenbach <xela@slit.de>, December 2002.
 *
 */

/*
 * This file handles the architecture-dependent parts of initialization
 */

#include <linux/sched.h>
#include <linux/mm.h>
26
#include <linux/mmzone.h>
27
#include <linux/screen_info.h>
L
Linus Torvalds 已提交
28 29 30 31 32 33 34 35 36 37 38 39 40 41
#include <linux/ioport.h>
#include <linux/acpi.h>
#include <linux/apm_bios.h>
#include <linux/initrd.h>
#include <linux/bootmem.h>
#include <linux/seq_file.h>
#include <linux/console.h>
#include <linux/mca.h>
#include <linux/root_dev.h>
#include <linux/highmem.h>
#include <linux/module.h>
#include <linux/efi.h>
#include <linux/init.h>
#include <linux/edd.h>
42
#include <linux/iscsi_ibft.h>
L
Linus Torvalds 已提交
43
#include <linux/nodemask.h>
44
#include <linux/kexec.h>
45
#include <linux/dmi.h>
D
Dave Hansen 已提交
46
#include <linux/pfn.h>
47
#include <linux/pci.h>
48
#include <asm/pci-direct.h>
49
#include <linux/init_ohci1394_dma.h>
50
#include <linux/kvm_para.h>
51

52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/stddef.h>
#include <linux/unistd.h>
#include <linux/ptrace.h>
#include <linux/slab.h>
#include <linux/user.h>
#include <linux/delay.h>

#include <linux/kallsyms.h>
#include <linux/cpufreq.h>
#include <linux/dma-mapping.h>
#include <linux/ctype.h>
#include <linux/uaccess.h>

#include <linux/percpu.h>
#include <linux/crash_dump.h>

L
Linus Torvalds 已提交
70
#include <video/edid.h>
71

72
#include <asm/mtrr.h>
73
#include <asm/apic.h>
L
Linus Torvalds 已提交
74 75 76 77
#include <asm/e820.h>
#include <asm/mpspec.h>
#include <asm/setup.h>
#include <asm/arch_hooks.h>
Y
Yinghai Lu 已提交
78
#include <asm/efi.h>
L
Linus Torvalds 已提交
79
#include <asm/sections.h>
80
#include <asm/dmi.h>
L
Linus Torvalds 已提交
81 82
#include <asm/io_apic.h>
#include <asm/ist.h>
83
#include <asm/vmi.h>
84
#include <setup_arch.h>
85
#include <asm/bios_ebda.h>
B
Bernhard Walle 已提交
86
#include <asm/cacheflush.h>
87
#include <asm/processor.h>
Y
Yinghai Lu 已提交
88
#include <asm/bugs.h>
L
Linus Torvalds 已提交
89

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

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

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

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

115 116 117 118 119 120
#ifndef CONFIG_DEBUG_BOOT_PARAMS
struct boot_params __initdata boot_params;
#else
struct boot_params boot_params;
#endif

L
Linus Torvalds 已提交
121 122 123
/*
 * Machine setup..
 */
124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144
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
};

145 146

#ifdef CONFIG_X86_32
147 148 149 150 151 152
/* This value is set up by the early boot code to point to the value
   immediately after the boot time page tables.  It contains a *physical*
   address, and must not be in the .bss segment! */
unsigned long init_pg_tables_start __initdata = ~0UL;
unsigned long init_pg_tables_end __initdata = ~0UL;

153 154 155 156 157 158 159
static struct resource video_ram_resource = {
	.name	= "Video RAM area",
	.start	= 0xa0000,
	.end	= 0xbffff,
	.flags	= IORESOURCE_BUSY | IORESOURCE_MEM
};

L
Linus Torvalds 已提交
160
/* cpu data as detected by the assembly code in head.S */
161
struct cpuinfo_x86 new_cpu_data __cpuinitdata = {0, 0, 0, 0, -1, 1, 0, 0, -1};
L
Linus Torvalds 已提交
162
/* common cpu data for all cpus */
163
struct cpuinfo_x86 boot_cpu_data __read_mostly = {0, 0, 0, 0, -1, 1, 0, 0, -1};
164
EXPORT_SYMBOL(boot_cpu_data);
165 166 167 168 169 170
static void set_mca_bus(int x)
{
#ifdef CONFIG_MCA
	MCA_bus = x;
#endif
}
L
Linus Torvalds 已提交
171

172 173
unsigned int def_to_bigsmp;

L
Linus Torvalds 已提交
174 175 176 177 178
/* for MCA, but anyone else can use it if they want */
unsigned int machine_id;
unsigned int machine_submodel_id;
unsigned int BIOS_revision;

179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201
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
struct cpuinfo_x86 boot_cpu_data __read_mostly;
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

L
Linus Torvalds 已提交
202 203 204
/* Boot loader ID as an integer, for the benefit of proc_dointvec */
int bootloader_type;

205 206 207 208 209 210
/*
 * Early DMI memory
 */
int dmi_alloc_index;
char dmi_alloc_data[DMI_MAX_DATA];

L
Linus Torvalds 已提交
211 212 213 214
/*
 * Setup options
 */
struct screen_info screen_info;
215
EXPORT_SYMBOL(screen_info);
L
Linus Torvalds 已提交
216
struct edid_info edid_info;
217
EXPORT_SYMBOL_GPL(edid_info);
L
Linus Torvalds 已提交
218 219 220

extern int root_mountflags;

221
unsigned long saved_video_mode;
L
Linus Torvalds 已提交
222

223
#define RAMDISK_IMAGE_START_MASK	0x07FF
L
Linus Torvalds 已提交
224
#define RAMDISK_PROMPT_FLAG		0x8000
225
#define RAMDISK_LOAD_FLAG		0x4000
L
Linus Torvalds 已提交
226

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

#if defined(CONFIG_EDD) || defined(CONFIG_EDD_MODULE)
struct edd edd;
#ifdef CONFIG_EDD_MODULE
EXPORT_SYMBOL(edd);
#endif
/**
 * copy_edd() - Copy the BIOS EDD information
 *              from boot_params into a safe place.
 *
 */
static inline void copy_edd(void)
{
244 245 246 247 248
     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 已提交
249 250 251 252 253 254 255
}
#else
static inline void copy_edd(void)
{
}
#endif

256 257
#ifdef CONFIG_BLK_DEV_INITRD

258
#ifdef CONFIG_X86_32
259

260 261
#define MAX_MAP_CHUNK	(NR_FIX_BTMAPS << PAGE_SHIFT)
static void __init relocate_initrd(void)
262
{
263

264 265 266 267
	u64 ramdisk_image = boot_params.hdr.ramdisk_image;
	u64 ramdisk_size  = boot_params.hdr.ramdisk_size;
	u64 end_of_lowmem = max_low_pfn << PAGE_SHIFT;
	u64 ramdisk_here;
268 269
	unsigned long slop, clen, mapaddr;
	char *p, *q;
270 271

	/* We need to move the initrd down into lowmem */
272 273
	ramdisk_here = find_e820_area(0, end_of_lowmem, ramdisk_size,
					 PAGE_SIZE);
274

275 276 277 278
	if (ramdisk_here == -1ULL)
		panic("Cannot find place for new RAMDISK of size %lld\n",
			 ramdisk_size);

279 280
	/* Note: this includes all the lowmem currently occupied by
	   the initrd, we rely on that fact to keep the data intact. */
281
	reserve_early(ramdisk_here, ramdisk_here + ramdisk_size,
282
			 "NEW RAMDISK");
283 284
	initrd_start = ramdisk_here + PAGE_OFFSET;
	initrd_end   = initrd_start + ramdisk_size;
285 286
	printk(KERN_INFO "Allocated new RAMDISK: %08llx - %08llx\n",
			 ramdisk_here, ramdisk_here + ramdisk_size);
287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306

	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;
307
		p = early_memremap(mapaddr, clen+slop);
308
		memcpy(q, p+slop, clen);
309
		early_iounmap(p, clen+slop);
310 311 312 313
		q += clen;
		ramdisk_image += clen;
		ramdisk_size  -= clen;
	}
314
	/* high pages is not converted by early_res_to_bootmem */
315 316
	ramdisk_image = boot_params.hdr.ramdisk_image;
	ramdisk_size  = boot_params.hdr.ramdisk_size;
317 318
	printk(KERN_INFO "Move RAMDISK from %016llx - %016llx to"
		" %08llx - %08llx\n",
319 320
		ramdisk_image, ramdisk_image + ramdisk_size - 1,
		ramdisk_here, ramdisk_here + ramdisk_size - 1);
321 322
}
#endif
Y
Yinghai Lu 已提交
323

324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367
static void __init reserve_initrd(void)
{
	u64 ramdisk_image = boot_params.hdr.ramdisk_image;
	u64 ramdisk_size  = boot_params.hdr.ramdisk_size;
	u64 ramdisk_end   = ramdisk_image + ramdisk_size;
	u64 end_of_lowmem = max_low_pfn << PAGE_SHIFT;

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

	initrd_start = 0;

	if (ramdisk_size >= (end_of_lowmem>>1)) {
		free_early(ramdisk_image, ramdisk_end);
		printk(KERN_ERR "initrd too large to handle, "
		       "disabling initrd\n");
		return;
	}

	printk(KERN_INFO "RAMDISK: %08llx - %08llx\n", ramdisk_image,
			ramdisk_end);


	if (ramdisk_end <= end_of_lowmem) {
		/* All in lowmem, easy case */
		/*
		 * don't need to reserve again, already reserved early
		 * in i386_start_kernel
		 */
		initrd_start = ramdisk_image + PAGE_OFFSET;
		initrd_end = initrd_start + ramdisk_size;
		return;
	}

#ifdef CONFIG_X86_32
	relocate_initrd();
#else
	printk(KERN_ERR "initrd extends beyond end of memory "
	       "(0x%08llx > 0x%08llx)\ndisabling initrd\n",
	       ramdisk_end, end_of_lowmem);
	initrd_start = 0;
#endif
	free_early(ramdisk_image, ramdisk_end);
368
}
Y
Yinghai Lu 已提交
369
#else
370
static void __init reserve_initrd(void)
Y
Yinghai Lu 已提交
371 372
{
}
373 374
#endif /* CONFIG_BLK_DEV_INITRD */

375
static void __init parse_setup_data(void)
376 377 378 379 380 381 382 383
{
	struct setup_data *data;
	u64 pa_data;

	if (boot_params.hdr.version < 0x0209)
		return;
	pa_data = boot_params.hdr.setup_data;
	while (pa_data) {
384
		data = early_memremap(pa_data, PAGE_SIZE);
385 386 387 388 389 390 391 392 393 394 395 396
		switch (data->type) {
		case SETUP_E820_EXT:
			parse_e820_ext(data, pa_data);
			break;
		default:
			break;
		}
		pa_data = data->next;
		early_iounmap(data, PAGE_SIZE);
	}
}

397
static void __init e820_reserve_setup_data(void)
398 399 400
{
	struct setup_data *data;
	u64 pa_data;
401
	int found = 0;
402 403 404 405 406

	if (boot_params.hdr.version < 0x0209)
		return;
	pa_data = boot_params.hdr.setup_data;
	while (pa_data) {
407
		data = early_memremap(pa_data, sizeof(*data));
408 409
		e820_update_range(pa_data, sizeof(*data)+data->len,
			 E820_RAM, E820_RESERVED_KERN);
410
		found = 1;
411 412 413
		pa_data = data->next;
		early_iounmap(data, sizeof(*data));
	}
414 415 416
	if (!found)
		return;

417
	sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
418
	memcpy(&e820_saved, &e820, sizeof(struct e820map));
419 420 421 422
	printk(KERN_INFO "extended physical RAM map:\n");
	e820_print_map("reserve setup_data");
}

423 424 425 426 427 428 429 430 431 432
static void __init reserve_early_setup_data(void)
{
	struct setup_data *data;
	u64 pa_data;
	char buf[32];

	if (boot_params.hdr.version < 0x0209)
		return;
	pa_data = boot_params.hdr.setup_data;
	while (pa_data) {
433
		data = early_memremap(pa_data, sizeof(*data));
434 435 436 437 438 439 440
		sprintf(buf, "setup data %x", data->type);
		reserve_early(pa_data, pa_data+sizeof(*data)+data->len, buf);
		pa_data = data->next;
		early_iounmap(data, sizeof(*data));
	}
}

441 442 443 444 445
/*
 * --------- Crashkernel reservation ------------------------------
 */

#ifdef CONFIG_KEXEC
446 447 448 449 450 451 452

/**
 * Reserve @size bytes of crashkernel memory at any suitable offset.
 *
 * @size: Size of the crashkernel memory to reserve.
 * Returns the base address on success, and -1ULL on failure.
 */
453
static
454
unsigned long long __init find_and_reserve_crashkernel(unsigned long long size)
455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474
{
	const unsigned long long alignment = 16<<20; 	/* 16M */
	unsigned long long start = 0LL;

	while (1) {
		int ret;

		start = find_e820_area(start, ULONG_MAX, size, alignment);
		if (start == -1ULL)
			return start;

		/* try to reserve it */
		ret = reserve_bootmem_generic(start, size, BOOTMEM_EXCLUSIVE);
		if (ret >= 0)
			return start;

		start += alignment;
	}
}

475 476 477 478 479 480 481 482 483 484 485 486
static inline unsigned long long get_total_mem(void)
{
	unsigned long long total;

	total = max_low_pfn - min_low_pfn;
#ifdef CONFIG_HIGHMEM
	total += highend_pfn - highstart_pfn;
#endif

	return total << PAGE_SHIFT;
}

487
static void __init reserve_crashkernel(void)
488 489 490 491 492 493 494 495 496
{
	unsigned long long total_mem;
	unsigned long long crash_size, crash_base;
	int ret;

	total_mem = get_total_mem();

	ret = parse_crashkernel(boot_command_line, total_mem,
			&crash_size, &crash_base);
497 498 499 500 501 502 503 504 505
	if (ret != 0 || crash_size <= 0)
		return;

	/* 0 means: find the address automatically */
	if (crash_base <= 0) {
		crash_base = find_and_reserve_crashkernel(crash_size);
		if (crash_base == -1ULL) {
			pr_info("crashkernel reservation failed. "
				"No suitable area found.\n");
506 507
			return;
		}
508 509 510 511 512 513
	} else {
		ret = reserve_bootmem_generic(crash_base, crash_size,
					BOOTMEM_EXCLUSIVE);
		if (ret < 0) {
			pr_info("crashkernel reservation failed - "
				"memory is in use\n");
514 515
			return;
		}
516
	}
517

518 519 520 521 522
	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));
523

524 525 526
	crashk_res.start = crash_base;
	crashk_res.end   = crash_base + crash_size - 1;
	insert_resource(&iomem_resource, &crashk_res);
527 528
}
#else
529
static void __init reserve_crashkernel(void)
530 531 532 533
{
}
#endif

534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556
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 }
};

557
static void __init reserve_standard_io_resources(void)
558 559 560 561 562 563 564 565 566
{
	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]);

}

567 568 569 570 571 572 573
/*
 * Note: elfcorehdr_addr is not just limited to vmcore. It is also used by
 * is_kdump_kernel() to determine if we are booting after a panic. Hence
 * ifdef it under CONFIG_CRASH_DUMP and not CONFIG_PROC_VMCORE.
 */

#ifdef CONFIG_CRASH_DUMP
574 575 576 577 578 579 580 581 582 583 584 585 586 587 588
/* elfcorehdr= specifies the location of elf core header
 * stored by the crashed kernel. This option will be passed
 * by kexec loader to the capture kernel.
 */
static int __init setup_elfcorehdr(char *arg)
{
	char *end;
	if (!arg)
		return -EINVAL;
	elfcorehdr_addr = memparse(arg, &end);
	return end > arg ? 0 : -EINVAL;
}
early_param("elfcorehdr", setup_elfcorehdr);
#endif

589
static int __init default_update_genapic(void)
590
{
591 592 593 594
#ifdef CONFIG_X86_SMP
# if defined(CONFIG_X86_GENERICARCH) || defined(CONFIG_X86_64)
	genapic->wakeup_cpu = wakeup_secondary_cpu_via_init;
# endif
595
#endif
596

597
	return 0;
598 599
}

600 601 602
static struct x86_quirks default_x86_quirks __initdata = {
	.update_genapic         = default_update_genapic,
};
603

Y
Yinghai Lu 已提交
604
struct x86_quirks *x86_quirks __initdata = &default_x86_quirks;
605

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

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

	return 0;
}
618
#endif
619 620 621

/* List of systems that have known low memory corruption BIOS problems */
static struct dmi_system_id __initdata bad_bios_dmi_table[] = {
I
Ingo Molnar 已提交
622
#ifdef CONFIG_X86_RESERVE_LOW_64K
623 624 625 626 627 628 629
	{
		.callback = dmi_low_memory_corruption,
		.ident = "AMI BIOS",
		.matches = {
			DMI_MATCH(DMI_BIOS_VENDOR, "American Megatrends Inc."),
		},
	},
630 631 632 633
	{
		.callback = dmi_low_memory_corruption,
		.ident = "Phoenix BIOS",
		.matches = {
634
			DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies"),
635 636
		},
	},
I
Ingo Molnar 已提交
637
#endif
638
	{}
639 640
};

L
Linus Torvalds 已提交
641 642 643 644 645 646 647
/*
 * 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.
 */
648 649 650 651 652 653
/*
 * setup_arch - architecture-specific boot-time initializations
 *
 * Note: On x86_64, fixmaps are ready for use even before this is called.
 */

L
Linus Torvalds 已提交
654 655
void __init setup_arch(char **cmdline_p)
{
656
#ifdef CONFIG_X86_32
L
Linus Torvalds 已提交
657
	memcpy(&boot_cpu_data, &new_cpu_data, sizeof(new_cpu_data));
I
Ingo Molnar 已提交
658
	visws_early_detect();
L
Linus Torvalds 已提交
659
	pre_setup_arch_hook();
660 661 662
#else
	printk(KERN_INFO "Command line: %s\n", boot_command_line);
#endif
L
Linus Torvalds 已提交
663

664 665 666
	/* VMI may relocate the fixmap; do this before touching ioremap area */
	vmi_init();

667
	early_cpu_init();
668 669
	early_ioremap_init();

670 671 672
	ROOT_DEV = old_decode_dev(boot_params.hdr.root_dev);
	screen_info = boot_params.screen_info;
	edid_info = boot_params.edid_info;
673
#ifdef CONFIG_X86_32
674 675
	apm_info.bios = boot_params.apm_bios_info;
	ist_info = boot_params.ist_info;
676
	if (boot_params.sys_desc_table.length != 0) {
677 678 679 680
		set_mca_bus(boot_params.sys_desc_table.table[3] & 0x2);
		machine_id = boot_params.sys_desc_table.table[0];
		machine_submodel_id = boot_params.sys_desc_table.table[1];
		BIOS_revision = boot_params.sys_desc_table.table[2];
L
Linus Torvalds 已提交
681
	}
682 683
#endif
	saved_video_mode = boot_params.hdr.vid_mode;
684
	bootloader_type = boot_params.hdr.type_of_loader;
L
Linus Torvalds 已提交
685 686

#ifdef CONFIG_BLK_DEV_RAM
687 688 689
	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 已提交
690
#endif
691 692
#ifdef CONFIG_EFI
	if (!strncmp((char *)&boot_params.efi_info.efi_loader_signature,
693 694 695 696 697 698
#ifdef CONFIG_X86_32
		     "EL32",
#else
		     "EL64",
#endif
	 4)) {
699 700 701 702 703
		efi_enabled = 1;
		efi_reserve_early();
	}
#endif

L
Linus Torvalds 已提交
704
	ARCH_SETUP
705

706
	setup_memory_map();
707
	parse_setup_data();
708 709
	/* update the e820_saved too */
	e820_reserve_setup_data();
710

L
Linus Torvalds 已提交
711 712
	copy_edd();

713
	if (!boot_params.hdr.root_flags)
L
Linus Torvalds 已提交
714 715 716 717
		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;
718
#ifdef CONFIG_X86_32
L
Linus Torvalds 已提交
719
	init_mm.brk = init_pg_tables_end + PAGE_OFFSET;
720 721 722
#else
	init_mm.brk = (unsigned long) &_end;
#endif
L
Linus Torvalds 已提交
723 724 725 726 727

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

731 732 733 734 735 736 737 738 739 740 741 742 743
#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

744 745 746
	strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE);
	*cmdline_p = command_line;

747
	parse_early_param();
L
Linus Torvalds 已提交
748

749 750 751 752
#ifdef CONFIG_X86_64
	check_efer();
#endif

753 754
	/* Must be before kernel pagetables are setup */
	vmi_activate();
A
Alok Kataria 已提交
755

756
	/* after early param, so could get panic from serial */
757
	reserve_early_setup_data();
758

759
	if (acpi_mps_check()) {
I
Ingo Molnar 已提交
760
#ifdef CONFIG_X86_LOCAL_APIC
761
		disable_apic = 1;
I
Ingo Molnar 已提交
762
#endif
763
		setup_clear_cpu_cap(X86_FEATURE_APIC);
764 765
	}

766 767 768 769 770
#ifdef CONFIG_PCI
	if (pci_early_dump_regs)
		early_dump_pci_devices();
#endif

771
	finish_e820_parsing();
772

773 774 775 776
	dmi_scan_machine();

	dmi_check_system(bad_bios_dmi_table);

777 778 779 780 781 782
	/*
	 * VMware detection requires dmi to be available, so this
	 * needs to be done after dmi_scan_machine, for the BP.
	 */
	init_hypervisor(&boot_cpu_data);

783
#ifdef CONFIG_X86_32
784
	probe_roms();
785
#endif
786 787 788 789 790 791

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

792 793 794
	if (efi_enabled)
		efi_init();

795
#ifdef CONFIG_X86_32
Y
Yinghai Lu 已提交
796 797 798 799 800 801 802
	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");
	}
803 804 805
#else
	early_gart_iommu_check();
#endif
Y
Yinghai Lu 已提交
806

807 808 809 810
	/*
	 * partially used pages are not usable - thus
	 * we are rounding upwards:
	 */
811
	max_pfn = e820_end_of_ram_pfn();
812

Y
Yinghai Lu 已提交
813 814
	/* preallocate 4k for mptable mpc */
	early_reserve_e820_mpc_new();
815 816
	/* update e820 for memory not covered by WB MTRRs */
	mtrr_bp_init();
817
	if (mtrr_trim_uncached_memory(max_pfn))
818
		max_pfn = e820_end_of_ram_pfn();
819

820
#ifdef CONFIG_X86_32
821
	/* max_low_pfn get updated here */
822
	find_low_pfn_range();
823 824 825
#else
	num_physpages = max_pfn;

826 827
 	if (cpu_has_x2apic)
 		check_x2apic();
828 829 830

	/* How many end-of-memory variables you have, grandma! */
	/* need this before calling reserve_initrd */
831 832 833 834 835
	if (max_pfn > (1UL<<(32 - PAGE_SHIFT)))
		max_low_pfn = e820_end_of_low_ram_pfn();
	else
		max_low_pfn = max_pfn;

836 837
	high_memory = (void *)__va(max_pfn * PAGE_SIZE - 1) + 1;
#endif
838

839 840 841 842
#ifdef CONFIG_X86_CHECK_BIOS_CORRUPTION
	setup_bios_corruption_check();
#endif

843
	/* max_pfn_mapped is updated here */
844 845 846 847 848 849 850 851 852 853 854
	max_low_pfn_mapped = init_memory_mapping(0, max_low_pfn<<PAGE_SHIFT);
	max_pfn_mapped = max_low_pfn_mapped;

#ifdef CONFIG_X86_64
	if (max_pfn > max_low_pfn) {
		max_pfn_mapped = init_memory_mapping(1UL<<32,
						     max_pfn<<PAGE_SHIFT);
		/* can we preseve max_low_pfn ?*/
		max_low_pfn = max_pfn;
	}
#endif
855

856 857 858 859 860 861 862 863 864
	/*
	 * 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

865 866
	reserve_initrd();

867 868 869 870
#ifdef CONFIG_X86_64
	vsmp_init();
#endif

871 872 873 874 875 876 877
	io_delay_init();

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

878 879
	early_acpi_boot_init();

880
#ifdef CONFIG_ACPI_NUMA
Y
Yinghai Lu 已提交
881 882 883 884
	/*
	 * Parse SRAT to discover nodes.
	 */
	acpi_numa_init();
885 886
#endif

887
	initmem_init(0, max_pfn);
888

889 890 891 892 893 894
#ifdef CONFIG_ACPI_SLEEP
	/*
	 * Reserve low memory region for sleep support.
	 */
	acpi_reserve_bootmem();
#endif
895
#ifdef CONFIG_X86_FIND_SMP_CONFIG
896 897 898 899 900 901 902
	/*
	 * Find and reserve possible boot-time SMP configuration:
	 */
	find_smp_config();
#endif
	reserve_crashkernel();

903 904 905 906 907 908 909 910 911
#ifdef CONFIG_X86_64
	/*
	 * dma32_reserve_bootmem() allocates bootmem which may conflict
	 * with the crashkernel command line, so do that after
	 * reserve_crashkernel()
	 */
	dma32_reserve_bootmem();
#endif

912 913
	reserve_ibft_region();

914 915 916 917
#ifdef CONFIG_KVM_CLOCK
	kvmclock_init();
#endif

918
	paravirt_pagetable_setup_start(swapper_pg_dir);
L
Linus Torvalds 已提交
919
	paging_init();
920
	paravirt_pagetable_setup_done(swapper_pg_dir);
921
	paravirt_post_allocator_init();
922

923 924 925 926
#ifdef CONFIG_X86_64
	map_vsyscall();
#endif

L
Linus Torvalds 已提交
927
#ifdef CONFIG_X86_GENERICARCH
928
	generic_apic_probe();
929
#endif
L
Linus Torvalds 已提交
930

931
	early_quirks();
932

933 934 935
	/*
	 * Read APIC and some other early information from ACPI tables.
	 */
L
Linus Torvalds 已提交
936
	acpi_boot_init();
937

938
#if defined(CONFIG_X86_MPPARSE) || defined(CONFIG_X86_VISWS)
939 940 941
	/*
	 * get boot-time SMP configuration:
	 */
942 943 944
	if (smp_found_config)
		get_smp_config();
#endif
945

946
	prefill_possible_map();
Y
Yinghai Lu 已提交
947

948 949 950 951
#ifdef CONFIG_X86_64
	init_cpu_to_node();
#endif

952 953
	init_apic_mappings();
	ioapic_init_mappings();
954

955
	/* need to wait for io_apic is mapped */
956
	probe_nr_irqs_gsi();
957

958
	kvm_guest_init();
L
Linus Torvalds 已提交
959

960
	e820_reserve_resources();
961
	e820_mark_nosave_regions(max_low_pfn);
L
Linus Torvalds 已提交
962

963
#ifdef CONFIG_X86_32
964
	request_resource(&iomem_resource, &video_ram_resource);
965
#endif
966
	reserve_standard_io_resources();
967 968 969

	e820_setup_gap();

L
Linus Torvalds 已提交
970 971 972 973 974 975 976 977 978
#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
}
979 980