[GitHub/mt8127/android_kernel_alcatel_ttab.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 <asm/pci-direct.h>
#include <linux/init_ohci1394_dma.h>
#include <linux/kvm_para.h>

#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/highmem.h>

#include <linux/kallsyms.h>
#include <linux/edd.h>
#include <linux/iscsi_ibft.h>
#include <linux/kexec.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>

#include <video/edid.h>

#include <asm/mtrr.h>
#include <asm/apic.h>
#include <asm/e820.h>
#include <asm/mpspec.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/vmi.h>
#include <setup_arch.h>
#include <asm/bios_ebda.h>
#include <asm/cacheflush.h>
#include <asm/processor.h>
#include <asm/bugs.h>

#include <asm/system.h>
#include <asm/vsyscall.h>
#include <asm/smp.h>
#include <asm/desc.h>
#include <asm/dma.h>
#include <asm/gart.h>
#include <asm/mmu_context.h>
#include <asm/proto.h>

#include <mach_apic.h>
#ifdef CONFIG_PARAVIRT
#include <asm/paravirt.h>
#else
#define ARCH_SETUP
#endif

#include <asm/percpu.h>
#include <asm/sections.h>
#include <asm/topology.h>
#include <asm/apicdef.h>
#ifdef CONFIG_X86_32
#include <asm/highmem.h>
#endif

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


#ifdef CONFIG_X86_32
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);
static void set_mca_bus(int x)
{
#ifdef CONFIG_MCA
	MCA_bus = x;
#endif
}

unsigned int def_to_bigsmp;

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

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

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

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

#ifdef CONFIG_X86_32

#define MAX_MAP_CHUNK	(NR_FIX_BTMAPS << PAGE_SHIFT)
static void __init relocate_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;

	/* We need to move the initrd down into lowmem */
	ramdisk_here = find_e820_area(0, 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);

	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;
		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 "Move RAMDISK from %016llx - %016llx to"
		" %08llx - %08llx\n",
		ramdisk_image, ramdisk_image + ramdisk_size - 1,
		ramdisk_here, ramdisk_here + ramdisk_size - 1);
}
#endif

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);
}
#else
static void __init reserve_initrd(void)
{
}
#endif /* CONFIG_BLK_DEV_INITRD */

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

	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
#ifdef CONFIG_EFI
	if (!strncmp((char *)&boot_params.efi_info.efi_loader_signature,
		     "EL32", 4)) {
		efi_enabled = 1;
		efi_reserve_early();
	}
#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;

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

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

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

	/* max_low_pfn get updated here */
	find_low_pfn_range();

	/* max_pfn_mapped is updated here */
	max_pfn_mapped = init_memory_mapping(0, (max_low_pfn << PAGE_SHIFT));

	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

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

	/*
	 * Read APIC and some other early information from ACPI tables.
	 */
	acpi_boot_init();

#if defined(CONFIG_X86_MPPARSE) || defined(CONFIG_X86_VISWS)
	/*
	 * get boot-time SMP configuration:
	 */
	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
	kvm_guest_init();

	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>
46d671b5	48	#include <asm/pci-direct.h>
f212ec4b	49	#include <linux/init_ohci1394_dma.h>
790c73f6	50	#include <linux/kvm_para.h>
1bc3b91a	51
46d671b5 YL	52	#include <linux/errno.h>
	53	#include <linux/kernel.h>
	54	#include <linux/stddef.h>
	55	#include <linux/unistd.h>
	56	#include <linux/ptrace.h>
	57	#include <linux/slab.h>
	58	#include <linux/user.h>
	59	#include <linux/delay.h>
	60	#include <linux/highmem.h>
	61
	62	#include <linux/kallsyms.h>
	63	#include <linux/edd.h>
	64	#include <linux/iscsi_ibft.h>
	65	#include <linux/kexec.h>
	66	#include <linux/cpufreq.h>
	67	#include <linux/dma-mapping.h>
	68	#include <linux/ctype.h>
	69	#include <linux/uaccess.h>
	70
	71	#include <linux/percpu.h>
	72	#include <linux/crash_dump.h>
	73
