[deliverable/linux.git] / arch / x86 / kernel / e820_64.c

/*
 * Handle the memory map.
 * The functions here do the job until bootmem takes over.
 *
 *  Getting sanitize_e820_map() in sync with i386 version by applying change:
 *  -  Provisions for empty E820 memory regions (reported by certain BIOSes).
 *     Alex Achenbach <xela@slit.de>, December 2002.
 *  Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
 *
 */
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/init.h>
#include <linux/bootmem.h>
#include <linux/ioport.h>
#include <linux/string.h>
#include <linux/kexec.h>
#include <linux/module.h>
#include <linux/mm.h>
#include <linux/pfn.h>
#include <linux/pci.h>

#include <asm/pgtable.h>
#include <asm/page.h>
#include <asm/e820.h>
#include <asm/proto.h>
#include <asm/setup.h>
#include <asm/sections.h>
#include <asm/kdebug.h>
#include <asm/trampoline.h>

/*
 * PFN of last memory page.
 */
unsigned long end_pfn;

/*
 * end_pfn only includes RAM, while max_pfn_mapped includes all e820 entries.
 * The direct mapping extends to max_pfn_mapped, so that we can directly access
 * apertures, ACPI and other tables without having to play with fixmaps.
 */
unsigned long max_pfn_mapped;

/*
 * Last pfn which the user wants to use.
 */
static unsigned long __initdata end_user_pfn = MAXMEM>>PAGE_SHIFT;

/*
 * Find the highest page frame number we have available
 */
unsigned long __init e820_end_of_ram(void)
{
	unsigned long last_pfn;

	last_pfn = find_max_pfn_with_active_regions();

	if (last_pfn > max_pfn_mapped)
		max_pfn_mapped = last_pfn;
	if (max_pfn_mapped > MAXMEM>>PAGE_SHIFT)
		max_pfn_mapped = MAXMEM>>PAGE_SHIFT;
	if (last_pfn > end_user_pfn)
		last_pfn = end_user_pfn;
	if (last_pfn > max_pfn_mapped)
		last_pfn = max_pfn_mapped;

	printk(KERN_INFO "max_pfn_mapped = %lu\n", max_pfn_mapped);
	return last_pfn;
}

/*
 * Mark e820 reserved areas as busy for the resource manager.
 */
void __init e820_reserve_resources(void)
{
	int i;
	struct resource *res;

	res = alloc_bootmem_low(sizeof(struct resource) * e820.nr_map);
	for (i = 0; i < e820.nr_map; i++) {
		switch (e820.map[i].type) {
		case E820_RAM:	res->name = "System RAM"; break;
		case E820_ACPI:	res->name = "ACPI Tables"; break;
		case E820_NVS:	res->name = "ACPI Non-volatile Storage"; break;
		default:	res->name = "reserved";
		}
		res->start = e820.map[i].addr;
		res->end = res->start + e820.map[i].size - 1;
		res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
		insert_resource(&iomem_resource, res);
		res++;
	}
}

/*
 * Finds an active region in the address range from start_pfn to last_pfn and
 * returns its range in ei_startpfn and ei_endpfn for the e820 entry.
 */
static int __init e820_find_active_region(const struct e820entry *ei,
					  unsigned long start_pfn,
					  unsigned long last_pfn,
					  unsigned long *ei_startpfn,
					  unsigned long *ei_endpfn)
{
	*ei_startpfn = round_up(ei->addr, PAGE_SIZE) >> PAGE_SHIFT;
	*ei_endpfn = round_down(ei->addr + ei->size, PAGE_SIZE) >> PAGE_SHIFT;

	/* Skip map entries smaller than a page */
	if (*ei_startpfn >= *ei_endpfn)
		return 0;

	/* Check if max_pfn_mapped should be updated */
	if (ei->type != E820_RAM && *ei_endpfn > max_pfn_mapped)
		max_pfn_mapped = *ei_endpfn;

	/* Skip if map is outside the node */
	if (ei->type != E820_RAM || *ei_endpfn <= start_pfn ||
				    *ei_startpfn >= last_pfn)
		return 0;

	/* Check for overlaps */
	if (*ei_startpfn < start_pfn)
		*ei_startpfn = start_pfn;
	if (*ei_endpfn > last_pfn)
		*ei_endpfn = last_pfn;

	/* Obey end_user_pfn to save on memmap */
	if (*ei_startpfn >= end_user_pfn)
		return 0;
	if (*ei_endpfn > end_user_pfn)
		*ei_endpfn = end_user_pfn;

	return 1;
}

