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

// SPDX-License-Identifier: GPL-2.0
// Copyright (C) 1995-2005 Russell King
// Copyright (C) 2012 ARM Ltd.
// Copyright (C) 2013-2017 Andes Technology Corporation

#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/swap.h>
#include <linux/init.h>
#include <linux/memblock.h>
#include <linux/mman.h>
#include <linux/nodemask.h>
#include <linux/initrd.h>
#include <linux/highmem.h>

#include <asm/sections.h>
#include <asm/setup.h>
#include <asm/tlb.h>
#include <asm/page.h>

DEFINE_PER_CPU(struct mmu_gather, mmu_gathers);
DEFINE_SPINLOCK(anon_alias_lock);
extern pgd_t swapper_pg_dir[PTRS_PER_PGD];
extern unsigned long phys_initrd_start;
extern unsigned long phys_initrd_size;

/*
 * empty_zero_page is a special page that is used for
 * zero-initialized data and COW.
 */
struct page *empty_zero_page;
EXPORT_SYMBOL(empty_zero_page);

static void __init zone_sizes_init(void)
{
	unsigned long zones_size[MAX_NR_ZONES];

	/* Clear the zone sizes */
	memset(zones_size, 0, sizeof(zones_size));

	zones_size[ZONE_NORMAL] = max_low_pfn;
#ifdef CONFIG_HIGHMEM
	zones_size[ZONE_HIGHMEM] = max_pfn;
#endif
	free_area_init(zones_size);

}

/*
 * Map all physical memory under high_memory into kernel's address space.
 *
 * This is explicitly coded for two-level page tables, so if you need
 * something else then this needs to change.
 */
static void __init map_ram(void)
{
	unsigned long v, p, e;
	pgd_t *pge;
	pud_t *pue;
	pmd_t *pme;
	pte_t *pte;
	/* These mark extents of read-only kernel pages...
	 * ...from vmlinux.lds.S
	 */

	p = (u32) memblock_start_of_DRAM() & PAGE_MASK;
	e = min((u32) memblock_end_of_DRAM(), (u32) __pa(high_memory));

	v = (u32) __va(p);
	pge = pgd_offset_k(v);

	while (p < e) {
		int j;
		pue = pud_offset(pge, v);
		pme = pmd_offset(pue, v);

		if ((u32) pue != (u32) pge || (u32) pme != (u32) pge) {
			panic("%s: Kernel hardcoded for "
			      "two-level page tables", __func__);
		}

		/* Alloc one page for holding PTE's... */
		pte = (pte_t *) __va(memblock_phys_alloc(PAGE_SIZE, PAGE_SIZE));
		memset(pte, 0, PAGE_SIZE);
		set_pmd(pme, __pmd(__pa(pte) + _PAGE_KERNEL_TABLE));

		/* Fill the newly allocated page with PTE'S */
		for (j = 0; p < e && j < PTRS_PER_PTE;
		     v += PAGE_SIZE, p += PAGE_SIZE, j++, pte++) {
			/* Create mapping between p and v. */
			/* TODO: more fine grant for page access permission */
			set_pte(pte, __pte(p + pgprot_val(PAGE_KERNEL)));
		}

		pge++;
	}
}
static pmd_t *fixmap_pmd_p;
static void __init fixedrange_init(void)
{
	unsigned long vaddr;
	pgd_t *pgd;
	pud_t *pud;
	pmd_t *pmd;
#ifdef CONFIG_HIGHMEM
	pte_t *pte;
#endif /* CONFIG_HIGHMEM */

	/*
	 * Fixed mappings:
	 */
	vaddr = __fix_to_virt(__end_of_fixed_addresses - 1);
	pgd = swapper_pg_dir + pgd_index(vaddr);
	pud = pud_offset(pgd, vaddr);
	pmd = pmd_offset(pud, vaddr);
	fixmap_pmd_p = (pmd_t *) __va(memblock_phys_alloc(PAGE_SIZE, PAGE_SIZE));
	memset(fixmap_pmd_p, 0, PAGE_SIZE);
	set_pmd(pmd, __pmd(__pa(fixmap_pmd_p) + _PAGE_KERNEL_TABLE));

#ifdef CONFIG_HIGHMEM
	/*
	 * Permanent kmaps:
	 */
	vaddr = PKMAP_BASE;

	pgd = swapper_pg_dir + pgd_index(vaddr);
	pud = pud_offset(pgd, vaddr);
	pmd = pmd_offset(pud, vaddr);
	pte = (pte_t *) __va(memblock_phys_alloc(PAGE_SIZE, PAGE_SIZE));
	memset(pte, 0, PAGE_SIZE);
	set_pmd(pmd, __pmd(__pa(pte) + _PAGE_KERNEL_TABLE));
	pkmap_page_table = pte;
#endif /* CONFIG_HIGHMEM */
}

