[mirror_ubuntu-artful-kernel.git] / arch / x86 / kernel / setup_32.c

/*
 *  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>
#include <linux/mmzone.h>
#include <linux/screen_info.h>
#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>
#include <linux/iscsi_ibft.h>
#include <linux/nodemask.h>
#include <linux/kexec.h>
#include <linux/dmi.h>
#include <linux/pfn.h>
#include <linux/pci.h>
#include <linux/init_ohci1394_dma.h>
#include <linux/kvm_para.h>

#include <video/edid.h>

#include <asm/mtrr.h>
#include <asm/apic.h>
#include <asm/e820.h>
#include <asm/mpspec.h>
#include <asm/mmzone.h>
#include <asm/setup.h>
#include <asm/arch_hooks.h>
#include <asm/sections.h>
#include <asm/dmi.h>
#include <asm/io_apic.h>
#include <asm/ist.h>
#include <asm/io.h>
#include <asm/vmi.h>
#include <setup_arch.h>
#include <asm/bios_ebda.h>
#include <asm/cacheflush.h>
#include <asm/processor.h>
#include <asm/efi.h>
#include <asm/bugs.h>

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

/*
 * Machine setup..
 */
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
};

static struct resource video_ram_resource = {
	.name	= "Video RAM area",
	.start	= 0xa0000,
	.end	= 0xbffff,
	.flags	= IORESOURCE_BUSY | IORESOURCE_MEM
};

/* cpu data as detected by the assembly code in head.S */
struct cpuinfo_x86 new_cpu_data __cpuinitdata = { 0, 0, 0, 0, -1, 1, 0, 0, -1 };
/* common cpu data for all cpus */
struct cpuinfo_x86 boot_cpu_data __read_mostly = { 0, 0, 0, 0, -1, 1, 0, 0, -1 };
EXPORT_SYMBOL(boot_cpu_data);

unsigned int def_to_bigsmp;

#ifndef CONFIG_X86_PAE
unsigned long mmu_cr4_features;
#else
unsigned long mmu_cr4_features = X86_CR4_PAE;
#endif

/* for MCA, but anyone else can use it if they want */
unsigned int machine_id;
unsigned int machine_submodel_id;
unsigned int BIOS_revision;

/* Boot loader ID as an integer, for the benefit of proc_dointvec */
int bootloader_type;

/*
 * Early DMI memory
 */
int dmi_alloc_index;
char dmi_alloc_data[DMI_MAX_DATA];

/*
 * Setup options
 */
struct screen_info screen_info;
EXPORT_SYMBOL(screen_info);
struct apm_info apm_info;
EXPORT_SYMBOL(apm_info);
struct edid_info edid_info;
EXPORT_SYMBOL_GPL(edid_info);
struct ist_info ist_info;
#if defined(CONFIG_X86_SPEEDSTEP_SMI) || \
	defined(CONFIG_X86_SPEEDSTEP_SMI_MODULE)
EXPORT_SYMBOL(ist_info);
#endif

extern int root_mountflags;

unsigned long saved_video_mode;

#define RAMDISK_IMAGE_START_MASK	0x07FF
#define RAMDISK_PROMPT_FLAG		0x8000
#define RAMDISK_LOAD_FLAG		0x4000

static char __initdata command_line[COMMAND_LINE_SIZE];

#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)
{
     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;
}
#else
static inline void copy_edd(void)
{
}
#endif

#ifdef CONFIG_BLK_DEV_INITRD

static bool do_relocate_initrd = false;

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;
	u64 ramdisk_here;
	u64 ramdisk_target;

	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 "old 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;
	}

	/* We need to move the initrd down into lowmem */
	ramdisk_target = max_pfn_mapped<<PAGE_SHIFT;
	ramdisk_here = find_e820_area(min(ramdisk_target, end_of_lowmem>>1),
				 end_of_lowmem, ramdisk_size,
				 PAGE_SIZE);

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

	/* Note: this includes all the lowmem currently occupied by
	   the initrd, we rely on that fact to keep the data intact. */
	reserve_early(ramdisk_here, ramdisk_here + ramdisk_size,
			 "NEW RAMDISK");
	initrd_start = ramdisk_here + PAGE_OFFSET;
	initrd_end   = initrd_start + ramdisk_size;
	printk(KERN_INFO "Allocated new RAMDISK: %08llx - %08llx\n",
			 ramdisk_here, ramdisk_here + ramdisk_size);

	do_relocate_initrd = true;
}

#define MAX_MAP_CHUNK	(NR_FIX_BTMAPS << PAGE_SHIFT)

