[linux-block.git] / arch / metag / mm / init.c

// SPDX-License-Identifier: GPL-2.0
/*
 *  Copyright (C) 2005,2006,2007,2008,2009,2010 Imagination Technologies
 *
 */

#include <linux/export.h>
#include <linux/mm.h>
#include <linux/swap.h>
#include <linux/init.h>
#include <linux/bootmem.h>
#include <linux/pagemap.h>
#include <linux/percpu.h>
#include <linux/memblock.h>
#include <linux/initrd.h>
#include <linux/sched/task.h>

#include <asm/setup.h>
#include <asm/page.h>
#include <asm/pgalloc.h>
#include <asm/mmu.h>
#include <asm/mmu_context.h>
#include <asm/sections.h>
#include <asm/tlb.h>
#include <asm/user_gateway.h>
#include <asm/mmzone.h>
#include <asm/fixmap.h>

unsigned long pfn_base;
EXPORT_SYMBOL(pfn_base);

pgd_t swapper_pg_dir[PTRS_PER_PGD] __page_aligned_data;

unsigned long empty_zero_page;
EXPORT_SYMBOL(empty_zero_page);

extern char __user_gateway_start;
extern char __user_gateway_end;

void *gateway_page;

/*
 * Insert the gateway page into a set of page tables, creating the
 * page tables if necessary.
 */
static void insert_gateway_page(pgd_t *pgd, unsigned long address)
{
	pud_t *pud;
	pmd_t *pmd;
	pte_t *pte;

	BUG_ON(!pgd_present(*pgd));

	pud = pud_offset(pgd, address);
	BUG_ON(!pud_present(*pud));

	pmd = pmd_offset(pud, address);
	if (!pmd_present(*pmd)) {
		pte = alloc_bootmem_pages(PAGE_SIZE);
		set_pmd(pmd, __pmd(_PAGE_TABLE | __pa(pte)));
	}

	pte = pte_offset_kernel(pmd, address);
	set_pte(pte, pfn_pte(__pa(gateway_page) >> PAGE_SHIFT, PAGE_READONLY));
}

/* Alloc and map a page in a known location accessible to userspace. */
static void __init user_gateway_init(void)
{
	unsigned long address = USER_GATEWAY_PAGE;
	int offset = pgd_index(address);
	pgd_t *pgd;

	gateway_page = alloc_bootmem_pages(PAGE_SIZE);

	pgd = swapper_pg_dir + offset;
	insert_gateway_page(pgd, address);

#ifdef CONFIG_METAG_META12
	/*
	 * Insert the gateway page into our current page tables even
	 * though we've already inserted it into our reference page
	 * table (swapper_pg_dir). This is because with a META1 mmu we
	 * copy just the user address range and not the gateway page
	 * entry on context switch, see switch_mmu().
	 */
	pgd = (pgd_t *)mmu_get_base() + offset;
	insert_gateway_page(pgd, address);
#endif /* CONFIG_METAG_META12 */

	BUG_ON((&__user_gateway_end - &__user_gateway_start) > PAGE_SIZE);

	gateway_page += (address & ~PAGE_MASK);

	memcpy(gateway_page, &__user_gateway_start,
	       &__user_gateway_end - &__user_gateway_start);

	/*
	 * We don't need to flush the TLB here, there should be no mapping
	 * present at boot for this address and only valid mappings are in
	 * the TLB (apart from on Meta 1.x, but those cached invalid
	 * mappings should be impossible to hit here).
	 *
	 * We don't flush the code cache here even though we have written
	 * code through the data cache and they may not be coherent. At
	 * this point we assume there is no stale data in the code cache
	 * for this address so there is no need to flush.
	 */
}