1da177e4	74	#include <video/edid.h>
1bc3b91a	75
093af8d7	76	#include <asm/mtrr.h>
9635b47d	77	#include <asm/apic.h>
1da177e4 LT	78	#include <asm/e820.h>
	79	#include <asm/mpspec.h>
	80	#include <asm/setup.h>
	81	#include <asm/arch_hooks.h>
	82	#include <asm/sections.h>
1c6e5503	83	#include <asm/dmi.h>
1da177e4 LT	84	#include <asm/io_apic.h>
1da177e4 LT	85	#include <asm/ist.h>
7ce0bcfd	86	#include <asm/vmi.h>
e75eac33	87	#include <setup_arch.h>
ce3fe6b2	88	#include <asm/bios_ebda.h>
00bf4098	89	#include <asm/cacheflush.h>
2fde61fd	90	#include <asm/processor.h>
cc9f7a0c	91	#include <asm/bugs.h>
1da177e4	92
46d671b5 YL	93	#include <asm/system.h>
	94	#include <asm/vsyscall.h>
	95	#include <asm/smp.h>
	96	#include <asm/desc.h>
	97	#include <asm/dma.h>
	98	#include <asm/gart.h>
	99	#include <asm/mmu_context.h>
	100	#include <asm/proto.h>
	101
	102	#include <mach_apic.h>
	103	#ifdef CONFIG_PARAVIRT
	104	#include <asm/paravirt.h>
	105	#else
	106	#define ARCH_SETUP
	107	#endif
	108
	109	#include <asm/percpu.h>
	110	#include <asm/sections.h>
	111	#include <asm/topology.h>
	112	#include <asm/apicdef.h>
	113	#ifdef CONFIG_X86_32
	114	#include <asm/highmem.h>
	115	#endif
	116
1da177e4 LT	117	/* This value is set up by the early boot code to point to the value
	118	immediately after the boot time page tables. It contains a physical
	119	address, and must not be in the .bss segment! */
f0d43100	120	unsigned long init_pg_tables_start __initdata = ~0UL;
1da177e4 LT	121	unsigned long init_pg_tables_end __initdata = ~0UL;
1da177e4 LT	122
1da177e4 LT	123	/*
	124	* Machine setup..
	125	*/
c9cce83d BW	126	static struct resource data_resource = {
	127	.name = "Kernel data",
	128	.start = 0,
	129	.end = 0,
	130	.flags = IORESOURCE_BUSY \| IORESOURCE_MEM
	131	};
	132
	133	static struct resource code_resource = {
	134	.name = "Kernel code",
	135	.start = 0,
	136	.end = 0,
	137	.flags = IORESOURCE_BUSY \| IORESOURCE_MEM
	138	};
	139
	140	static struct resource bss_resource = {
	141	.name = "Kernel bss",
	142	.start = 0,
	143	.end = 0,
	144	.flags = IORESOURCE_BUSY \| IORESOURCE_MEM
	145	};
	146
7dea23ec YL	147
7dea23ec YL	148	#ifdef CONFIG_X86_32
c9cce83d BW	149	static struct resource video_ram_resource = {
	150	.name = "Video RAM area",
	151	.start = 0xa0000,
	152	.end = 0xbffff,
	153	.flags = IORESOURCE_BUSY \| IORESOURCE_MEM
	154	};
	155
1da177e4	156	/* cpu data as detected by the assembly code in head.S */
7dea23ec	157	struct cpuinfo_x86 new_cpu_data __cpuinitdata = {0, 0, 0, 0, -1, 1, 0, 0, -1};
1da177e4	158	/* common cpu data for all cpus */
7dea23ec	159	struct cpuinfo_x86 boot_cpu_data __read_mostly = {0, 0, 0, 0, -1, 1, 0, 0, -1};
129f6946	160	EXPORT_SYMBOL(boot_cpu_data);
7dea23ec YL	161	static void set_mca_bus(int x)
	162	{
	163	#ifdef CONFIG_MCA
	164	MCA_bus = x;
	165	#endif
	166	}