void __init post_reserve_initrd(void)
{
	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;
	unsigned long slop, clen, mapaddr;
	char *p, *q;

	if (!do_relocate_initrd)
		return;

	ramdisk_here = initrd_start - PAGE_OFFSET;

	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;
		/* need to free these low pages...*/
		printk(KERN_INFO "Freeing old partial RAMDISK %08llx-%08llx\n",
			 ramdisk_image, ramdisk_image + clen - 1);
		free_bootmem(ramdisk_image, 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;
		p = early_ioremap(mapaddr, clen+slop);
		memcpy(q, p+slop, clen);
		early_iounmap(p, clen+slop);
		q += clen;
		ramdisk_image += clen;
		ramdisk_size  -= clen;
	}
	/* high pages is not converted by early_res_to_bootmem */
	ramdisk_image = boot_params.hdr.ramdisk_image;
	ramdisk_size  = boot_params.hdr.ramdisk_size;
	printk(KERN_INFO "Copied RAMDISK from %016llx - %016llx to %08llx - %08llx\n",
		ramdisk_image, ramdisk_image + ramdisk_size - 1,
		ramdisk_here, ramdisk_here + ramdisk_size - 1);

	/* need to free that, otherwise init highmem will reserve it again */
	free_early(ramdisk_image, ramdisk_image+ramdisk_size);
}
#else
void __init reserve_initrd(void)
{
}
void __init post_reserve_initrd(void)
{
}
#endif /* CONFIG_BLK_DEV_INITRD */

#ifdef CONFIG_MCA
static void set_mca_bus(int x)
{
	MCA_bus = x;
}
#else
static void set_mca_bus(int x) { }
#endif

/*
 * 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.
 */
void __init setup_arch(char **cmdline_p)
{
	memcpy(&boot_cpu_data, &new_cpu_data, sizeof(new_cpu_data));
	pre_setup_arch_hook();
	early_cpu_init();
	early_ioremap_init();
	reserve_setup_data();

#ifdef CONFIG_EFI
	if (!strncmp((char *)&boot_params.efi_info.efi_loader_signature,
		     "EL32", 4)) {
		efi_enabled = 1;
		efi_reserve_early();
	}
#endif

	ROOT_DEV = old_decode_dev(boot_params.hdr.root_dev);
	screen_info = boot_params.screen_info;
	edid_info = boot_params.edid_info;
	apm_info.bios = boot_params.apm_bios_info;
	ist_info = boot_params.ist_info;
	saved_video_mode = boot_params.hdr.vid_mode;
	if( boot_params.sys_desc_table.length != 0 ) {
		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];
	}
	bootloader_type = boot_params.hdr.type_of_loader;

#ifdef CONFIG_BLK_DEV_RAM
	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);
#endif
	ARCH_SETUP

	setup_memory_map();

	copy_edd();

	if (!boot_params.hdr.root_flags)
		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;
	init_mm.brk = init_pg_tables_end + PAGE_OFFSET;

	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;
	bss_resource.start = virt_to_phys(&__bss_start);
	bss_resource.end = virt_to_phys(&__bss_stop)-1;

	parse_setup_data();

	parse_early_param();

	if (acpi_mps_check()){
#ifdef CONFIG_X86_LOCAL_APIC
		enable_local_apic = -1;
#endif
		clear_cpu_cap(&boot_cpu_data, X86_FEATURE_APIC);
	}

	finish_e820_parsing();

	probe_roms();

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

	strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE);
	*cmdline_p = command_line;

	if (efi_enabled)
		efi_init();

	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");
	}

	e820_register_active_regions(0, 0, -1UL);
	/*
	 * partially used pages are not usable - thus
	 * we are rounding upwards:
	 */
	max_pfn = e820_end_of_ram();

	/* preallocate 4k for mptable mpc */
	early_reserve_e820_mpc_new();
	/* update e820 for memory not covered by WB MTRRs */
	mtrr_bp_init();
	if (mtrr_trim_uncached_memory(max_pfn)) {
		remove_all_active_ranges();
		e820_register_active_regions(0, 0, -1UL);
		max_pfn = e820_end_of_ram();
	}

	find_low_pfn_range();

	reserve_initrd();

	dmi_scan_machine();

	io_delay_init();

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

#ifdef CONFIG_ACPI_NUMA
        /*
         * Parse SRAT to discover nodes.
         */
        acpi_numa_init();
#endif

	initmem_init(0, max_pfn);

#ifdef CONFIG_ACPI_SLEEP
	/*
	 * Reserve low memory region for sleep support.
	 */
	acpi_reserve_bootmem();