/* Walk the e820 map and register active regions within a node */
void __init
e820_register_active_regions(int nid, unsigned long start_pfn,
							unsigned long last_pfn)
{
	unsigned long ei_startpfn;
	unsigned long ei_endpfn;
	int i;

	for (i = 0; i < e820.nr_map; i++)
		if (e820_find_active_region(&e820.map[i],
					    start_pfn, last_pfn,
					    &ei_startpfn, &ei_endpfn))
			add_active_range(nid, ei_startpfn, ei_endpfn);
}

/*
 * Find the hole size (in bytes) in the memory range.
 * @start: starting address of the memory range to scan
 * @end: ending address of the memory range to scan
 */
unsigned long __init e820_hole_size(unsigned long start, unsigned long end)
{
	unsigned long start_pfn = start >> PAGE_SHIFT;
	unsigned long last_pfn = end >> PAGE_SHIFT;
	unsigned long ei_startpfn, ei_endpfn, ram = 0;
	int i;

	for (i = 0; i < e820.nr_map; i++) {
		if (e820_find_active_region(&e820.map[i],
					    start_pfn, last_pfn,
					    &ei_startpfn, &ei_endpfn))
			ram += ei_endpfn - ei_startpfn;
	}
	return end - start - (ram << PAGE_SHIFT);
}

static void early_panic(char *msg)
{
	early_printk(msg);
	panic(msg);
}

/* We're not void only for x86 32-bit compat */
char *__init machine_specific_memory_setup(void)
{
	char *who = "BIOS-e820";
	int new_nr;
	/*
	 * Try to copy the BIOS-supplied E820-map.
	 *
	 * Otherwise fake a memory map; one section from 0k->640k,
	 * the next section from 1mb->appropriate_mem_k
	 */
	new_nr = boot_params.e820_entries;
	sanitize_e820_map(boot_params.e820_map,
			ARRAY_SIZE(boot_params.e820_map),
			&new_nr);
	boot_params.e820_entries = new_nr;
	if (copy_e820_map(boot_params.e820_map, boot_params.e820_entries) < 0)
		early_panic("Cannot find a valid memory map");
	printk(KERN_INFO "BIOS-provided physical RAM map:\n");
	e820_print_map(who);

	/* In case someone cares... */
	return who;
}

static int __init parse_memopt(char *p)
{
	if (!p)
		return -EINVAL;
	end_user_pfn = memparse(p, &p);
	end_user_pfn >>= PAGE_SHIFT;
	return 0;
}
early_param("mem", parse_memopt);

static int userdef __initdata;

static int __init parse_memmap_opt(char *p)
{
	char *oldp;
	unsigned long long start_at, mem_size;

	if (!strcmp(p, "exactmap")) {
#ifdef CONFIG_CRASH_DUMP
		/*
		 * If we are doing a crash dump, we still need to know
		 * the real mem size before original memory map is
		 * reset.
		 */
		e820_register_active_regions(0, 0, -1UL);
		saved_max_pfn = e820_end_of_ram();
		remove_all_active_ranges();
#endif
		max_pfn_mapped = 0;
		e820.nr_map = 0;
		userdef = 1;
		return 0;
	}

	oldp = p;
	mem_size = memparse(p, &p);
	if (p == oldp)
		return -EINVAL;

	userdef = 1;
	if (*p == '@') {
		start_at = memparse(p+1, &p);
		add_memory_region(start_at, mem_size, E820_RAM);
	} else if (*p == '#') {
		start_at = memparse(p+1, &p);
		add_memory_region(start_at, mem_size, E820_ACPI);
	} else if (*p == '$') {
		start_at = memparse(p+1, &p);
		add_memory_region(start_at, mem_size, E820_RESERVED);
	} else {
		end_user_pfn = (mem_size >> PAGE_SHIFT);
	}
	return *p == '\0' ? 0 : -EINVAL;
}
early_param("memmap", parse_memmap_opt);