static void __init allocate_pgdat(unsigned int nid)
{
	unsigned long start_pfn, end_pfn;
#ifdef CONFIG_NEED_MULTIPLE_NODES
	unsigned long phys;
#endif

	get_pfn_range_for_nid(nid, &start_pfn, &end_pfn);

#ifdef CONFIG_NEED_MULTIPLE_NODES
	phys = __memblock_alloc_base(sizeof(struct pglist_data),
				SMP_CACHE_BYTES, end_pfn << PAGE_SHIFT);
	/* Retry with all of system memory */
	if (!phys)
		phys = __memblock_alloc_base(sizeof(struct pglist_data),
					     SMP_CACHE_BYTES,
					     memblock_end_of_DRAM());
	if (!phys)
		panic("Can't allocate pgdat for node %d\n", nid);

	NODE_DATA(nid) = __va(phys);
	memset(NODE_DATA(nid), 0, sizeof(struct pglist_data));

	NODE_DATA(nid)->bdata = &bootmem_node_data[nid];
#endif

	NODE_DATA(nid)->node_start_pfn = start_pfn;
	NODE_DATA(nid)->node_spanned_pages = end_pfn - start_pfn;
}

static void __init bootmem_init_one_node(unsigned int nid)
{
	unsigned long total_pages, paddr;
	unsigned long end_pfn;
	struct pglist_data *p;

	p = NODE_DATA(nid);

	/* Nothing to do.. */
	if (!p->node_spanned_pages)
		return;

	end_pfn = pgdat_end_pfn(p);
#ifdef CONFIG_HIGHMEM
	if (end_pfn > max_low_pfn)
		end_pfn = max_low_pfn;
#endif

	total_pages = bootmem_bootmap_pages(end_pfn - p->node_start_pfn);

	paddr = memblock_alloc(total_pages << PAGE_SHIFT, PAGE_SIZE);
	if (!paddr)
		panic("Can't allocate bootmap for nid[%d]\n", nid);

	init_bootmem_node(p, paddr >> PAGE_SHIFT, p->node_start_pfn, end_pfn);

	free_bootmem_with_active_regions(nid, end_pfn);

	/*
	 * XXX Handle initial reservations for the system memory node
	 * only for the moment, we'll refactor this later for handling
	 * reservations in other nodes.
	 */
	if (nid == 0) {
		struct memblock_region *reg;

		/* Reserve the sections we're already using. */
		for_each_memblock(reserved, reg) {
			unsigned long size = reg->size;

#ifdef CONFIG_HIGHMEM
			/* ...but not highmem */
			if (PFN_DOWN(reg->base) >= highstart_pfn)
				continue;

			if (PFN_UP(reg->base + size) > highstart_pfn)
				size = (highstart_pfn - PFN_DOWN(reg->base))
				       << PAGE_SHIFT;
#endif

			reserve_bootmem(reg->base, size, BOOTMEM_DEFAULT);
		}
	}

	sparse_memory_present_with_active_regions(nid);
}

static void __init do_init_bootmem(void)
{
	struct memblock_region *reg;
	int i;

	/* Add active regions with valid PFNs. */
	for_each_memblock(memory, reg) {
		unsigned long start_pfn, end_pfn;
		start_pfn = memblock_region_memory_base_pfn(reg);
		end_pfn = memblock_region_memory_end_pfn(reg);
		memblock_set_node(PFN_PHYS(start_pfn),
				  PFN_PHYS(end_pfn - start_pfn),
				  &memblock.memory, 0);
	}

	/* All of system RAM sits in node 0 for the non-NUMA case */
	allocate_pgdat(0);
	node_set_online(0);

	soc_mem_setup();

	for_each_online_node(i)
		bootmem_init_one_node(i);

	sparse_init();
}

extern char _heap_start[];

static void __init init_and_reserve_mem(void)
{
	unsigned long start_pfn, heap_start;
	u64 base = min_low_pfn << PAGE_SHIFT;
	u64 size = (max_low_pfn << PAGE_SHIFT) - base;

	heap_start = (unsigned long) &_heap_start;

	memblock_add(base, size);

	/*
	 * Partially used pages are not usable - thus
	 * we are rounding upwards:
	 */
	start_pfn = PFN_UP(__pa(heap_start));

	/*
	 * Reserve the kernel text.
	 */
	memblock_reserve(base, (PFN_PHYS(start_pfn) + PAGE_SIZE - 1) - base);

#ifdef CONFIG_HIGHMEM
	/*
	 * Add & reserve highmem, so page structures are initialised.
	 */
	base = highstart_pfn << PAGE_SHIFT;
	size = (highend_pfn << PAGE_SHIFT) - base;
	if (size) {
		memblock_add(base, size);
		memblock_reserve(base, size);
	}
#endif
}