#endif
#ifdef CONFIG_X86_FIND_SMP_CONFIG
	/*
	 * Find and reserve possible boot-time SMP configuration:
	 */
	find_smp_config();
#endif
	reserve_crashkernel();

	reserve_ibft_region();

#ifdef CONFIG_KVM_CLOCK
	kvmclock_init();
#endif

#ifdef CONFIG_VMI
	/*
	 * Must be after max_low_pfn is determined, and before kernel
	 * pagetables are setup.
	 */
	vmi_init();
#endif
	kvm_guest_init();

	/*
	 * NOTE: before this point _nobody_ is allowed to allocate
	 * any memory using the bootmem allocator.  Although the
	 * allocator is now initialised only the first 8Mb of the kernel
	 * virtual address space has been mapped.  All allocations before
	 * paging_init() has completed must use the alloc_bootmem_low_pages()
	 * variant (which allocates DMA'able memory) and care must be taken
	 * not to exceed the 8Mb limit.
	 */

	paging_init();

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

#ifdef CONFIG_X86_GENERICARCH
	generic_apic_probe();
#endif

	early_quirks();

	acpi_boot_init();

#if defined(CONFIG_X86_MPPARSE) || defined(CONFIG_X86_VISWS)
	if (smp_found_config)
		get_smp_config();
#endif
#if defined(CONFIG_SMP) && defined(CONFIG_X86_PC)
	if (def_to_bigsmp)
		printk(KERN_WARNING "More than 8 CPUs detected and "
			"CONFIG_X86_PC cannot handle it.\nUse "
			"CONFIG_X86_GENERICARCH or CONFIG_X86_BIGSMP.\n");
#endif

	e820_reserve_resources();
	e820_mark_nosave_regions(max_low_pfn);

	request_resource(&iomem_resource, &video_ram_resource);
	reserve_standard_io_resources();

	e820_setup_gap();

#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
}
Commit	Line	Data
1da177e4	1	/*
1da177e4 LT	2	* Copyright (C) 1995 Linus Torvalds
	3	*
	4	* Support of BIGMEM added by Gerhard Wichert, Siemens AG, July 1999
	5	*
	6	* Memory region support
	7	* David Parsons <orc@pell.chi.il.us>, July-August 1999
	8	*
	9	* Added E820 sanitization routine (removes overlapping memory regions);
	10	* Brian Moyle <bmoyle@mvista.com>, February 2001
	11	*
	12	* Moved CPU detection code to cpu/${cpu}.c
	13	* Patrick Mochel <mochel@osdl.org>, March 2002
	14	*
	15	* Provisions for empty E820 memory regions (reported by certain BIOSes).
	16	* Alex Achenbach <xela@slit.de>, December 2002.
	17	*
	18	*/
	19
	20	/*
	21	* This file handles the architecture-dependent parts of initialization
	22	*/
	23
	24	#include <linux/sched.h>
	25	#include <linux/mm.h>
05b79bdc	26	#include <linux/mmzone.h>
894673ee	27	#include <linux/screen_info.h>
1da177e4 LT	28	#include <linux/ioport.h>
	29	#include <linux/acpi.h>
	30	#include <linux/apm_bios.h>
	31	#include <linux/initrd.h>
	32	#include <linux/bootmem.h>
	33	#include <linux/seq_file.h>
	34	#include <linux/console.h>
	35	#include <linux/mca.h>
	36	#include <linux/root_dev.h>
	37	#include <linux/highmem.h>
	38	#include <linux/module.h>
	39	#include <linux/efi.h>
	40	#include <linux/init.h>
	41	#include <linux/edd.h>
138fe4e0	42	#include <linux/iscsi_ibft.h>
1da177e4	43	#include <linux/nodemask.h>
1bc3b91a	44	#include <linux/kexec.h>
e9928674	45	#include <linux/dmi.h>
22a9835c	46	#include <linux/pfn.h>
376ff035	47	#include <linux/pci.h>
f212ec4b	48	#include <linux/init_ohci1394_dma.h>
790c73f6	49	#include <linux/kvm_para.h>
1bc3b91a	50
1da177e4	51	#include <video/edid.h>
1bc3b91a	52
093af8d7	53	#include <asm/mtrr.h>
9635b47d	54	#include <asm/apic.h>
1da177e4 LT	55	#include <asm/e820.h>
1da177e4 LT	56	#include <asm/mpspec.h>
91023300	57	#include <asm/mmzone.h>
1da177e4 LT	58	#include <asm/setup.h>
	59	#include <asm/arch_hooks.h>
	60	#include <asm/sections.h>
1c6e5503	61	#include <asm/dmi.h>
1da177e4 LT	62	#include <asm/io_apic.h>
	63	#include <asm/ist.h>
	64	#include <asm/io.h>