/*
 * paging_init() sets up the page tables, initialises the zone memory
 * maps, and sets up the zero page, bad page and bad page tables.
 */
void __init paging_init(void)
{
	int i;
	void *zero_page;

	pr_info("Setting up paging and PTEs.\n");
	/* clear out the init_mm.pgd that will contain the kernel's mappings */
	for (i = 0; i < PTRS_PER_PGD; i++)
		swapper_pg_dir[i] = __pgd(1);

	map_ram();

	fixedrange_init();

	/* allocate space for empty_zero_page */
	zero_page = __va(memblock_phys_alloc(PAGE_SIZE, PAGE_SIZE));
	memset(zero_page, 0, PAGE_SIZE);
	zone_sizes_init();

	empty_zero_page = virt_to_page(zero_page);
	flush_dcache_page(empty_zero_page);
}

static inline void __init free_highmem(void)
{
#ifdef CONFIG_HIGHMEM
	unsigned long pfn;
	for (pfn = PFN_UP(__pa(high_memory)); pfn < max_pfn; pfn++) {
		phys_addr_t paddr = (phys_addr_t) pfn << PAGE_SHIFT;
		if (!memblock_is_reserved(paddr))
			free_highmem_page(pfn_to_page(pfn));
	}
#endif
}

static void __init set_max_mapnr_init(void)
{
	max_mapnr = max_pfn;
}

/*
 * mem_init() marks the free areas in the mem_map and tells us how much
 * memory is free.  This is done after various parts of the system have
 * claimed their memory after the kernel image.
 */