#ifdef CONFIG_HIGHMEM
/*
 * Ensure we have allocated page tables in swapper_pg_dir for the
 * fixed mappings range from 'start' to 'end'.
 */
static void __init allocate_pgtables(unsigned long start, unsigned long end)
{
	pgd_t *pgd;
	pmd_t *pmd;
	pte_t *pte;
	int i, j;
	unsigned long vaddr;

	vaddr = start;
	i = pgd_index(vaddr);
	j = pmd_index(vaddr);
	pgd = swapper_pg_dir + i;

	for ( ; (i < PTRS_PER_PGD) && (vaddr != end); pgd++, i++) {
		pmd = (pmd_t *)pgd;
		for (; (j < PTRS_PER_PMD) && (vaddr != end); pmd++, j++) {
			vaddr += PMD_SIZE;

			if (!pmd_none(*pmd))
				continue;

			pte = (pte_t *)alloc_bootmem_low_pages(PAGE_SIZE);
			pmd_populate_kernel(&init_mm, pmd, pte);
		}
		j = 0;
	}
}

static void __init fixedrange_init(void)
{
	unsigned long vaddr, end;
	pgd_t *pgd;
	pud_t *pud;
	pmd_t *pmd;
	pte_t *pte;

	/*
	 * Fixed mappings:
	 */
	vaddr = __fix_to_virt(__end_of_fixed_addresses - 1) & PMD_MASK;
	end = (FIXADDR_TOP + PMD_SIZE - 1) & PMD_MASK;
	allocate_pgtables(vaddr, end);

	/*
	 * Permanent kmaps:
	 */
	vaddr = PKMAP_BASE;
	allocate_pgtables(vaddr, vaddr + PAGE_SIZE*LAST_PKMAP);

	pgd = swapper_pg_dir + pgd_index(vaddr);
	pud = pud_offset(pgd, vaddr);
	pmd = pmd_offset(pud, vaddr);
	pte = pte_offset_kernel(pmd, vaddr);
	pkmap_page_table = pte;
}
#endif /* CONFIG_HIGHMEM */

/*
 * paging_init() continues the virtual memory environment setup which
 * was begun by the code in arch/metag/kernel/setup.c.
 */
void __init paging_init(unsigned long mem_end)
{
	unsigned long max_zone_pfns[MAX_NR_ZONES];
	int nid;

	init_and_reserve_mem();

	memblock_allow_resize();

	memblock_dump_all();

	nodes_clear(node_online_map);

	init_new_context(&init_task, &init_mm);

	memset(swapper_pg_dir, 0, sizeof(swapper_pg_dir));

	do_init_bootmem();
	mmu_init(mem_end);

#ifdef CONFIG_HIGHMEM
	fixedrange_init();
	kmap_init();
#endif

	/* Initialize the zero page to a bootmem page, already zeroed. */
	empty_zero_page = (unsigned long)alloc_bootmem_pages(PAGE_SIZE);

	user_gateway_init();

	memset(max_zone_pfns, 0, sizeof(max_zone_pfns));

	for_each_online_node(nid) {
		pg_data_t *pgdat = NODE_DATA(nid);
		unsigned long low, start_pfn;

		start_pfn = pgdat->bdata->node_min_pfn;
		low = pgdat->bdata->node_low_pfn;

		if (max_zone_pfns[ZONE_NORMAL] < low)
			max_zone_pfns[ZONE_NORMAL] = low;

#ifdef CONFIG_HIGHMEM
		max_zone_pfns[ZONE_HIGHMEM] = highend_pfn;
#endif
		pr_info("Node %u: start_pfn = 0x%lx, low = 0x%lx\n",
			nid, start_pfn, low);
	}

	free_area_init_nodes(max_zone_pfns);
}