7ce0bcfd	65	#include <asm/vmi.h>
e75eac33	66	#include <setup_arch.h>
ce3fe6b2	67	#include <asm/bios_ebda.h>
00bf4098	68	#include <asm/cacheflush.h>
2fde61fd	69	#include <asm/processor.h>
ecacf09f	70	#include <asm/efi.h>
cc9f7a0c	71	#include <asm/bugs.h>
1da177e4 LT	72
	73	/* This value is set up by the early boot code to point to the value
	74	immediately after the boot time page tables. It contains a physical
	75	address, and must not be in the .bss segment! */
f0d43100	76	unsigned long init_pg_tables_start __initdata = ~0UL;
1da177e4 LT	77	unsigned long init_pg_tables_end __initdata = ~0UL;
1da177e4 LT	78
1da177e4 LT	79	/*
	80	* Machine setup..
	81	*/
c9cce83d BW	82	static struct resource data_resource = {
	83	.name = "Kernel data",
	84	.start = 0,
	85	.end = 0,
	86	.flags = IORESOURCE_BUSY \| IORESOURCE_MEM
	87	};
	88
	89	static struct resource code_resource = {
	90	.name = "Kernel code",
	91	.start = 0,
	92	.end = 0,
	93	.flags = IORESOURCE_BUSY \| IORESOURCE_MEM
	94	};
	95
	96	static struct resource bss_resource = {
	97	.name = "Kernel bss",
	98	.start = 0,
	99	.end = 0,
	100	.flags = IORESOURCE_BUSY \| IORESOURCE_MEM
	101	};
	102
	103	static struct resource video_ram_resource = {
	104	.name = "Video RAM area",
	105	.start = 0xa0000,
	106	.end = 0xbffff,
	107	.flags = IORESOURCE_BUSY \| IORESOURCE_MEM
	108	};
	109
1da177e4	110	/* cpu data as detected by the assembly code in head.S */
4a5d107a	111	struct cpuinfo_x86 new_cpu_data __cpuinitdata = { 0, 0, 0, 0, -1, 1, 0, 0, -1 };
1da177e4	112	/* common cpu data for all cpus */
c3d8c141	113	struct cpuinfo_x86 boot_cpu_data __read_mostly = { 0, 0, 0, 0, -1, 1, 0, 0, -1 };
129f6946	114	EXPORT_SYMBOL(boot_cpu_data);
1da177e4	115
0c254e38 AS	116	unsigned int def_to_bigsmp;
0c254e38 AS	117
551889a6	118	#ifndef CONFIG_X86_PAE
1da177e4	119	unsigned long mmu_cr4_features;
551889a6 IC	120	#else
	121	unsigned long mmu_cr4_features = X86_CR4_PAE;
	122	#endif
1da177e4	123
1da177e4 LT	124	/* for MCA, but anyone else can use it if they want */
	125	unsigned int machine_id;
	126	unsigned int machine_submodel_id;
	127	unsigned int BIOS_revision;
1da177e4	128
1da177e4 LT	129	/* Boot loader ID as an integer, for the benefit of proc_dointvec */
	130	int bootloader_type;
	131
1c6e5503 YL	132	/*
	133	* Early DMI memory
	134	*/
	135	int dmi_alloc_index;
	136	char dmi_alloc_data[DMI_MAX_DATA];
	137
1da177e4 LT	138	/*
	139	* Setup options
	140	*/
1da177e4	141	struct screen_info screen_info;
129f6946	142	EXPORT_SYMBOL(screen_info);
1da177e4	143	struct apm_info apm_info;
129f6946	144	EXPORT_SYMBOL(apm_info);
1da177e4	145	struct edid_info edid_info;
5e518d76	146	EXPORT_SYMBOL_GPL(edid_info);
1da177e4	147	struct ist_info ist_info;
129f6946 AD	148	#if defined(CONFIG_X86_SPEEDSTEP_SMI) \|\| \
	149	defined(CONFIG_X86_SPEEDSTEP_SMI_MODULE)
	150	EXPORT_SYMBOL(ist_info);
	151	#endif