void __init finish_e820_parsing(void)
{
	if (userdef) {
		int nr = e820.nr_map;

		if (sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &nr) < 0)
			early_panic("Invalid user supplied memory map");
		e820.nr_map = nr;

		printk(KERN_INFO "user-defined physical RAM map:\n");
		e820_print_map("user");
	}
}

int __init arch_get_ram_range(int slot, u64 *addr, u64 *size)
{
	int i;

	if (slot < 0 || slot >= e820.nr_map)
		return -1;
	for (i = slot; i < e820.nr_map; i++) {
		if (e820.map[i].type != E820_RAM)
			continue;
		break;
	}
	if (i == e820.nr_map || e820.map[i].addr > (max_pfn << PAGE_SHIFT))
		return -1;
	*addr = e820.map[i].addr;
	*size = min_t(u64, e820.map[i].size + e820.map[i].addr,
		max_pfn << PAGE_SHIFT) - *addr;
	return i + 1;
}
Commit	Line	Data
2f36fa13	1	/*
1da177e4 LT	2	* Handle the memory map.
1da177e4 LT	3	* The functions here do the job until bootmem takes over.
8059b2a2 VP	4	*
	5	* Getting sanitize_e820_map() in sync with i386 version by applying change:
	6	* - Provisions for empty E820 memory regions (reported by certain BIOSes).
	7	* Alex Achenbach <xela@slit.de>, December 2002.
	8	* Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
	9	*
1da177e4	10	*/
1da177e4 LT	11	#include <linux/kernel.h>
	12	#include <linux/types.h>
	13	#include <linux/init.h>
	14	#include <linux/bootmem.h>
	15	#include <linux/ioport.h>
	16	#include <linux/string.h>
5f5609df	17	#include <linux/kexec.h>
b9491ac8	18	#include <linux/module.h>
e8eff5ac	19	#include <linux/mm.h>
74dfd666	20	#include <linux/pfn.h>
4a139a7f	21	#include <linux/pci.h>
b9491ac8	22
1a91023a	23	#include <asm/pgtable.h>
1da177e4 LT	24	#include <asm/page.h>
	25	#include <asm/e820.h>
	26	#include <asm/proto.h>