void __init mem_init(void)
{
#ifdef CONFIG_HIGHMEM
	unsigned long tmp;

	/*
	 * Explicitly reset zone->managed_pages because highmem pages are
	 * freed before calling free_all_bootmem();
	 */
	reset_all_zones_managed_pages();
	for (tmp = highstart_pfn; tmp < highend_pfn; tmp++)
		free_highmem_page(pfn_to_page(tmp));
#endif /* CONFIG_HIGHMEM */

	free_all_bootmem();
	mem_init_print_info(NULL);
}

void free_initmem(void)
{
	free_initmem_default(POISON_FREE_INITMEM);
}

#ifdef CONFIG_BLK_DEV_INITRD
void free_initrd_mem(unsigned long start, unsigned long end)
{
	free_reserved_area((void *)start, (void *)end, POISON_FREE_INITMEM,
			   "initrd");
}
#endif
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
f5df8e26 JH	2	/*
	3	* Copyright (C) 2005,2006,2007,2008,2009,2010 Imagination Technologies
	4	*
	5	*/
	6
44c24510	7	#include <linux/export.h>
f5df8e26 JH	8	#include <linux/mm.h>
	9	#include <linux/swap.h>
	10	#include <linux/init.h>
	11	#include <linux/bootmem.h>
	12	#include <linux/pagemap.h>
	13	#include <linux/percpu.h>
	14	#include <linux/memblock.h>
	15	#include <linux/initrd.h>
9164bb4a	16	#include <linux/sched/task.h>
f5df8e26 JH	17
	18	#include <asm/setup.h>
	19	#include <asm/page.h>
	20	#include <asm/pgalloc.h>
	21	#include <asm/mmu.h>
	22	#include <asm/mmu_context.h>
	23	#include <asm/sections.h>
	24	#include <asm/tlb.h>
	25	#include <asm/user_gateway.h>
	26	#include <asm/mmzone.h>
	27	#include <asm/fixmap.h>
	28
	29	unsigned long pfn_base;
44c24510	30	EXPORT_SYMBOL(pfn_base);
f5df8e26 JH	31
	32	pgd_t swapper_pg_dir[PTRS_PER_PGD] __page_aligned_data;
	33
	34	unsigned long empty_zero_page;