1da177e4	152
1da177e4 LT	153	extern int root_mountflags;
1da177e4 LT	154
e44b7b75	155	unsigned long saved_video_mode;
1da177e4	156
cf8fa920	157	#define RAMDISK_IMAGE_START_MASK 0x07FF
1da177e4	158	#define RAMDISK_PROMPT_FLAG 0x8000
cf8fa920	159	#define RAMDISK_LOAD_FLAG 0x4000
1da177e4	160
4e498b66	161	static char __initdata command_line[COMMAND_LINE_SIZE];
1da177e4	162
1da177e4 LT	163	#if defined(CONFIG_EDD) \|\| defined(CONFIG_EDD_MODULE)
	164	struct edd edd;
	165	#ifdef CONFIG_EDD_MODULE
	166	EXPORT_SYMBOL(edd);
	167	#endif
	168	/**
	169	* copy_edd() - Copy the BIOS EDD information
	170	* from boot_params into a safe place.
	171	*
	172	*/
	173	static inline void copy_edd(void)
	174	{
30c82645 PA	175	memcpy(edd.mbr_signature, boot_params.edd_mbr_sig_buffer,
	176	sizeof(edd.mbr_signature));
	177	memcpy(edd.edd_info, boot_params.eddbuf, sizeof(edd.edd_info));
	178	edd.mbr_signature_nr = boot_params.edd_mbr_sig_buf_entries;
	179	edd.edd_info_nr = boot_params.eddbuf_entries;
1da177e4 LT	180	}
	181	#else
	182	static inline void copy_edd(void)
	183	{
	184	}
	185	#endif
	186
cf8fa920 PA	187	#ifdef CONFIG_BLK_DEV_INITRD
	188
	189	static bool do_relocate_initrd = false;
	190
2ec65f8b	191	static void __init reserve_initrd(void)
cf8fa920	192	{
ba5b14cc YL	193	u64 ramdisk_image = boot_params.hdr.ramdisk_image;
	194	u64 ramdisk_size = boot_params.hdr.ramdisk_size;
	195	u64 ramdisk_end = ramdisk_image + ramdisk_size;
	196	u64 end_of_lowmem = max_low_pfn << PAGE_SHIFT;
	197	u64 ramdisk_here;
2ec65f8b	198	u64 ramdisk_target;
cf8fa920	199
cf8fa920 PA	200	if (!boot_params.hdr.type_of_loader \|\|
	201	!ramdisk_image \|\| !ramdisk_size)
	202	return; /* No initrd provided by bootloader */
	203
a4c81cf6 YL	204	initrd_start = 0;
a4c81cf6 YL	205
2ec65f8b	206	if (ramdisk_size >= (end_of_lowmem>>1)) {
3945e2c9	207	free_early(ramdisk_image, ramdisk_end);
cf8fa920 PA	208	printk(KERN_ERR "initrd too large to handle, "
	209	"disabling initrd\n");
	210	return;
	211	}
a4c81cf6	212
f0d43100 YL	213	printk(KERN_INFO "old RAMDISK: %08llx - %08llx\n", ramdisk_image,
	214	ramdisk_end);
	215
	216
cf8fa920 PA	217	if (ramdisk_end <= end_of_lowmem) {
cf8fa920 PA	218	/* All in lowmem, easy case */
a4c81cf6 YL	219	/*
a4c81cf6 YL	220	* don't need to reserve again, already reserved early
ba5b14cc	221	* in i386_start_kernel
a4c81cf6	222	*/
cf8fa920	223	initrd_start = ramdisk_image + PAGE_OFFSET;
225c37d7	224	initrd_end = initrd_start + ramdisk_size;
cf8fa920 PA	225	return;
	226	}
	227
	228	/* We need to move the initrd down into lowmem */
2ec65f8b YL	229	ramdisk_target = max_pfn_mapped<<PAGE_SHIFT;
2ec65f8b YL	230	ramdisk_here = find_e820_area(min(ramdisk_target, end_of_lowmem>>1),
ba5b14cc YL	231	end_of_lowmem, ramdisk_size,
ba5b14cc YL	232	PAGE_SIZE);
cf8fa920	233
3945e2c9 YL	234	if (ramdisk_here == -1ULL)
	235	panic("Cannot find place for new RAMDISK of size %lld\n",
	236	ramdisk_size);
	237
cf8fa920 PA	238	/* Note: this includes all the lowmem currently occupied by
cf8fa920 PA	239	the initrd, we rely on that fact to keep the data intact. */
3945e2c9	240	reserve_early(ramdisk_here, ramdisk_here + ramdisk_size,
ba5b14cc	241	"NEW RAMDISK");
cf8fa920 PA	242	initrd_start = ramdisk_here + PAGE_OFFSET;
cf8fa920 PA	243	initrd_end = initrd_start + ramdisk_size;
f0d43100 YL	244	printk(KERN_INFO "Allocated new RAMDISK: %08llx - %08llx\n",
f0d43100 YL	245	ramdisk_here, ramdisk_here + ramdisk_size);
cf8fa920 PA	246
	247	do_relocate_initrd = true;
	248	}
	249
	250	#define MAX_MAP_CHUNK (NR_FIX_BTMAPS << PAGE_SHIFT)
	251