1da177e4	167
0c254e38 AS	168	unsigned int def_to_bigsmp;
0c254e38 AS	169
1da177e4 LT	170	/* for MCA, but anyone else can use it if they want */
	171	unsigned int machine_id;
	172	unsigned int machine_submodel_id;
	173	unsigned int BIOS_revision;
1da177e4	174
7dea23ec YL	175	struct apm_info apm_info;
	176	EXPORT_SYMBOL(apm_info);
	177
	178	#if defined(CONFIG_X86_SPEEDSTEP_SMI) \|\| \
	179	defined(CONFIG_X86_SPEEDSTEP_SMI_MODULE)
	180	struct ist_info ist_info;
	181	EXPORT_SYMBOL(ist_info);
	182	#else
	183	struct ist_info ist_info;
	184	#endif
	185
	186	#else
	187	struct cpuinfo_x86 boot_cpu_data __read_mostly;
	188	EXPORT_SYMBOL(boot_cpu_data);
	189	#endif
	190
	191
	192	#if !defined(CONFIG_X86_PAE) \|\| defined(CONFIG_X86_64)
	193	unsigned long mmu_cr4_features;
	194	#else
	195	unsigned long mmu_cr4_features = X86_CR4_PAE;
	196	#endif
	197
1da177e4 LT	198	/* Boot loader ID as an integer, for the benefit of proc_dointvec */
	199	int bootloader_type;
	200
1c6e5503 YL	201	/*
	202	* Early DMI memory
	203	*/
	204	int dmi_alloc_index;
	205	char dmi_alloc_data[DMI_MAX_DATA];
	206
1da177e4 LT	207	/*
	208	* Setup options
	209	*/
1da177e4	210	struct screen_info screen_info;
129f6946	211	EXPORT_SYMBOL(screen_info);
1da177e4	212	struct edid_info edid_info;
5e518d76	213	EXPORT_SYMBOL_GPL(edid_info);
1da177e4	214
1da177e4 LT	215	extern int root_mountflags;
1da177e4 LT	216
e44b7b75	217	unsigned long saved_video_mode;
1da177e4	218
cf8fa920	219	#define RAMDISK_IMAGE_START_MASK 0x07FF
1da177e4	220	#define RAMDISK_PROMPT_FLAG 0x8000
cf8fa920	221	#define RAMDISK_LOAD_FLAG 0x4000
1da177e4	222
4e498b66	223	static char __initdata command_line[COMMAND_LINE_SIZE];
1da177e4	224
1da177e4 LT	225	#if defined(CONFIG_EDD) \|\| defined(CONFIG_EDD_MODULE)
	226	struct edd edd;
	227	#ifdef CONFIG_EDD_MODULE
	228	EXPORT_SYMBOL(edd);
	229	#endif
	230	/**
	231	* copy_edd() - Copy the BIOS EDD information
	232	* from boot_params into a safe place.
	233	*
	234	*/
	235	static inline void copy_edd(void)
	236	{
30c82645 PA	237	memcpy(edd.mbr_signature, boot_params.edd_mbr_sig_buffer,
	238	sizeof(edd.mbr_signature));
	239	memcpy(edd.edd_info, boot_params.eddbuf, sizeof(edd.edd_info));
	240	edd.mbr_signature_nr = boot_params.edd_mbr_sig_buf_entries;
	241	edd.edd_info_nr = boot_params.eddbuf_entries;
1da177e4 LT	242	}
	243	#else
	244	static inline void copy_edd(void)
	245	{
	246	}
	247	#endif
	248