30c82645	27	#include <asm/setup.h>
2bc0414e	28	#include <asm/sections.h>
718fc13b	29	#include <asm/kdebug.h>
e44b7b75	30	#include <asm/trampoline.h>
1da177e4	31
2f36fa13	32	/*
1da177e4 LT	33	* PFN of last memory page.
1da177e4 LT	34	*/
2f36fa13	35	unsigned long end_pfn;
1da177e4	36
2f36fa13	37	/*
67794292 TG	38	* end_pfn only includes RAM, while max_pfn_mapped includes all e820 entries.
67794292 TG	39	* The direct mapping extends to max_pfn_mapped, so that we can directly access
1da177e4	40	* apertures, ACPI and other tables without having to play with fixmaps.
2f36fa13	41	*/
67794292	42	unsigned long max_pfn_mapped;
1da177e4	43
2f36fa13	44	/*
1da177e4 LT	45	* Last pfn which the user wants to use.
1da177e4 LT	46	*/
caff0710	47	static unsigned long __initdata end_user_pfn = MAXMEM>>PAGE_SHIFT;
1da177e4	48
1da177e4 LT	49	/*
	50	* Find the highest page frame number we have available
	51	*/
	52	unsigned long __init e820_end_of_ram(void)
	53	{
a91eea6d	54	unsigned long last_pfn;
2f36fa13	55
a91eea6d	56	last_pfn = find_max_pfn_with_active_regions();
2f36fa13	57
a91eea6d TG	58	if (last_pfn > max_pfn_mapped)
a91eea6d TG	59	max_pfn_mapped = last_pfn;
67794292 TG	60	if (max_pfn_mapped > MAXMEM>>PAGE_SHIFT)
67794292 TG	61	max_pfn_mapped = MAXMEM>>PAGE_SHIFT;
a91eea6d TG	62	if (last_pfn > end_user_pfn)
	63	last_pfn = end_user_pfn;
	64	if (last_pfn > max_pfn_mapped)
	65	last_pfn = max_pfn_mapped;
1da177e4	66
67794292	67	printk(KERN_INFO "max_pfn_mapped = %lu\n", max_pfn_mapped);
a91eea6d	68	return last_pfn;
1da177e4 LT	69	}
1da177e4 LT	70
485761bd	71	/*
1da177e4 LT	72	* Mark e820 reserved areas as busy for the resource manager.
1da177e4 LT	73	*/
3def3d6d	74	void __init e820_reserve_resources(void)
1da177e4 LT	75	{
1da177e4 LT	76	int i;
01561264 YL	77	struct resource *res;
	78
	79	res = alloc_bootmem_low(sizeof(struct resource) * e820.nr_map);
1da177e4	80	for (i = 0; i < e820.nr_map; i++) {
1da177e4 LT	81	switch (e820.map[i].type) {
	82	case E820_RAM: res->name = "System RAM"; break;
	83	case E820_ACPI: res->name = "ACPI Tables"; break;
	84	case E820_NVS: res->name = "ACPI Non-volatile Storage"; break;
	85	default: res->name = "reserved";
	86	}
	87	res->start = e820.map[i].addr;
	88	res->end = res->start + e820.map[i].size - 1;
	89	res->flags = IORESOURCE_MEM \| IORESOURCE_BUSY;
3def3d6d	90	insert_resource(&iomem_resource, res);
01561264	91	res++;
1da177e4 LT	92	}
	93	}
	94
3af044e0	95	/*
a91eea6d	96	* Finds an active region in the address range from start_pfn to last_pfn and
3af044e0 DR	97	* returns its range in ei_startpfn and ei_endpfn for the e820 entry.
	98	*/
	99	static int __init e820_find_active_region(const struct e820entry *ei,
	100	unsigned long start_pfn,
a91eea6d	101	unsigned long last_pfn,
3af044e0 DR	102	unsigned long *ei_startpfn,
	103	unsigned long *ei_endpfn)
	104	{
	105	*ei_startpfn = round_up(ei->addr, PAGE_SIZE) >> PAGE_SHIFT;
	106	*ei_endpfn = round_down(ei->addr + ei->size, PAGE_SIZE) >> PAGE_SHIFT;
	107
	108	/* Skip map entries smaller than a page */
	109	if (ei_startpfn >= ei_endpfn)
	110	return 0;
	111
67794292 TG	112	/* Check if max_pfn_mapped should be updated */
	113	if (ei->type != E820_RAM && *ei_endpfn > max_pfn_mapped)
	114	max_pfn_mapped = *ei_endpfn;
3af044e0 DR	115
	116	/* Skip if map is outside the node */
	117	if (ei->type != E820_RAM \|\| *ei_endpfn <= start_pfn \|\|
a91eea6d	118	*ei_startpfn >= last_pfn)
3af044e0 DR	119	return 0;
	120
	121	/* Check for overlaps */
	122	if (*ei_startpfn < start_pfn)
	123	*ei_startpfn = start_pfn;
a91eea6d TG	124	if (*ei_endpfn > last_pfn)
a91eea6d TG	125	*ei_endpfn = last_pfn;
3af044e0 DR	126
	127	/* Obey end_user_pfn to save on memmap */
	128	if (*ei_startpfn >= end_user_pfn)
	129	return 0;
	130	if (*ei_endpfn > end_user_pfn)
	131	*ei_endpfn = end_user_pfn;
	132
	133	return 1;
	134	}
	135