11cd0bc1	252	void __init post_reserve_initrd(void)
cf8fa920	253	{
ba5b14cc YL	254	u64 ramdisk_image = boot_params.hdr.ramdisk_image;
	255	u64 ramdisk_size = boot_params.hdr.ramdisk_size;
	256	u64 end_of_lowmem = max_low_pfn << PAGE_SHIFT;
	257	u64 ramdisk_here;
cf8fa920 PA	258	unsigned long slop, clen, mapaddr;
	259	char p, q;
	260
	261	if (!do_relocate_initrd)
	262	return;
	263
	264	ramdisk_here = initrd_start - PAGE_OFFSET;
	265
	266	q = (char *)initrd_start;
	267
	268	/* Copy any lowmem portion of the initrd */
	269	if (ramdisk_image < end_of_lowmem) {
	270	clen = end_of_lowmem - ramdisk_image;
	271	p = (char *)__va(ramdisk_image);
	272	memcpy(q, p, clen);
	273	q += clen;
a4c81cf6	274	/* need to free these low pages...*/
ba5b14cc YL	275	printk(KERN_INFO "Freeing old partial RAMDISK %08llx-%08llx\n",
ba5b14cc YL	276	ramdisk_image, ramdisk_image + clen - 1);
a4c81cf6	277	free_bootmem(ramdisk_image, clen);
cf8fa920 PA	278	ramdisk_image += clen;
	279	ramdisk_size -= clen;
	280	}
	281
	282	/* Copy the highmem portion of the initrd */
	283	while (ramdisk_size) {
	284	slop = ramdisk_image & ~PAGE_MASK;
	285	clen = ramdisk_size;
	286	if (clen > MAX_MAP_CHUNK-slop)
	287	clen = MAX_MAP_CHUNK-slop;
	288	mapaddr = ramdisk_image & PAGE_MASK;
beacfaac	289	p = early_ioremap(mapaddr, clen+slop);
cf8fa920	290	memcpy(q, p+slop, clen);
beacfaac	291	early_iounmap(p, clen+slop);
cf8fa920 PA	292	q += clen;
	293	ramdisk_image += clen;
	294	ramdisk_size -= clen;
	295	}
a4c81cf6	296	/* high pages is not converted by early_res_to_bootmem */
ba5b14cc YL	297	ramdisk_image = boot_params.hdr.ramdisk_image;
	298	ramdisk_size = boot_params.hdr.ramdisk_size;
	299	printk(KERN_INFO "Copied RAMDISK from %016llx - %016llx to %08llx - %08llx\n",
	300	ramdisk_image, ramdisk_image + ramdisk_size - 1,
	301	ramdisk_here, ramdisk_here + ramdisk_size - 1);
9a27f5c5 YL	302
	303	/* need to free that, otherwise init highmem will reserve it again */
	304	free_early(ramdisk_image, ramdisk_image+ramdisk_size);
cf8fa920	305	}
225c37d7 YL	306	#else
	307	void __init reserve_initrd(void)
	308	{
	309	}