void __init mem_init(void)
{
	phys_addr_t memory_start = memblock_start_of_DRAM();
	BUG_ON(!mem_map);
	set_max_mapnr_init();

	free_highmem();

	/* this will put all low memory onto the freelists */
	memblock_free_all();
	mem_init_print_info(NULL);

	pr_info("virtual kernel memory layout:\n"
		"    fixmap  : 0x%08lx - 0x%08lx   (%4ld kB)\n"
#ifdef CONFIG_HIGHMEM
		"    pkmap   : 0x%08lx - 0x%08lx   (%4ld kB)\n"
#endif
		"    consist : 0x%08lx - 0x%08lx   (%4ld MB)\n"
		"    vmalloc : 0x%08lx - 0x%08lx   (%4ld MB)\n"
		"    lowmem  : 0x%08lx - 0x%08lx   (%4ld MB)\n"
		"      .init : 0x%08lx - 0x%08lx   (%4ld kB)\n"
		"      .data : 0x%08lx - 0x%08lx   (%4ld kB)\n"
		"      .text : 0x%08lx - 0x%08lx   (%4ld kB)\n",
		FIXADDR_START, FIXADDR_TOP, (FIXADDR_TOP - FIXADDR_START) >> 10,
#ifdef CONFIG_HIGHMEM
		PKMAP_BASE, PKMAP_BASE + LAST_PKMAP * PAGE_SIZE,
		(LAST_PKMAP * PAGE_SIZE) >> 10,
#endif
		CONSISTENT_BASE, CONSISTENT_END,
		((CONSISTENT_END) - (CONSISTENT_BASE)) >> 20, VMALLOC_START,
		(unsigned long)VMALLOC_END, (VMALLOC_END - VMALLOC_START) >> 20,
		(unsigned long)__va(memory_start), (unsigned long)high_memory,
		((unsigned long)high_memory -
		 (unsigned long)__va(memory_start)) >> 20,
		(unsigned long)&__init_begin, (unsigned long)&__init_end,
		((unsigned long)&__init_end -
		 (unsigned long)&__init_begin) >> 10, (unsigned long)&_etext,
		(unsigned long)&_edata,
		((unsigned long)&_edata - (unsigned long)&_etext) >> 10,
		(unsigned long)&_text, (unsigned long)&_etext,
		((unsigned long)&_etext - (unsigned long)&_text) >> 10);

	/*
	 * Check boundaries twice: Some fundamental inconsistencies can
	 * be detected at build time already.
	 */
#ifdef CONFIG_HIGHMEM
	BUILD_BUG_ON(PKMAP_BASE + LAST_PKMAP * PAGE_SIZE > FIXADDR_START);
	BUILD_BUG_ON((CONSISTENT_END) > PKMAP_BASE);
#endif
	BUILD_BUG_ON(VMALLOC_END > CONSISTENT_BASE);
	BUILD_BUG_ON(VMALLOC_START >= VMALLOC_END);

#ifdef CONFIG_HIGHMEM
	BUG_ON(PKMAP_BASE + LAST_PKMAP * PAGE_SIZE > FIXADDR_START);
	BUG_ON(CONSISTENT_END > PKMAP_BASE);
#endif
	BUG_ON(VMALLOC_END > CONSISTENT_BASE);
	BUG_ON(VMALLOC_START >= VMALLOC_END);
	BUG_ON((unsigned long)high_memory > VMALLOC_START);

	return;
}

void free_initmem(void)
{
	free_initmem_default(-1);
}

#ifdef CONFIG_BLK_DEV_INITRD
void free_initrd_mem(unsigned long start, unsigned long end)
{
	free_reserved_area((void *)start, (void *)end, -1, "initrd");
}
#endif

void __set_fixmap(enum fixed_addresses idx,
			       phys_addr_t phys, pgprot_t flags)
{
	unsigned long addr = __fix_to_virt(idx);
	pte_t *pte;

	BUG_ON(idx <= FIX_HOLE || idx >= __end_of_fixed_addresses);

	pte = (pte_t *)&fixmap_pmd_p[pte_index(addr)];;

	if (pgprot_val(flags)) {
		set_pte(pte, pfn_pte(phys >> PAGE_SHIFT, flags));
	} else {
		pte_clear(&init_mm, addr, pte);
		flush_tlb_kernel_range(addr, addr + PAGE_SIZE);
	}
}
Commit	Line	Data
59fd53cd GH	1	// SPDX-License-Identifier: GPL-2.0
	2	// Copyright (C) 1995-2005 Russell King
	3	// Copyright (C) 2012 ARM Ltd.
	4	// Copyright (C) 2013-2017 Andes Technology Corporation
	5
	6	#include <linux/kernel.h>
	7	#include <linux/errno.h>
	8	#include <linux/swap.h>
	9	#include <linux/init.h>
57c8a661	10	#include <linux/memblock.h>
59fd53cd GH	11	#include <linux/mman.h>
	12	#include <linux/nodemask.h>
	13	#include <linux/initrd.h>
	14	#include <linux/highmem.h>