cf8fa920 PA	249	#ifdef CONFIG_BLK_DEV_INITRD
cf8fa920 PA	250
eb1379cb	251	#ifdef CONFIG_X86_32
cf8fa920	252
eb1379cb YL	253	#define MAX_MAP_CHUNK (NR_FIX_BTMAPS << PAGE_SHIFT)
eb1379cb YL	254	static void __init relocate_initrd(void)
cf8fa920	255	{
eb1379cb	256
ba5b14cc YL	257	u64 ramdisk_image = boot_params.hdr.ramdisk_image;
ba5b14cc YL	258	u64 ramdisk_size = boot_params.hdr.ramdisk_size;
ba5b14cc YL	259	u64 end_of_lowmem = max_low_pfn << PAGE_SHIFT;
ba5b14cc YL	260	u64 ramdisk_here;
eb1379cb YL	261	unsigned long slop, clen, mapaddr;
eb1379cb YL	262	char p, q;
cf8fa920 PA	263
cf8fa920 PA	264	/* We need to move the initrd down into lowmem */
4e29684c YL	265	ramdisk_here = find_e820_area(0, end_of_lowmem, ramdisk_size,
4e29684c YL	266	PAGE_SIZE);
cf8fa920	267
3945e2c9 YL	268	if (ramdisk_here == -1ULL)
	269	panic("Cannot find place for new RAMDISK of size %lld\n",
	270	ramdisk_size);
	271
cf8fa920 PA	272	/* Note: this includes all the lowmem currently occupied by
cf8fa920 PA	273	the initrd, we rely on that fact to keep the data intact. */
3945e2c9	274	reserve_early(ramdisk_here, ramdisk_here + ramdisk_size,
ba5b14cc	275	"NEW RAMDISK");
cf8fa920 PA	276	initrd_start = ramdisk_here + PAGE_OFFSET;
cf8fa920 PA	277	initrd_end = initrd_start + ramdisk_size;
f0d43100 YL	278	printk(KERN_INFO "Allocated new RAMDISK: %08llx - %08llx\n",
f0d43100 YL	279	ramdisk_here, ramdisk_here + ramdisk_size);
cf8fa920	280
cf8fa920 PA	281	q = (char *)initrd_start;
	282
	283	/* Copy any lowmem portion of the initrd */
	284	if (ramdisk_image < end_of_lowmem) {
	285	clen = end_of_lowmem - ramdisk_image;
	286	p = (char *)__va(ramdisk_image);
	287	memcpy(q, p, clen);
	288	q += clen;
	289	ramdisk_image += clen;
	290	ramdisk_size -= clen;
	291	}
	292
	293	/* Copy the highmem portion of the initrd */
	294	while (ramdisk_size) {
	295	slop = ramdisk_image & ~PAGE_MASK;
	296	clen = ramdisk_size;
	297	if (clen > MAX_MAP_CHUNK-slop)
	298	clen = MAX_MAP_CHUNK-slop;
	299	mapaddr = ramdisk_image & PAGE_MASK;
beacfaac	300	p = early_ioremap(mapaddr, clen+slop);
cf8fa920	301	memcpy(q, p+slop, clen);
beacfaac	302	early_iounmap(p, clen+slop);
cf8fa920 PA	303	q += clen;
	304	ramdisk_image += clen;
	305	ramdisk_size -= clen;
	306	}
a4c81cf6	307	/* high pages is not converted by early_res_to_bootmem */
ba5b14cc YL	308	ramdisk_image = boot_params.hdr.ramdisk_image;
ba5b14cc YL	309	ramdisk_size = boot_params.hdr.ramdisk_size;
eb1379cb YL	310	printk(KERN_INFO "Move RAMDISK from %016llx - %016llx to"
eb1379cb YL	311	" %08llx - %08llx\n",
ba5b14cc YL	312	ramdisk_image, ramdisk_image + ramdisk_size - 1,
ba5b14cc YL	313	ramdisk_here, ramdisk_here + ramdisk_size - 1);
eb1379cb YL	314	}
eb1379cb YL	315	#endif
9a27f5c5	316
eb1379cb YL	317	static void __init reserve_initrd(void)
	318	{
	319	u64 ramdisk_image = boot_params.hdr.ramdisk_image;
	320	u64 ramdisk_size = boot_params.hdr.ramdisk_size;
	321	u64 ramdisk_end = ramdisk_image + ramdisk_size;
	322	u64 end_of_lowmem = max_low_pfn << PAGE_SHIFT;
	323
	324	if (!boot_params.hdr.type_of_loader \|\|
	325	!ramdisk_image \|\| !ramdisk_size)
	326	return; /* No initrd provided by bootloader */
	327
	328	initrd_start = 0;
	329
	330	if (ramdisk_size >= (end_of_lowmem>>1)) {
	331	free_early(ramdisk_image, ramdisk_end);
	332	printk(KERN_ERR "initrd too large to handle, "
	333	"disabling initrd\n");
	334	return;
	335	}
	336
	337	printk(KERN_INFO "RAMDISK: %08llx - %08llx\n", ramdisk_image,
	338	ramdisk_end);
	339
	340
	341	if (ramdisk_end <= end_of_lowmem) {
	342	/* All in lowmem, easy case */
	343	/*
	344	* don't need to reserve again, already reserved early
	345	* in i386_start_kernel
	346	*/
	347	initrd_start = ramdisk_image + PAGE_OFFSET;
	348	initrd_end = initrd_start + ramdisk_size;
	349	return;
	350	}
	351
	352	#ifdef CONFIG_X86_32
	353	relocate_initrd();
	354	#else
	355	printk(KERN_ERR "initrd extends beyond end of memory "
	356	"(0x%08llx > 0x%08llx)\ndisabling initrd\n",
	357	ramdisk_end, end_of_lowmem);
	358	initrd_start = 0;
	359	#endif
	360	free_early(ramdisk_image, ramdisk_end);
cf8fa920	361	}
225c37d7	362	#else
eb1379cb	363	static void __init reserve_initrd(void)
225c37d7 YL	364	{
225c37d7 YL	365	}
cf8fa920 PA	366	#endif /* CONFIG_BLK_DEV_INITRD */
cf8fa920 PA	367
1da177e4 LT	368	/*
	369	* Determine if we were loaded by an EFI loader. If so, then we have also been
	370	* passed the efi memmap, systab, etc., so we should use these data structures
	371	* for initialization. Note, the efi init code path is determined by the
	372	* global efi_enabled. This allows the same kernel image to be used on existing
	373	* systems (with a traditional BIOS) as well as on EFI systems.
	374	*/
	375	void __init setup_arch(char **cmdline_p)
	376	{
1da177e4 LT	377	memcpy(&boot_cpu_data, &new_cpu_data, sizeof(new_cpu_data));
	378	pre_setup_arch_hook();
	379	early_cpu_init();
beacfaac	380	early_ioremap_init();
c45a707d	381	reserve_setup_data();
1da177e4	382
30c82645 PA	383	ROOT_DEV = old_decode_dev(boot_params.hdr.root_dev);
	384	screen_info = boot_params.screen_info;
	385	edid_info = boot_params.edid_info;
	386	apm_info.bios = boot_params.apm_bios_info;
	387	ist_info = boot_params.ist_info;
e44b7b75	388	saved_video_mode = boot_params.hdr.vid_mode;
30c82645 PA	389	if( boot_params.sys_desc_table.length != 0 ) {
	390	set_mca_bus(boot_params.sys_desc_table.table[3] & 0x2);
	391	machine_id = boot_params.sys_desc_table.table[0];
	392	machine_submodel_id = boot_params.sys_desc_table.table[1];
	393	BIOS_revision = boot_params.sys_desc_table.table[2];
1da177e4	394	}
30c82645	395	bootloader_type = boot_params.hdr.type_of_loader;
1da177e4 LT	396
1da177e4 LT	397	#ifdef CONFIG_BLK_DEV_RAM
30c82645 PA	398	rd_image_start = boot_params.hdr.ram_size & RAMDISK_IMAGE_START_MASK;
	399	rd_prompt = ((boot_params.hdr.ram_size & RAMDISK_PROMPT_FLAG) != 0);
	400	rd_doload = ((boot_params.hdr.ram_size & RAMDISK_LOAD_FLAG) != 0);
1da177e4	401	#endif
7465252e YL	402	#ifdef CONFIG_EFI
	403	if (!strncmp((char *)&boot_params.efi_info.efi_loader_signature,
	404	"EL32", 4)) {
	405	efi_enabled = 1;
	406	efi_reserve_early();
	407	}
	408	#endif
	409
1da177e4	410	ARCH_SETUP
2215e69d	411
0dbfafa5	412	setup_memory_map();
1da177e4 LT	413	copy_edd();
1da177e4 LT	414
30c82645	415	if (!boot_params.hdr.root_flags)
1da177e4 LT	416	root_mountflags &= ~MS_RDONLY;
	417	init_mm.start_code = (unsigned long) _text;
	418	init_mm.end_code = (unsigned long) _etext;
	419	init_mm.end_data = (unsigned long) _edata;
	420	init_mm.brk = init_pg_tables_end + PAGE_OFFSET;
	421
	422	code_resource.start = virt_to_phys(_text);
	423	code_resource.end = virt_to_phys(_etext)-1;
	424	data_resource.start = virt_to_phys(_etext);
	425	data_resource.end = virt_to_phys(_edata)-1;
00bf4098 BW	426	bss_resource.start = virt_to_phys(&__bss_start);
00bf4098 BW	427	bss_resource.end = virt_to_phys(&__bss_stop)-1;
1da177e4	428
9a2e5930 YL	429	strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE);
	430	*cmdline_p = command_line;
	431