11cd0bc1	310	void __init post_reserve_initrd(void)
225c37d7 YL	311	{
225c37d7 YL	312	}
cf8fa920 PA	313	#endif /* CONFIG_BLK_DEV_INITRD */
cf8fa920 PA	314
1da177e4 LT	315	#ifdef CONFIG_MCA
	316	static void set_mca_bus(int x)
	317	{
	318	MCA_bus = x;
	319	}
	320	#else
	321	static void set_mca_bus(int x) { }
	322	#endif
	323
	324	/*
	325	* Determine if we were loaded by an EFI loader. If so, then we have also been
	326	* passed the efi memmap, systab, etc., so we should use these data structures
	327	* for initialization. Note, the efi init code path is determined by the
	328	* global efi_enabled. This allows the same kernel image to be used on existing
	329	* systems (with a traditional BIOS) as well as on EFI systems.
	330	*/
	331	void __init setup_arch(char **cmdline_p)
	332	{
1da177e4 LT	333	memcpy(&boot_cpu_data, &new_cpu_data, sizeof(new_cpu_data));
	334	pre_setup_arch_hook();
	335	early_cpu_init();
beacfaac	336	early_ioremap_init();
c45a707d	337	reserve_setup_data();
1da177e4	338
1da177e4	339	#ifdef CONFIG_EFI
e429795c	340	if (!strncmp((char *)&boot_params.efi_info.efi_loader_signature,
ecacf09f	341	"EL32", 4)) {
1da177e4	342	efi_enabled = 1;
ecacf09f HY	343	efi_reserve_early();
ecacf09f HY	344	}
1da177e4 LT	345	#endif
1da177e4 LT	346
30c82645 PA	347	ROOT_DEV = old_decode_dev(boot_params.hdr.root_dev);
	348	screen_info = boot_params.screen_info;
	349	edid_info = boot_params.edid_info;
	350	apm_info.bios = boot_params.apm_bios_info;
	351	ist_info = boot_params.ist_info;
e44b7b75	352	saved_video_mode = boot_params.hdr.vid_mode;
30c82645 PA	353	if( boot_params.sys_desc_table.length != 0 ) {
	354	set_mca_bus(boot_params.sys_desc_table.table[3] & 0x2);
	355	machine_id = boot_params.sys_desc_table.table[0];
	356	machine_submodel_id = boot_params.sys_desc_table.table[1];
	357	BIOS_revision = boot_params.sys_desc_table.table[2];
1da177e4	358	}
30c82645	359	bootloader_type = boot_params.hdr.type_of_loader;
1da177e4 LT	360
1da177e4 LT	361	#ifdef CONFIG_BLK_DEV_RAM
30c82645 PA	362	rd_image_start = boot_params.hdr.ram_size & RAMDISK_IMAGE_START_MASK;
	363	rd_prompt = ((boot_params.hdr.ram_size & RAMDISK_PROMPT_FLAG) != 0);
	364	rd_doload = ((boot_params.hdr.ram_size & RAMDISK_LOAD_FLAG) != 0);
1da177e4 LT	365	#endif
1da177e4 LT	366	ARCH_SETUP
2215e69d	367
0dbfafa5	368	setup_memory_map();
2215e69d	369
1da177e4 LT	370	copy_edd();
1da177e4 LT	371
30c82645	372	if (!boot_params.hdr.root_flags)
1da177e4 LT	373	root_mountflags &= ~MS_RDONLY;
	374	init_mm.start_code = (unsigned long) _text;
	375	init_mm.end_code = (unsigned long) _etext;
	376	init_mm.end_data = (unsigned long) _edata;
	377	init_mm.brk = init_pg_tables_end + PAGE_OFFSET;
	378
	379	code_resource.start = virt_to_phys(_text);
	380	code_resource.end = virt_to_phys(_etext)-1;
	381	data_resource.start = virt_to_phys(_etext);
	382	data_resource.end = virt_to_phys(_edata)-1;
00bf4098 BW	383	bss_resource.start = virt_to_phys(&__bss_start);
00bf4098 BW	384	bss_resource.end = virt_to_phys(&__bss_stop)-1;
1da177e4	385
c45a707d HY	386	parse_setup_data();
c45a707d HY	387
1a3f239d	388	parse_early_param();
1da177e4	389
3c999f14	390	if (acpi_mps_check()){
3eb11edc	391	#ifdef CONFIG_X86_LOCAL_APIC
3c999f14	392	enable_local_apic = -1;
3eb11edc	393	#endif
3c999f14 YL	394	clear_cpu_cap(&boot_cpu_data, X86_FEATURE_APIC);
	395	}
	396
0dbfafa5	397	finish_e820_parsing();
1a3f239d	398
41c094fd YL	399	probe_roms();
	400
	401	/* after parse_early_param, so could debug it */
	402	insert_resource(&iomem_resource, &code_resource);
	403	insert_resource(&iomem_resource, &data_resource);
	404	insert_resource(&iomem_resource, &bss_resource);
	405
4e498b66	406	strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE);
1a3f239d	407	*cmdline_p = command_line;
99b7de33	408
8b2cb7a8 HY	409	if (efi_enabled)
	410	efi_init();
	411
cc9f7a0c YL	412	if (ppro_with_ram_bug()) {
	413	e820_update_range(0x70000000ULL, 0x40000ULL, E820_RAM,
	414	E820_RESERVED);
	415	sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
	416	printk(KERN_INFO "fixed physical RAM map:\n");
	417	e820_print_map("bad_ppro");
	418	}
	419
7b2a0a6c YL	420	e820_register_active_regions(0, 0, -1UL);
	421	/*
	422	* partially used pages are not usable - thus
	423	* we are rounding upwards:
	424	*/
	425	max_pfn = e820_end_of_ram();
	426
6780711e YL	427	/* preallocate 4k for mptable mpc */
6780711e YL	428	early_reserve_e820_mpc_new();
093af8d7 YL	429	/* update e820 for memory not covered by WB MTRRs */
093af8d7 YL	430	mtrr_bp_init();
7b2a0a6c YL	431	if (mtrr_trim_uncached_memory(max_pfn)) {
	432	remove_all_active_ranges();
	433	e820_register_active_regions(0, 0, -1UL);
	434	max_pfn = e820_end_of_ram();
	435	}