59fd53cd GH	15
	16	#include <asm/sections.h>
	17	#include <asm/setup.h>
	18	#include <asm/tlb.h>
	19	#include <asm/page.h>
	20
	21	DEFINE_PER_CPU(struct mmu_gather, mmu_gathers);
	22	DEFINE_SPINLOCK(anon_alias_lock);
	23	extern pgd_t swapper_pg_dir[PTRS_PER_PGD];
	24	extern unsigned long phys_initrd_start;
	25	extern unsigned long phys_initrd_size;
	26
	27	/*
	28	* empty_zero_page is a special page that is used for
	29	* zero-initialized data and COW.
	30	*/
	31	struct page *empty_zero_page;
e3f46243	32	EXPORT_SYMBOL(empty_zero_page);
59fd53cd GH	33
	34	static void __init zone_sizes_init(void)
	35	{
	36	unsigned long zones_size[MAX_NR_ZONES];
	37
	38	/* Clear the zone sizes */
	39	memset(zones_size, 0, sizeof(zones_size));
	40
	41	zones_size[ZONE_NORMAL] = max_low_pfn;
	42	#ifdef CONFIG_HIGHMEM
	43	zones_size[ZONE_HIGHMEM] = max_pfn;
	44	#endif
	45	free_area_init(zones_size);
	46
	47	}
	48
	49	/*
	50	* Map all physical memory under high_memory into kernel's address space.
	51	*
	52	* This is explicitly coded for two-level page tables, so if you need
	53	* something else then this needs to change.
	54	*/
	55	static void __init map_ram(void)
	56	{
	57	unsigned long v, p, e;
	58	pgd_t *pge;
	59	pud_t *pue;
	60	pmd_t *pme;
	61	pte_t *pte;
	62	/* These mark extents of read-only kernel pages...
	63	* ...from vmlinux.lds.S
	64	*/
	65
	66	p = (u32) memblock_start_of_DRAM() & PAGE_MASK;
	67	e = min((u32) memblock_end_of_DRAM(), (u32) __pa(high_memory));
	68
	69	v = (u32) __va(p);
	70	pge = pgd_offset_k(v);
	71
	72	while (p < e) {
	73	int j;
	74	pue = pud_offset(pge, v);
	75	pme = pmd_offset(pue, v);
	76
	77	if ((u32) pue != (u32) pge \|\| (u32) pme != (u32) pge) {
	78	panic("%s: Kernel hardcoded for "
	79	"two-level page tables", __func__);
	80	}
	81
	82	/* Alloc one page for holding PTE's... */
9a8dd708	83	pte = (pte_t *) __va(memblock_phys_alloc(PAGE_SIZE, PAGE_SIZE));
59fd53cd GH	84	memset(pte, 0, PAGE_SIZE);
	85	set_pmd(pme, __pmd(__pa(pte) + _PAGE_KERNEL_TABLE));
	86
	87	/* Fill the newly allocated page with PTE'S */
	88	for (j = 0; p < e && j < PTRS_PER_PTE;
	89	v += PAGE_SIZE, p += PAGE_SIZE, j++, pte++) {
	90	/* Create mapping between p and v. */
	91	/* TODO: more fine grant for page access permission */
	92	set_pte(pte, __pte(p + pgprot_val(PAGE_KERNEL)));
	93	}
	94
	95	pge++;
	96	}
	97	}
	98	static pmd_t *fixmap_pmd_p;
	99	static void __init fixedrange_init(void)
	100	{
	101	unsigned long vaddr;
	102	pgd_t *pgd;
	103	pud_t *pud;
	104	pmd_t *pmd;
	105	#ifdef CONFIG_HIGHMEM
	106	pte_t *pte;
	107	#endif /* CONFIG_HIGHMEM */
	108
	109	/*
	110	* Fixed mappings:
	111	*/
	112	vaddr = __fix_to_virt(__end_of_fixed_addresses - 1);
	113	pgd = swapper_pg_dir + pgd_index(vaddr);
	114	pud = pud_offset(pgd, vaddr);
	115	pmd = pmd_offset(pud, vaddr);
9a8dd708	116	fixmap_pmd_p = (pmd_t *) __va(memblock_phys_alloc(PAGE_SIZE, PAGE_SIZE));
59fd53cd GH	117	memset(fixmap_pmd_p, 0, PAGE_SIZE);
	118	set_pmd(pmd, __pmd(__pa(fixmap_pmd_p) + _PAGE_KERNEL_TABLE));
	119
	120	#ifdef CONFIG_HIGHMEM
	121	/*
	122	* Permanent kmaps:
	123	*/
	124	vaddr = PKMAP_BASE;
	125
	126	pgd = swapper_pg_dir + pgd_index(vaddr);
	127	pud = pud_offset(pgd, vaddr);
	128	pmd = pmd_offset(pud, vaddr);
9a8dd708	129	pte = (pte_t *) __va(memblock_phys_alloc(PAGE_SIZE, PAGE_SIZE));
59fd53cd GH	130	memset(pte, 0, PAGE_SIZE);
	131	set_pmd(pmd, __pmd(__pa(pte) + _PAGE_KERNEL_TABLE));
	132	pkmap_page_table = pte;
	133	#endif /* CONFIG_HIGHMEM */
	134	}
	135
	136	/*
	137	* paging_init() sets up the page tables, initialises the zone memory
	138	* maps, and sets up the zero page, bad page and bad page tables.
	139	*/
	140	void __init paging_init(void)
	141	{
	142	int i;
	143	void *zero_page;
	144
	145	pr_info("Setting up paging and PTEs.\n");
	146	/* clear out the init_mm.pgd that will contain the kernel's mappings */
	147	for (i = 0; i < PTRS_PER_PGD; i++)
	148	swapper_pg_dir[i] = __pgd(1);
	149
	150	map_ram();
	151
	152	fixedrange_init();
	153
	154	/* allocate space for empty_zero_page */
9a8dd708	155	zero_page = __va(memblock_phys_alloc(PAGE_SIZE, PAGE_SIZE));
59fd53cd GH	156	memset(zero_page, 0, PAGE_SIZE);
	157	zone_sizes_init();
	158
	159	empty_zero_page = virt_to_page(zero_page);
	160	flush_dcache_page(empty_zero_page);
	161	}
	162
	163	static inline void __init free_highmem(void)
	164	{
	165	#ifdef CONFIG_HIGHMEM
	166	unsigned long pfn;
	167	for (pfn = PFN_UP(__pa(high_memory)); pfn < max_pfn; pfn++) {
	168	phys_addr_t paddr = (phys_addr_t) pfn << PAGE_SHIFT;
	169	if (!memblock_is_reserved(paddr))
	170	free_highmem_page(pfn_to_page(pfn));
	171	}
	172	#endif
	173	}
	174
	175	static void __init set_max_mapnr_init(void)
	176	{
	177	max_mapnr = max_pfn;
	178	}
	179
	180	/*
	181	* mem_init() marks the free areas in the mem_map and tells us how much
	182	* memory is free. This is done after various parts of the system have
	183	* claimed their memory after the kernel image.
	184	*/
	185	void __init mem_init(void)
	186	{
	187	phys_addr_t memory_start = memblock_start_of_DRAM();
	188	BUG_ON(!mem_map);
	189	set_max_mapnr_init();
	190
	191	free_highmem();
	192
	193	/* this will put all low memory onto the freelists */
c6ffc5ca	194	memblock_free_all();
59fd53cd GH	195	mem_init_print_info(NULL);
	196
	197	pr_info("virtual kernel memory layout:\n"
	198	" fixmap : 0x%08lx - 0x%08lx (%4ld kB)\n"
	199	#ifdef CONFIG_HIGHMEM
	200	" pkmap : 0x%08lx - 0x%08lx (%4ld kB)\n"
	201	#endif
	202	" consist : 0x%08lx - 0x%08lx (%4ld MB)\n"
	203	" vmalloc : 0x%08lx - 0x%08lx (%4ld MB)\n"
	204	" lowmem : 0x%08lx - 0x%08lx (%4ld MB)\n"
	205	" .init : 0x%08lx - 0x%08lx (%4ld kB)\n"
	206	" .data : 0x%08lx - 0x%08lx (%4ld kB)\n"
	207	" .text : 0x%08lx - 0x%08lx (%4ld kB)\n",
	208	FIXADDR_START, FIXADDR_TOP, (FIXADDR_TOP - FIXADDR_START) >> 10,
	209	#ifdef CONFIG_HIGHMEM
	210	PKMAP_BASE, PKMAP_BASE + LAST_PKMAP * PAGE_SIZE,
	211	(LAST_PKMAP * PAGE_SIZE) >> 10,
	212	#endif
	213	CONSISTENT_BASE, CONSISTENT_END,
	214	((CONSISTENT_END) - (CONSISTENT_BASE)) >> 20, VMALLOC_START,
	215	(unsigned long)VMALLOC_END, (VMALLOC_END - VMALLOC_START) >> 20,
	216	(unsigned long)__va(memory_start), (unsigned long)high_memory,
	217	((unsigned long)high_memory -
	218	(unsigned long)__va(memory_start)) >> 20,
	219	(unsigned long)&__init_begin, (unsigned long)&__init_end,
	220	((unsigned long)&__init_end -
	221	(unsigned long)&__init_begin) >> 10, (unsigned long)&_etext,
	222	(unsigned long)&_edata,
	223	((unsigned long)&_edata - (unsigned long)&_etext) >> 10,
	224	(unsigned long)&_text, (unsigned long)&_etext,
	225	((unsigned long)&_etext - (unsigned long)&_text) >> 10);
	226
	227	/*
	228	* Check boundaries twice: Some fundamental inconsistencies can
	229	* be detected at build time already.
	230	*/
	231	#ifdef CONFIG_HIGHMEM
	232	BUILD_BUG_ON(PKMAP_BASE + LAST_PKMAP * PAGE_SIZE > FIXADDR_START);
	233	BUILD_BUG_ON((CONSISTENT_END) > PKMAP_BASE);
	234	#endif
	235	BUILD_BUG_ON(VMALLOC_END > CONSISTENT_BASE);
	236	BUILD_BUG_ON(VMALLOC_START >= VMALLOC_END);
	237
	238	#ifdef CONFIG_HIGHMEM
	239	BUG_ON(PKMAP_BASE + LAST_PKMAP * PAGE_SIZE > FIXADDR_START);
	240	BUG_ON(CONSISTENT_END > PKMAP_BASE);
	241	#endif
	242	BUG_ON(VMALLOC_END > CONSISTENT_BASE);
	243	BUG_ON(VMALLOC_START >= VMALLOC_END);
	244	BUG_ON((unsigned long)high_memory > VMALLOC_START);
	245
	246	return;
	247	}
	248
	249	void free_initmem(void)
	250	{
	251	free_initmem_default(-1);
	252	}
	253
	254	#ifdef CONFIG_BLK_DEV_INITRD
	255	void free_initrd_mem(unsigned long start, unsigned long end)
	256	{
	257	free_reserved_area((void )start, (void )end, -1, "initrd");
	258	}
259	#endif
260
261	void __set_fixmap(enum fixed_addresses idx,
262	phys_addr_t phys, pgprot_t flags)
263	{
264	unsigned long addr = __fix_to_virt(idx);
265	pte_t *pte;
266
267	BUG_ON(idx <= FIX_HOLE \|\| idx >= __end_of_fixed_addresses);
268
269	pte = (pte_t *)&fixmap_pmd_p[pte_index(addr)];;
270
271	if (pgprot_val(flags)) {
272	set_pte(pte, pfn_pte(phys >> PAGE_SHIFT, flags));
273	} else {
274	pte_clear(&init_mm, addr, pte);
275	flush_tlb_kernel_range(addr, addr + PAGE_SIZE);
276	}
277	}