c45a707d HY	432	parse_setup_data();
c45a707d HY	433
1a3f239d	434	parse_early_param();
1da177e4	435
3c999f14	436	if (acpi_mps_check()){
3eb11edc	437	#ifdef CONFIG_X86_LOCAL_APIC
3c999f14	438	enable_local_apic = -1;
3eb11edc	439	#endif
3c999f14 YL	440	clear_cpu_cap(&boot_cpu_data, X86_FEATURE_APIC);
	441	}
	442
0dbfafa5	443	finish_e820_parsing();
1a3f239d	444
41c094fd YL	445	probe_roms();
	446
	447	/* after parse_early_param, so could debug it */
	448	insert_resource(&iomem_resource, &code_resource);
	449	insert_resource(&iomem_resource, &data_resource);
	450	insert_resource(&iomem_resource, &bss_resource);
	451
8b2cb7a8 HY	452	if (efi_enabled)
	453	efi_init();
	454
cc9f7a0c YL	455	if (ppro_with_ram_bug()) {
	456	e820_update_range(0x70000000ULL, 0x40000ULL, E820_RAM,
	457	E820_RESERVED);
	458	sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
	459	printk(KERN_INFO "fixed physical RAM map:\n");
	460	e820_print_map("bad_ppro");
	461	}
	462