44c24510	35	EXPORT_SYMBOL(empty_zero_page);
f5df8e26 JH	36
	37	extern char __user_gateway_start;
	38	extern char __user_gateway_end;
	39
	40	void *gateway_page;
	41
	42	/*
	43	* Insert the gateway page into a set of page tables, creating the
	44	* page tables if necessary.
	45	*/
	46	static void insert_gateway_page(pgd_t *pgd, unsigned long address)
	47	{
	48	pud_t *pud;
	49	pmd_t *pmd;
	50	pte_t *pte;
	51
	52	BUG_ON(!pgd_present(*pgd));
	53
	54	pud = pud_offset(pgd, address);
	55	BUG_ON(!pud_present(*pud));
	56
	57	pmd = pmd_offset(pud, address);
	58	if (!pmd_present(*pmd)) {
	59	pte = alloc_bootmem_pages(PAGE_SIZE);
	60	set_pmd(pmd, __pmd(_PAGE_TABLE \| __pa(pte)));
	61	}
	62
	63	pte = pte_offset_kernel(pmd, address);
	64	set_pte(pte, pfn_pte(__pa(gateway_page) >> PAGE_SHIFT, PAGE_READONLY));
	65	}
	66
	67	/* Alloc and map a page in a known location accessible to userspace. */
	68	static void __init user_gateway_init(void)
	69	{
	70	unsigned long address = USER_GATEWAY_PAGE;
	71	int offset = pgd_index(address);
	72	pgd_t *pgd;
	73
	74	gateway_page = alloc_bootmem_pages(PAGE_SIZE);
	75
	76	pgd = swapper_pg_dir + offset;
	77	insert_gateway_page(pgd, address);
	78
	79	#ifdef CONFIG_METAG_META12
	80	/*
	81	* Insert the gateway page into our current page tables even
	82	* though we've already inserted it into our reference page
	83	* table (swapper_pg_dir). This is because with a META1 mmu we
	84	* copy just the user address range and not the gateway page
	85	* entry on context switch, see switch_mmu().
	86	*/
	87	pgd = (pgd_t *)mmu_get_base() + offset;
	88	insert_gateway_page(pgd, address);
	89	#endif /* CONFIG_METAG_META12 */
	90
	91	BUG_ON((&__user_gateway_end - &__user_gateway_start) > PAGE_SIZE);
	92
	93	gateway_page += (address & ~PAGE_MASK);
	94
	95	memcpy(gateway_page, &__user_gateway_start,
	96	&__user_gateway_end - &__user_gateway_start);
	97
	98	/*
	99	* We don't need to flush the TLB here, there should be no mapping
100	* present at boot for this address and only valid mappings are in
101	* the TLB (apart from on Meta 1.x, but those cached invalid
102	* mappings should be impossible to hit here).
103	*
104	* We don't flush the code cache here even though we have written
105	* code through the data cache and they may not be coherent. At
106	* this point we assume there is no stale data in the code cache
107	* for this address so there is no need to flush.
108	*/
109	}
110
111	static void __init allocate_pgdat(unsigned int nid)
112	{
113	unsigned long start_pfn, end_pfn;
114	#ifdef CONFIG_NEED_MULTIPLE_NODES
115	unsigned long phys;
116	#endif
117
118	get_pfn_range_for_nid(nid, &start_pfn, &end_pfn);
119
120	#ifdef CONFIG_NEED_MULTIPLE_NODES
121	phys = __memblock_alloc_base(sizeof(struct pglist_data),
122	SMP_CACHE_BYTES, end_pfn << PAGE_SHIFT);
123	/* Retry with all of system memory */
124	if (!phys)
125	phys = __memblock_alloc_base(sizeof(struct pglist_data),
126	SMP_CACHE_BYTES,
127	memblock_end_of_DRAM());
128	if (!phys)
129	panic("Can't allocate pgdat for node %d\n", nid);
130
131	NODE_DATA(nid) = __va(phys);
132	memset(NODE_DATA(nid), 0, sizeof(struct pglist_data));
133
134	NODE_DATA(nid)->bdata = &bootmem_node_data[nid];
135	#endif
136
137	NODE_DATA(nid)->node_start_pfn = start_pfn;
138	NODE_DATA(nid)->node_spanned_pages = end_pfn - start_pfn;
139	}
140
141	static void __init bootmem_init_one_node(unsigned int nid)
142	{
143	unsigned long total_pages, paddr;
144	unsigned long end_pfn;
145	struct pglist_data *p;
146
147	p = NODE_DATA(nid);
148
149	/* Nothing to do.. */
150	if (!p->node_spanned_pages)
151	return;
152
6408068e	153	end_pfn = pgdat_end_pfn(p);
f5df8e26 JH	154	#ifdef CONFIG_HIGHMEM
	155	if (end_pfn > max_low_pfn)
	156	end_pfn = max_low_pfn;
	157	#endif
	158
	159	total_pages = bootmem_bootmap_pages(end_pfn - p->node_start_pfn);
	160
	161	paddr = memblock_alloc(total_pages << PAGE_SHIFT, PAGE_SIZE);
	162	if (!paddr)
	163	panic("Can't allocate bootmap for nid[%d]\n", nid);
	164
	165	init_bootmem_node(p, paddr >> PAGE_SHIFT, p->node_start_pfn, end_pfn);
	166
	167	free_bootmem_with_active_regions(nid, end_pfn);
	168
	169	/*
	170	* XXX Handle initial reservations for the system memory node
	171	* only for the moment, we'll refactor this later for handling
	172	* reservations in other nodes.
	173	*/
	174	if (nid == 0) {
	175	struct memblock_region *reg;
	176
	177	/* Reserve the sections we're already using. */
	178	for_each_memblock(reserved, reg) {
	179	unsigned long size = reg->size;
	180
	181	#ifdef CONFIG_HIGHMEM
	182	/* ...but not highmem */
	183	if (PFN_DOWN(reg->base) >= highstart_pfn)
	184	continue;
	185
	186	if (PFN_UP(reg->base + size) > highstart_pfn)
	187	size = (highstart_pfn - PFN_DOWN(reg->base))
	188	<< PAGE_SHIFT;
	189	#endif
	190
	191	reserve_bootmem(reg->base, size, BOOTMEM_DEFAULT);
	192	}
	193	}
	194
	195	sparse_memory_present_with_active_regions(nid);
	196	}
	197
	198	static void __init do_init_bootmem(void)
	199	{
	200	struct memblock_region *reg;
	201	int i;
	202
	203	/* Add active regions with valid PFNs. */
	204	for_each_memblock(memory, reg) {
	205	unsigned long start_pfn, end_pfn;
	206	start_pfn = memblock_region_memory_base_pfn(reg);
	207	end_pfn = memblock_region_memory_end_pfn(reg);
	208	memblock_set_node(PFN_PHYS(start_pfn),
e7e8de59 TC	209	PFN_PHYS(end_pfn - start_pfn),
e7e8de59 TC	210	&memblock.memory, 0);
f5df8e26 JH	211	}
	212
	213	/* All of system RAM sits in node 0 for the non-NUMA case */
	214	allocate_pgdat(0);
	215	node_set_online(0);
	216
	217	soc_mem_setup();
	218
	219	for_each_online_node(i)
	220	bootmem_init_one_node(i);
	221
	222	sparse_init();
	223	}
	224
	225	extern char _heap_start[];
	226
	227	static void __init init_and_reserve_mem(void)
	228	{
	229	unsigned long start_pfn, heap_start;
	230	u64 base = min_low_pfn << PAGE_SHIFT;
	231	u64 size = (max_low_pfn << PAGE_SHIFT) - base;
	232
	233	heap_start = (unsigned long) &_heap_start;
	234
	235	memblock_add(base, size);
	236
	237	/*
	238	* Partially used pages are not usable - thus
	239	* we are rounding upwards:
	240	*/
	241	start_pfn = PFN_UP(__pa(heap_start));
	242
	243	/*
	244	* Reserve the kernel text.
	245	*/
	246	memblock_reserve(base, (PFN_PHYS(start_pfn) + PAGE_SIZE - 1) - base);
	247
	248	#ifdef CONFIG_HIGHMEM
	249	/*
	250	* Add & reserve highmem, so page structures are initialised.
	251	*/
	252	base = highstart_pfn << PAGE_SHIFT;
	253	size = (highend_pfn << PAGE_SHIFT) - base;
	254	if (size) {
	255	memblock_add(base, size);
	256	memblock_reserve(base, size);
	257	}
	258	#endif
	259	}
	260
	261	#ifdef CONFIG_HIGHMEM
	262	/*
	263	* Ensure we have allocated page tables in swapper_pg_dir for the
	264	* fixed mappings range from 'start' to 'end'.
	265	*/
	266	static void __init allocate_pgtables(unsigned long start, unsigned long end)
	267	{
	268	pgd_t *pgd;
	269	pmd_t *pmd;
	270	pte_t *pte;
	271	int i, j;
	272	unsigned long vaddr;
	273
	274	vaddr = start;
275	i = pgd_index(vaddr);
276	j = pmd_index(vaddr);
277	pgd = swapper_pg_dir + i;
278
279	for ( ; (i < PTRS_PER_PGD) && (vaddr != end); pgd++, i++) {
280	pmd = (pmd_t *)pgd;
281	for (; (j < PTRS_PER_PMD) && (vaddr != end); pmd++, j++) {
282	vaddr += PMD_SIZE;
283
284	if (!pmd_none(*pmd))
285	continue;
286
287	pte = (pte_t *)alloc_bootmem_low_pages(PAGE_SIZE);
288	pmd_populate_kernel(&init_mm, pmd, pte);
289	}
290	j = 0;
291	}
292	}
293
294	static void __init fixedrange_init(void)
295	{
296	unsigned long vaddr, end;
297	pgd_t *pgd;
298	pud_t *pud;
299	pmd_t *pmd;
300	pte_t *pte;
301
302	/*
303	* Fixed mappings:
304	*/
305	vaddr = __fix_to_virt(__end_of_fixed_addresses - 1) & PMD_MASK;
306	end = (FIXADDR_TOP + PMD_SIZE - 1) & PMD_MASK;
307	allocate_pgtables(vaddr, end);
308
309	/*
310	* Permanent kmaps:
311	*/
312	vaddr = PKMAP_BASE;
313	allocate_pgtables(vaddr, vaddr + PAGE_SIZE*LAST_PKMAP);
314
315	pgd = swapper_pg_dir + pgd_index(vaddr);
316	pud = pud_offset(pgd, vaddr);
317	pmd = pmd_offset(pud, vaddr);
318	pte = pte_offset_kernel(pmd, vaddr);
319	pkmap_page_table = pte;
320	}
321	#endif /* CONFIG_HIGHMEM */
322
323	/*
324	* paging_init() continues the virtual memory environment setup which
325	* was begun by the code in arch/metag/kernel/setup.c.
326	*/
327	void __init paging_init(unsigned long mem_end)
328	{
329	unsigned long max_zone_pfns[MAX_NR_ZONES];
330	int nid;
331
332	init_and_reserve_mem();
333
334	memblock_allow_resize();
335
336	memblock_dump_all();
337
338	nodes_clear(node_online_map);
339
340	init_new_context(&init_task, &init_mm);
341
342	memset(swapper_pg_dir, 0, sizeof(swapper_pg_dir));
343
344	do_init_bootmem();
345	mmu_init(mem_end);
346
347	#ifdef CONFIG_HIGHMEM
348	fixedrange_init();
349	kmap_init();
350	#endif
351
352	/* Initialize the zero page to a bootmem page, already zeroed. */
353	empty_zero_page = (unsigned long)alloc_bootmem_pages(PAGE_SIZE);
354
355	user_gateway_init();
356
357	memset(max_zone_pfns, 0, sizeof(max_zone_pfns));
358
359	for_each_online_node(nid) {
360	pg_data_t *pgdat = NODE_DATA(nid);
361	unsigned long low, start_pfn;
362
363	start_pfn = pgdat->bdata->node_min_pfn;
364	low = pgdat->bdata->node_low_pfn;
365
366	if (max_zone_pfns[ZONE_NORMAL] < low)
367	max_zone_pfns[ZONE_NORMAL] = low;
368
369	#ifdef CONFIG_HIGHMEM
370	max_zone_pfns[ZONE_HIGHMEM] = highend_pfn;
371	#endif
372	pr_info("Node %u: start_pfn = 0x%lx, low = 0x%lx\n",
373	nid, start_pfn, low);
374	}
375
376	free_area_init_nodes(max_zone_pfns);
377	}
378
379	void __init mem_init(void)
380	{
f5df8e26 JH	381	#ifdef CONFIG_HIGHMEM
f5df8e26 JH	382	unsigned long tmp;
7b4b2a0d JL	383
	384	/*
	385	* Explicitly reset zone->managed_pages because highmem pages are
5ad62f24	386	* freed before calling free_all_bootmem();
7b4b2a0d JL	387	*/
7b4b2a0d JL	388	reset_all_zones_managed_pages();
a564496e JL	389	for (tmp = highstart_pfn; tmp < highend_pfn; tmp++)
a564496e JL	390	free_highmem_page(pfn_to_page(tmp));
f5df8e26 JH	391	#endif /* CONFIG_HIGHMEM */
f5df8e26 JH	392
5ad62f24	393	free_all_bootmem();
132de671	394	mem_init_print_info(NULL);
f5df8e26 JH	395	}
f5df8e26 JH	396
f5df8e26 JH	397	void free_initmem(void)
f5df8e26 JH	398	{
c9418368	399	free_initmem_default(POISON_FREE_INITMEM);
f5df8e26 JH	400	}
	401
	402	#ifdef CONFIG_BLK_DEV_INITRD
	403	void free_initrd_mem(unsigned long start, unsigned long end)
	404	{
11199692 JL	405	free_reserved_area((void )start, (void )end, POISON_FREE_INITMEM,
11199692 JL	406	"initrd");
f5df8e26 JH	407	}
f5df8e26 JH	408	#endif