76c32418	436
2ec65f8b YL	437	find_low_pfn_range();
	438
	439	reserve_initrd();
	440
1c6e5503 YL	441	dmi_scan_machine();
	442
	443	io_delay_init();
	444
1c6e5503 YL	445	/*
	446	* Parse the ACPI tables for possible boot-time SMP configuration.
	447	*/
	448	acpi_boot_table_init();
1c6e5503 YL	449
	450	#ifdef CONFIG_ACPI_NUMA
	451	/*
	452	* Parse SRAT to discover nodes.
	453	*/
	454	acpi_numa_init();
	455	#endif
	456
2ec65f8b	457	initmem_init(0, max_pfn);
093af8d7	458
593a0cc3 YL	459	#ifdef CONFIG_ACPI_SLEEP
	460	/*
	461	* Reserve low memory region for sleep support.
	462	*/
	463	acpi_reserve_bootmem();
	464	#endif
	465	#ifdef CONFIG_X86_FIND_SMP_CONFIG
	466	/*
	467	* Find and reserve possible boot-time SMP configuration:
	468	*/
	469	find_smp_config();
	470	#endif
	471	reserve_crashkernel();
	472
	473	reserve_ibft_region();
	474
790c73f6 GOC	475	#ifdef CONFIG_KVM_CLOCK
	476	kvmclock_init();
	477	#endif
	478
7ce0bcfd ZA	479	#ifdef CONFIG_VMI
	480	/*
	481	* Must be after max_low_pfn is determined, and before kernel
	482	* pagetables are setup.
	483	*/
	484	vmi_init();
	485	#endif
0cf1bfd2	486	kvm_guest_init();
7ce0bcfd	487
1da177e4 LT	488	/*
	489	* NOTE: before this point _nobody_ is allowed to allocate
	490	* any memory using the bootmem allocator. Although the
27b46d76	491	* allocator is now initialised only the first 8Mb of the kernel
1da177e4 LT	492	* virtual address space has been mapped. All allocations before
	493	* paging_init() has completed must use the alloc_bootmem_low_pages()
	494	* variant (which allocates DMA'able memory) and care must be taken
	495	* not to exceed the 8Mb limit.
	496	*/
	497
1da177e4	498	paging_init();
f212ec4b BK	499
	500	/*
	501	* NOTE: On x86-32, only from this point on, fixmaps are ready for use.
	502	*/
	503
	504	#ifdef CONFIG_PROVIDE_OHCI1394_DMA_INIT
	505	if (init_ohci1394_dma_early)
	506	init_ohci1394_dma_on_all_controllers();
	507	#endif
	508
1da177e4	509	#ifdef CONFIG_X86_GENERICARCH
1a3f239d	510	generic_apic_probe();
cf8fa920	511	#endif
1da177e4	512
54ef3400	513	early_quirks();
d44647b0	514
1da177e4	515	acpi_boot_init();
04606618	516
e0da3364 YL	517	#if defined(CONFIG_X86_MPPARSE) \|\| defined(CONFIG_X86_VISWS)
	518	if (smp_found_config)
	519	get_smp_config();
	520	#endif
911a62d4 VP	521	#if defined(CONFIG_SMP) && defined(CONFIG_X86_PC)
	522	if (def_to_bigsmp)
	523	printk(KERN_WARNING "More than 8 CPUs detected and "
	524	"CONFIG_X86_PC cannot handle it.\nUse "
	525	"CONFIG_X86_GENERICARCH or CONFIG_X86_BIGSMP.\n");
	526	#endif
1da177e4	527
41c094fd	528	e820_reserve_resources();
bf62f398	529	e820_mark_nosave_regions(max_low_pfn);
1da177e4	530
41c094fd	531	request_resource(&iomem_resource, &video_ram_resource);
ce97c40e	532	reserve_standard_io_resources();
41c094fd YL	533
	534	e820_setup_gap();
	535
1da177e4 LT	536	#ifdef CONFIG_VT
	537	#if defined(CONFIG_VGA_CONSOLE)
	538	if (!efi_enabled \|\| (efi_mem_type(0xa0000) != EFI_CONVENTIONAL_MEMORY))
	539	conswitchp = &vga_con;
	540	#elif defined(CONFIG_DUMMY_CONSOLE)
	541	conswitchp = &dummy_con;
	542	#endif
	543	#endif
	544	}
c9cce83d	545