7b2a0a6c YL	463	e820_register_active_regions(0, 0, -1UL);
	464	/*
	465	* partially used pages are not usable - thus
	466	* we are rounding upwards:
	467	*/
	468	max_pfn = e820_end_of_ram();
	469
6780711e YL	470	/* preallocate 4k for mptable mpc */
6780711e YL	471	early_reserve_e820_mpc_new();
093af8d7 YL	472	/* update e820 for memory not covered by WB MTRRs */
093af8d7 YL	473	mtrr_bp_init();
7b2a0a6c YL	474	if (mtrr_trim_uncached_memory(max_pfn)) {
	475	remove_all_active_ranges();
	476	e820_register_active_regions(0, 0, -1UL);
	477	max_pfn = e820_end_of_ram();
	478	}
76c32418	479
4e29684c	480	/* max_low_pfn get updated here */
2ec65f8b YL	481	find_low_pfn_range();
2ec65f8b YL	482
4e29684c	483	/* max_pfn_mapped is updated here */
b9d19f4a	484	max_pfn_mapped = init_memory_mapping(0, (max_low_pfn << PAGE_SHIFT));
4e29684c	485
2ec65f8b YL	486	reserve_initrd();
2ec65f8b YL	487
1c6e5503 YL	488	dmi_scan_machine();
	489
	490	io_delay_init();
	491