5cb248ab MG	136	/* Walk the e820 map and register active regions within a node */
	137	void __init
	138	e820_register_active_regions(int nid, unsigned long start_pfn,
a91eea6d	139	unsigned long last_pfn)
5cb248ab	140	{
3af044e0 DR	141	unsigned long ei_startpfn;
3af044e0 DR	142	unsigned long ei_endpfn;
5cb248ab	143	int i;
5cb248ab	144
3af044e0 DR	145	for (i = 0; i < e820.nr_map; i++)
3af044e0 DR	146	if (e820_find_active_region(&e820.map[i],
a91eea6d	147	start_pfn, last_pfn,
3af044e0 DR	148	&ei_startpfn, &ei_endpfn))
3af044e0 DR	149	add_active_range(nid, ei_startpfn, ei_endpfn);
5cb248ab MG	150	}
5cb248ab MG	151
a7e96629 DR	152	/*
	153	* Find the hole size (in bytes) in the memory range.
	154	* @start: starting address of the memory range to scan
	155	* @end: ending address of the memory range to scan
	156	*/
	157	unsigned long __init e820_hole_size(unsigned long start, unsigned long end)
	158	{
	159	unsigned long start_pfn = start >> PAGE_SHIFT;
a91eea6d	160	unsigned long last_pfn = end >> PAGE_SHIFT;
2f36fa13	161	unsigned long ei_startpfn, ei_endpfn, ram = 0;
a7e96629 DR	162	int i;
	163
	164	for (i = 0; i < e820.nr_map; i++) {
	165	if (e820_find_active_region(&e820.map[i],
a91eea6d	166	start_pfn, last_pfn,
a7e96629 DR	167	&ei_startpfn, &ei_endpfn))
	168	ram += ei_endpfn - ei_startpfn;
	169	}
	170	return end - start - (ram << PAGE_SHIFT);
	171	}
	172
013d23e1	173	static void early_panic(char *msg)
1da177e4	174	{
8380aabb AK	175	early_printk(msg);
	176	panic(msg);
	177	}