1c6e5503 YL	492	/*
	493	* Parse the ACPI tables for possible boot-time SMP configuration.
	494	*/
	495	acpi_boot_table_init();
1c6e5503 YL	496
	497	#ifdef CONFIG_ACPI_NUMA
	498	/*
	499	* Parse SRAT to discover nodes.
	500	*/
	501	acpi_numa_init();
	502	#endif
	503
2ec65f8b	504	initmem_init(0, max_pfn);
093af8d7	505
593a0cc3 YL	506	#ifdef CONFIG_ACPI_SLEEP
	507	/*
	508	* Reserve low memory region for sleep support.
	509	*/
	510	acpi_reserve_bootmem();
	511	#endif
	512	#ifdef CONFIG_X86_FIND_SMP_CONFIG
	513	/*
	514	* Find and reserve possible boot-time SMP configuration:
	515	*/
	516	find_smp_config();
	517	#endif
	518	reserve_crashkernel();
	519
	520	reserve_ibft_region();
	521
790c73f6 GOC	522	#ifdef CONFIG_KVM_CLOCK
	523	kvmclock_init();
	524	#endif
	525
7ce0bcfd ZA	526	#ifdef CONFIG_VMI
	527	/*
	528	* Must be after max_low_pfn is determined, and before kernel
	529	* pagetables are setup.
	530	*/
	531	vmi_init();
	532	#endif
1da177e4	533
1da177e4	534	paging_init();
f212ec4b BK	535
	536	/*
	537	* NOTE: On x86-32, only from this point on, fixmaps are ready for use.
	538	*/
	539
	540	#ifdef CONFIG_PROVIDE_OHCI1394_DMA_INIT
	541	if (init_ohci1394_dma_early)
	542	init_ohci1394_dma_on_all_controllers();
	543	#endif
	544
1da177e4	545	#ifdef CONFIG_X86_GENERICARCH
1a3f239d	546	generic_apic_probe();
cf8fa920	547	#endif
1da177e4	548
54ef3400	549	early_quirks();
d44647b0	550
295deae4 YL	551	/*
	552	* Read APIC and some other early information from ACPI tables.
	553	*/
1da177e4	554	acpi_boot_init();
04606618	555
e0da3364	556	#if defined(CONFIG_X86_MPPARSE) \|\| defined(CONFIG_X86_VISWS)
295deae4 YL	557	/*
	558	* get boot-time SMP configuration:
	559	*/
e0da3364 YL	560	if (smp_found_config)
	561	get_smp_config();
	562	#endif
911a62d4 VP	563	#if defined(CONFIG_SMP) && defined(CONFIG_X86_PC)
	564	if (def_to_bigsmp)
	565	printk(KERN_WARNING "More than 8 CPUs detected and "
	566	"CONFIG_X86_PC cannot handle it.\nUse "
	567	"CONFIG_X86_GENERICARCH or CONFIG_X86_BIGSMP.\n");
	568	#endif
295deae4	569	kvm_guest_init();
1da177e4	570
41c094fd	571	e820_reserve_resources();
bf62f398	572	e820_mark_nosave_regions(max_low_pfn);
1da177e4	573
41c094fd	574	request_resource(&iomem_resource, &video_ram_resource);
ce97c40e	575	reserve_standard_io_resources();
41c094fd YL	576
	577	e820_setup_gap();
	578
1da177e4 LT	579	#ifdef CONFIG_VT
	580	#if defined(CONFIG_VGA_CONSOLE)
	581	if (!efi_enabled \|\| (efi_mem_type(0xa0000) != EFI_CONVENTIONAL_MEMORY))
	582	conswitchp = &vga_con;
	583	#elif defined(CONFIG_DUMMY_CONSOLE)
	584	conswitchp = &dummy_con;
	585	#endif
	586	#endif
	587	}
c9cce83d	588