1da177e4	178
746ef0cd	179	/* We're not void only for x86 32-bit compat */
b25e31ce	180	char *__init machine_specific_memory_setup(void)
8380aabb	181	{
746ef0cd	182	char *who = "BIOS-e820";
6e9bcc79	183	int new_nr;
1da177e4 LT	184	/*
	185	* Try to copy the BIOS-supplied E820-map.
	186	*
	187	* Otherwise fake a memory map; one section from 0k->640k,
	188	* the next section from 1mb->appropriate_mem_k
	189	*/
6e9bcc79	190	new_nr = boot_params.e820_entries;
c3965bd1 PJ	191	sanitize_e820_map(boot_params.e820_map,
c3965bd1 PJ	192	ARRAY_SIZE(boot_params.e820_map),
6e9bcc79 PJ	193	&new_nr);
6e9bcc79 PJ	194	boot_params.e820_entries = new_nr;
30c82645	195	if (copy_e820_map(boot_params.e820_map, boot_params.e820_entries) < 0)
8380aabb	196	early_panic("Cannot find a valid memory map");
1da177e4	197	printk(KERN_INFO "BIOS-provided physical RAM map:\n");
746ef0cd GOC	198	e820_print_map(who);
	199
	200	/* In case someone cares... */
	201	return who;
1da177e4 LT	202	}
1da177e4 LT	203
2c8c0e6b AK	204	static int __init parse_memopt(char *p)
	205	{
	206	if (!p)
	207	return -EINVAL;
	208	end_user_pfn = memparse(p, &p);
2f36fa13	209	end_user_pfn >>= PAGE_SHIFT;
2c8c0e6b	210	return 0;
2f36fa13	211	}
2c8c0e6b	212	early_param("mem", parse_memopt);
1da177e4	213
2c8c0e6b	214	static int userdef __initdata;
1da177e4	215
2c8c0e6b	216	static int __init parse_memmap_opt(char *p)
69cda7b1	217	{
2c8c0e6b	218	char *oldp;
69cda7b1	219	unsigned long long start_at, mem_size;
69cda7b1	220
2c8c0e6b AK	221	if (!strcmp(p, "exactmap")) {
2c8c0e6b AK	222	#ifdef CONFIG_CRASH_DUMP
2f36fa13 TG	223	/*
	224	* If we are doing a crash dump, we still need to know
	225	* the real mem size before original memory map is
2c8c0e6b AK	226	* reset.
2c8c0e6b AK	227	*/
15803a43	228	e820_register_active_regions(0, 0, -1UL);
2c8c0e6b	229	saved_max_pfn = e820_end_of_ram();
15803a43	230	remove_all_active_ranges();
2c8c0e6b	231	#endif
67794292	232	max_pfn_mapped = 0;
2c8c0e6b AK	233	e820.nr_map = 0;
	234	userdef = 1;
	235	return 0;
	236	}
	237
	238	oldp = p;
	239	mem_size = memparse(p, &p);
	240	if (p == oldp)
	241	return -EINVAL;
b3ca74a2 VB	242
b3ca74a2 VB	243	userdef = 1;
69cda7b1	244	if (*p == '@') {
2c8c0e6b	245	start_at = memparse(p+1, &p);
69cda7b1	246	add_memory_region(start_at, mem_size, E820_RAM);
69cda7b1	247	} else if (*p == '#') {
2c8c0e6b	248	start_at = memparse(p+1, &p);
69cda7b1	249	add_memory_region(start_at, mem_size, E820_ACPI);
69cda7b1	250	} else if (*p == '$') {
2c8c0e6b	251	start_at = memparse(p+1, &p);
69cda7b1	252	add_memory_region(start_at, mem_size, E820_RESERVED);
	253	} else {
	254	end_user_pfn = (mem_size >> PAGE_SHIFT);
	255	}
2c8c0e6b AK	256	return *p == '\0' ? 0 : -EINVAL;
	257	}
	258	early_param("memmap", parse_memmap_opt);
	259
43999d9e	260	void __init finish_e820_parsing(void)
2c8c0e6b AK	261	{
2c8c0e6b AK	262	if (userdef) {
6e9bcc79	263	int nr = e820.nr_map;
b3ca74a2	264
c3965bd1	265	if (sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &nr) < 0)
b3ca74a2 VB	266	early_panic("Invalid user supplied memory map");
	267	e820.nr_map = nr;
	268
2c8c0e6b AK	269	printk(KERN_INFO "user-defined physical RAM map:\n");
	270	e820_print_map("user");
	271	}
69cda7b1	272	}
69cda7b1	273
e820482c KA	274	int __init arch_get_ram_range(int slot, u64 addr, u64 size)
	275	{
	276	int i;
	277
	278	if (slot < 0 \|\| slot >= e820.nr_map)
	279	return -1;
	280	for (i = slot; i < e820.nr_map; i++) {
	281	if (e820.map[i].type != E820_RAM)
	282	continue;
	283	break;
	284	}
	285	if (i == e820.nr_map \|\| e820.map[i].addr > (max_pfn << PAGE_SHIFT))
	286	return -1;
	287	*addr = e820.map[i].addr;
	288	*size = min_t(u64, e820.map[i].size + e820.map[i].addr,
	289	max_pfn << PAGE_SHIFT) - *addr;
	290	return i + 1;
	291	}