[mirror_ubuntu-bionic-kernel.git] / arch / nios2 / include / asm / pgtable.h

/*
 * Copyright (C) 2011 Tobias Klauser <tklauser@distanz.ch>
 * Copyright (C) 2009 Wind River Systems Inc
 *
 * Based on asm/pgtable-32.h from mips which is:
 *
 * Copyright (C) 1994, 95, 96, 97, 98, 99, 2000, 2003 Ralf Baechle
 * Copyright (C) 1999, 2000, 2001 Silicon Graphics, Inc.
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 */

#ifndef _ASM_NIOS2_PGTABLE_H
#define _ASM_NIOS2_PGTABLE_H

#include <linux/io.h>
#include <linux/bug.h>
#include <asm/page.h>
#include <asm/cacheflush.h>
#include <asm/tlbflush.h>

#include <asm/pgtable-bits.h>
#include <asm-generic/pgtable-nopmd.h>

#define FIRST_USER_ADDRESS	0UL

#define VMALLOC_START		CONFIG_NIOS2_KERNEL_MMU_REGION_BASE
#define VMALLOC_END		(CONFIG_NIOS2_KERNEL_REGION_BASE - 1)

struct mm_struct;

/* Helper macro */
#define MKP(x, w, r) __pgprot(_PAGE_PRESENT | _PAGE_CACHED |		\
				((x) ? _PAGE_EXEC : 0) |		\
				((r) ? _PAGE_READ : 0) |		\
				((w) ? _PAGE_WRITE : 0))
/*
 * These are the macros that generic kernel code needs
 * (to populate protection_map[])
 */

/* Remove W bit on private pages for COW support */
#define __P000	MKP(0, 0, 0)
#define __P001	MKP(0, 0, 1)
#define __P010	MKP(0, 0, 0)	/* COW */
#define __P011	MKP(0, 0, 1)	/* COW */
#define __P100	MKP(1, 0, 0)
#define __P101	MKP(1, 0, 1)
#define __P110	MKP(1, 0, 0)	/* COW */
#define __P111	MKP(1, 0, 1)	/* COW */

/* Shared pages can have exact HW mapping */
#define __S000	MKP(0, 0, 0)
#define __S001	MKP(0, 0, 1)
#define __S010	MKP(0, 1, 0)
#define __S011	MKP(0, 1, 1)
#define __S100	MKP(1, 0, 0)
#define __S101	MKP(1, 0, 1)
#define __S110	MKP(1, 1, 0)
#define __S111	MKP(1, 1, 1)

/* Used all over the kernel */
#define PAGE_KERNEL __pgprot(_PAGE_PRESENT | _PAGE_CACHED | _PAGE_READ | \
			     _PAGE_WRITE | _PAGE_EXEC | _PAGE_GLOBAL)

#define PAGE_SHARED __pgprot(_PAGE_PRESENT | _PAGE_CACHED | _PAGE_READ | \
			     _PAGE_WRITE | _PAGE_ACCESSED)

#define PAGE_COPY MKP(0, 0, 1)

#define PGD_ORDER	0
#define PTE_ORDER	0

#define PTRS_PER_PGD	((PAGE_SIZE << PGD_ORDER) / sizeof(pgd_t))
#define PTRS_PER_PTE	((PAGE_SIZE << PTE_ORDER) / sizeof(pte_t))

#define USER_PTRS_PER_PGD	\
	(CONFIG_NIOS2_KERNEL_MMU_REGION_BASE / PGDIR_SIZE)

#define PGDIR_SHIFT	22
#define PGDIR_SIZE	(1UL << PGDIR_SHIFT)
#define PGDIR_MASK	(~(PGDIR_SIZE-1))

/*
 * ZERO_PAGE is a global shared page that is always zero: used
 * for zero-mapped memory areas etc..
 */
extern unsigned long empty_zero_page[PAGE_SIZE / sizeof(unsigned long)];
#define ZERO_PAGE(vaddr)	(virt_to_page(empty_zero_page))

extern pgd_t swapper_pg_dir[PTRS_PER_PGD];
extern pte_t invalid_pte_table[PAGE_SIZE/sizeof(pte_t)];

/*
 * (pmds are folded into puds so this doesn't get actually called,
 * but the define is needed for a generic inline function.)
 */
static inline void set_pmd(pmd_t *pmdptr, pmd_t pmdval)
{
	pmdptr->pud.pgd.pgd = pmdval.pud.pgd.pgd;
}

/* to find an entry in a page-table-directory */
#define pgd_index(addr)		(((addr) >> PGDIR_SHIFT) & (PTRS_PER_PGD - 1))
#define pgd_offset(mm, addr)	((mm)->pgd + pgd_index(addr))

static inline int pte_write(pte_t pte)		\
	{ return pte_val(pte) & _PAGE_WRITE; }
static inline int pte_dirty(pte_t pte)		\
	{ return pte_val(pte) & _PAGE_DIRTY; }
static inline int pte_young(pte_t pte)		\
	{ return pte_val(pte) & _PAGE_ACCESSED; }
static inline int pte_special(pte_t pte)	{ return 0; }

#define pgprot_noncached pgprot_noncached

static inline pgprot_t pgprot_noncached(pgprot_t _prot)
{
	unsigned long prot = pgprot_val(_prot);

	prot &= ~_PAGE_CACHED;

	return __pgprot(prot);
}

static inline int pte_none(pte_t pte)
{
	return !(pte_val(pte) & ~(_PAGE_GLOBAL|0xf));
}

static inline int pte_present(pte_t pte)	\
	{ return pte_val(pte) & _PAGE_PRESENT; }

/*
 * The following only work if pte_present() is true.
 * Undefined behaviour if not..
 */
static inline pte_t pte_wrprotect(pte_t pte)
{
	pte_val(pte) &= ~_PAGE_WRITE;
	return pte;
}

static inline pte_t pte_mkclean(pte_t pte)
{
	pte_val(pte) &= ~_PAGE_DIRTY;
	return pte;
}

static inline pte_t pte_mkold(pte_t pte)
{
	pte_val(pte) &= ~_PAGE_ACCESSED;
	return pte;
}

static inline pte_t pte_mkwrite(pte_t pte)
{
	pte_val(pte) |= _PAGE_WRITE;
	return pte;
}

static inline pte_t pte_mkdirty(pte_t pte)
{
	pte_val(pte) |= _PAGE_DIRTY;
	return pte;
}

static inline pte_t pte_mkspecial(pte_t pte)	{ return pte; }

static inline pte_t pte_mkyoung(pte_t pte)
{
	pte_val(pte) |= _PAGE_ACCESSED;
	return pte;
}

static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
{
	const unsigned long mask = _PAGE_READ | _PAGE_WRITE | _PAGE_EXEC;

	pte_val(pte) = (pte_val(pte) & ~mask) | (pgprot_val(newprot) & mask);
	return pte;
}

static inline int pmd_present(pmd_t pmd)
{
	return (pmd_val(pmd) != (unsigned long) invalid_pte_table)
			&& (pmd_val(pmd) != 0UL);
}

static inline void pmd_clear(pmd_t *pmdp)
{
	pmd_val(*pmdp) = (unsigned long) invalid_pte_table;
}

#define pte_pfn(pte)		(pte_val(pte) & 0xfffff)
#define pfn_pte(pfn, prot)	(__pte(pfn | pgprot_val(prot)))
#define pte_page(pte)		(pfn_to_page(pte_pfn(pte)))

/*
 * Store a linux PTE into the linux page table.
 */
static inline void set_pte(pte_t *ptep, pte_t pteval)
{
	*ptep = pteval;
}

static inline void set_pte_at(struct mm_struct *mm, unsigned long addr,
			      pte_t *ptep, pte_t pteval)
{
	unsigned long paddr = page_to_virt(pte_page(pteval));

	flush_dcache_range(paddr, paddr + PAGE_SIZE);
	set_pte(ptep, pteval);
}

static inline int pmd_none(pmd_t pmd)
{
	return (pmd_val(pmd) ==
		(unsigned long) invalid_pte_table) || (pmd_val(pmd) == 0UL);
}

#define pmd_bad(pmd)	(pmd_val(pmd) & ~PAGE_MASK)

static inline void pte_clear(struct mm_struct *mm,
				unsigned long addr, pte_t *ptep)
{
	pte_t null;

	pte_val(null) = (addr >> PAGE_SHIFT) & 0xf;

	set_pte_at(mm, addr, ptep, null);
	flush_tlb_one(addr);
}

/*
 * Conversion functions: convert a page and protection to a page entry,
 * and a page entry and page directory to the page they refer to.
 */
#define mk_pte(page, prot)	(pfn_pte(page_to_pfn(page), prot))

#define pte_unmap(pte)	do { } while (0)

/*
 * Conversion functions: convert a page and protection to a page entry,
 * and a page entry and page directory to the page they refer to.
 */
#define pmd_phys(pmd)		virt_to_phys((void *)pmd_val(pmd))
#define pmd_page(pmd)		(pfn_to_page(pmd_phys(pmd) >> PAGE_SHIFT))
#define pmd_page_vaddr(pmd)	pmd_val(pmd)

#define pte_offset_map(dir, addr)			\
	((pte_t *) page_address(pmd_page(*dir)) +	\
	 (((addr) >> PAGE_SHIFT) & (PTRS_PER_PTE - 1)))

/* to find an entry in a kernel page-table-directory */
#define pgd_offset_k(addr)	pgd_offset(&init_mm, addr)

/* Get the address to the PTE for a vaddr in specific directory */
#define pte_offset_kernel(dir, addr)			\
	((pte_t *) pmd_page_vaddr(*(dir)) +		\
	 (((addr) >> PAGE_SHIFT) & (PTRS_PER_PTE - 1)))

#define pte_ERROR(e) \
	pr_err("%s:%d: bad pte %08lx.\n", \
		__FILE__, __LINE__, pte_val(e))
#define pgd_ERROR(e) \
	pr_err("%s:%d: bad pgd %08lx.\n", \
		__FILE__, __LINE__, pgd_val(e))

/*
 * Encode and decode a swap entry (must be !pte_none(pte) && !pte_present(pte):
 *
 * 31 30 29 28 27 26 25 24 23 22 21 20 19 18 ...  1  0
 *  0  0  0  0 type.  0  0  0  0  0  0 offset.........
 *
 * This gives us up to 2**2 = 4 swap files and 2**20 * 4K = 4G per swap file.
 *
 * Note that the offset field is always non-zero, thus !pte_none(pte) is always
 * true.
 */
#define __swp_type(swp)		(((swp).val >> 26) & 0x3)
#define __swp_offset(swp)	((swp).val & 0xfffff)
#define __swp_entry(type, off)	((swp_entry_t) { (((type) & 0x3) << 26) \
						 | ((off) & 0xfffff) })
#define __swp_entry_to_pte(swp)	((pte_t) { (swp).val })
#define __pte_to_swp_entry(pte)	((swp_entry_t) { pte_val(pte) })

#define kern_addr_valid(addr)		(1)

#include <asm-generic/pgtable.h>

#define pgtable_cache_init()		do { } while (0)

extern void __init paging_init(void);
extern void __init mmu_init(void);

extern void update_mmu_cache(struct vm_area_struct *vma,
			     unsigned long address, pte_t *pte);

#endif /* _ASM_NIOS2_PGTABLE_H */
Commit	Line	Data
cbd15b3f LFT	1	/*
	2	* Copyright (C) 2011 Tobias Klauser <tklauser@distanz.ch>
	3	* Copyright (C) 2009 Wind River Systems Inc
	4	*
	5	* Based on asm/pgtable-32.h from mips which is:
	6	*
	7	* Copyright (C) 1994, 95, 96, 97, 98, 99, 2000, 2003 Ralf Baechle
	8	* Copyright (C) 1999, 2000, 2001 Silicon Graphics, Inc.
	9	*
	10	* This file is subject to the terms and conditions of the GNU General Public
	11	* License. See the file "COPYING" in the main directory of this archive
	12	* for more details.
	13	*/
	14
	15	#ifndef _ASM_NIOS2_PGTABLE_H
	16	#define _ASM_NIOS2_PGTABLE_H
	17
	18	#include <linux/io.h>
	19	#include <linux/bug.h>
	20	#include <asm/page.h>
	21	#include <asm/cacheflush.h>
	22	#include <asm/tlbflush.h>
	23
	24	#include <asm/pgtable-bits.h>
	25	#include <asm-generic/pgtable-nopmd.h>
	26
d016bf7e	27	#define FIRST_USER_ADDRESS 0UL
cbd15b3f LFT	28
	29	#define VMALLOC_START CONFIG_NIOS2_KERNEL_MMU_REGION_BASE
	30	#define VMALLOC_END (CONFIG_NIOS2_KERNEL_REGION_BASE - 1)
	31
	32	struct mm_struct;
	33
	34	/* Helper macro */
	35	#define MKP(x, w, r) __pgprot(_PAGE_PRESENT \| _PAGE_CACHED \| \
	36	((x) ? _PAGE_EXEC : 0) \| \
	37	((r) ? _PAGE_READ : 0) \| \
	38	((w) ? _PAGE_WRITE : 0))
	39	/*
	40	* These are the macros that generic kernel code needs
	41	* (to populate protection_map[])
	42	*/
	43
	44	/* Remove W bit on private pages for COW support */
	45	#define __P000 MKP(0, 0, 0)
	46	#define __P001 MKP(0, 0, 1)
	47	#define __P010 MKP(0, 0, 0) /* COW */
	48	#define __P011 MKP(0, 0, 1) /* COW */
	49	#define __P100 MKP(1, 0, 0)
	50	#define __P101 MKP(1, 0, 1)
	51	#define __P110 MKP(1, 0, 0) /* COW */
	52	#define __P111 MKP(1, 0, 1) /* COW */
	53
	54	/* Shared pages can have exact HW mapping */
	55	#define __S000 MKP(0, 0, 0)
	56	#define __S001 MKP(0, 0, 1)
	57	#define __S010 MKP(0, 1, 0)
	58	#define __S011 MKP(0, 1, 1)
	59	#define __S100 MKP(1, 0, 0)
	60	#define __S101 MKP(1, 0, 1)
	61	#define __S110 MKP(1, 1, 0)
	62	#define __S111 MKP(1, 1, 1)
	63
	64	/* Used all over the kernel */
	65	#define PAGE_KERNEL __pgprot(_PAGE_PRESENT \| _PAGE_CACHED \| _PAGE_READ \| \
	66	_PAGE_WRITE \| _PAGE_EXEC \| _PAGE_GLOBAL)
	67
	68	#define PAGE_SHARED __pgprot(_PAGE_PRESENT \| _PAGE_CACHED \| _PAGE_READ \| \
	69	_PAGE_WRITE \| _PAGE_ACCESSED)
	70
	71	#define PAGE_COPY MKP(0, 0, 1)
	72
	73	#define PGD_ORDER 0
	74	#define PTE_ORDER 0
	75
	76	#define PTRS_PER_PGD ((PAGE_SIZE << PGD_ORDER) / sizeof(pgd_t))
	77	#define PTRS_PER_PTE ((PAGE_SIZE << PTE_ORDER) / sizeof(pte_t))
	78
	79	#define USER_PTRS_PER_PGD \
	80	(CONFIG_NIOS2_KERNEL_MMU_REGION_BASE / PGDIR_SIZE)
	81
	82	#define PGDIR_SHIFT 22
	83	#define PGDIR_SIZE (1UL << PGDIR_SHIFT)
	84	#define PGDIR_MASK (~(PGDIR_SIZE-1))
	85
	86	/*
	87	* ZERO_PAGE is a global shared page that is always zero: used
	88	* for zero-mapped memory areas etc..
	89	*/
	90	extern unsigned long empty_zero_page[PAGE_SIZE / sizeof(unsigned long)];
	91	#define ZERO_PAGE(vaddr) (virt_to_page(empty_zero_page))
92
93	extern pgd_t swapper_pg_dir[PTRS_PER_PGD];
94	extern pte_t invalid_pte_table[PAGE_SIZE/sizeof(pte_t)];
95
96	/*
97	* (pmds are folded into puds so this doesn't get actually called,
98	* but the define is needed for a generic inline function.)
99	*/
100	static inline void set_pmd(pmd_t *pmdptr, pmd_t pmdval)
101	{
102	pmdptr->pud.pgd.pgd = pmdval.pud.pgd.pgd;
103	}
104
105	/* to find an entry in a page-table-directory */
106	#define pgd_index(addr) (((addr) >> PGDIR_SHIFT) & (PTRS_PER_PGD - 1))
107	#define pgd_offset(mm, addr) ((mm)->pgd + pgd_index(addr))
108
109	static inline int pte_write(pte_t pte) \
110	{ return pte_val(pte) & _PAGE_WRITE; }
111	static inline int pte_dirty(pte_t pte) \
112	{ return pte_val(pte) & _PAGE_DIRTY; }
113	static inline int pte_young(pte_t pte) \
114	{ return pte_val(pte) & _PAGE_ACCESSED; }
cbd15b3f LFT	115	static inline int pte_special(pte_t pte) { return 0; }
	116
	117	#define pgprot_noncached pgprot_noncached
	118
	119	static inline pgprot_t pgprot_noncached(pgprot_t _prot)
	120	{
	121	unsigned long prot = pgprot_val(_prot);
	122
	123	prot &= ~_PAGE_CACHED;
	124
	125	return __pgprot(prot);
	126	}
	127
	128	static inline int pte_none(pte_t pte)
	129	{
	130	return !(pte_val(pte) & ~(_PAGE_GLOBAL\|0xf));
	131	}
	132
	133	static inline int pte_present(pte_t pte) \
	134	{ return pte_val(pte) & _PAGE_PRESENT; }
	135
	136	/*
	137	* The following only work if pte_present() is true.
	138	* Undefined behaviour if not..
	139	*/
	140	static inline pte_t pte_wrprotect(pte_t pte)
	141	{
	142	pte_val(pte) &= ~_PAGE_WRITE;
	143	return pte;
	144	}
	145
	146	static inline pte_t pte_mkclean(pte_t pte)
	147	{
	148	pte_val(pte) &= ~_PAGE_DIRTY;
	149	return pte;
	150	}
	151
	152	static inline pte_t pte_mkold(pte_t pte)
	153	{
	154	pte_val(pte) &= ~_PAGE_ACCESSED;
	155	return pte;
	156	}
	157
	158	static inline pte_t pte_mkwrite(pte_t pte)
	159	{
	160	pte_val(pte) \|= _PAGE_WRITE;
	161	return pte;
	162	}
	163
	164	static inline pte_t pte_mkdirty(pte_t pte)
	165	{
	166	pte_val(pte) \|= _PAGE_DIRTY;
	167	return pte;
	168	}
	169
	170	static inline pte_t pte_mkspecial(pte_t pte) { return pte; }
	171
	172	static inline pte_t pte_mkyoung(pte_t pte)
	173	{
	174	pte_val(pte) \|= _PAGE_ACCESSED;
	175	return pte;
	176	}
	177
	178	static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
179	{
180	const unsigned long mask = _PAGE_READ \| _PAGE_WRITE \| _PAGE_EXEC;
181
182	pte_val(pte) = (pte_val(pte) & ~mask) \| (pgprot_val(newprot) & mask);
183	return pte;
184	}
185
186	static inline int pmd_present(pmd_t pmd)
187	{
188	return (pmd_val(pmd) != (unsigned long) invalid_pte_table)
189	&& (pmd_val(pmd) != 0UL);
190	}
191
192	static inline void pmd_clear(pmd_t *pmdp)
193	{
194	pmd_val(*pmdp) = (unsigned long) invalid_pte_table;
195	}
196
197	#define pte_pfn(pte) (pte_val(pte) & 0xfffff)
198	#define pfn_pte(pfn, prot) (__pte(pfn \| pgprot_val(prot)))
199	#define pte_page(pte) (pfn_to_page(pte_pfn(pte)))
200
201	/*
202	* Store a linux PTE into the linux page table.
203	*/
204	static inline void set_pte(pte_t *ptep, pte_t pteval)
205	{
206	*ptep = pteval;
207	}
208
209	static inline void set_pte_at(struct mm_struct *mm, unsigned long addr,
210	pte_t *ptep, pte_t pteval)
211	{
212	unsigned long paddr = page_to_virt(pte_page(pteval));
213
214	flush_dcache_range(paddr, paddr + PAGE_SIZE);
215	set_pte(ptep, pteval);
216	}
217
218	static inline int pmd_none(pmd_t pmd)
219	{
220	return (pmd_val(pmd) ==
221	(unsigned long) invalid_pte_table) \|\| (pmd_val(pmd) == 0UL);
222	}
223
224	#define pmd_bad(pmd) (pmd_val(pmd) & ~PAGE_MASK)
225
226	static inline void pte_clear(struct mm_struct *mm,
227	unsigned long addr, pte_t *ptep)
228	{
229	pte_t null;
230
231	pte_val(null) = (addr >> PAGE_SHIFT) & 0xf;
232
233	set_pte_at(mm, addr, ptep, null);
234	flush_tlb_one(addr);
235	}
236
237	/*
238	* Conversion functions: convert a page and protection to a page entry,
239	* and a page entry and page directory to the page they refer to.
240	*/
241	#define mk_pte(page, prot) (pfn_pte(page_to_pfn(page), prot))
242
243	#define pte_unmap(pte) do { } while (0)
244
245	/*
246	* Conversion functions: convert a page and protection to a page entry,
247	* and a page entry and page directory to the page they refer to.
248	*/
249	#define pmd_phys(pmd) virt_to_phys((void *)pmd_val(pmd))
250	#define pmd_page(pmd) (pfn_to_page(pmd_phys(pmd) >> PAGE_SHIFT))
251	#define pmd_page_vaddr(pmd) pmd_val(pmd)
252
253	#define pte_offset_map(dir, addr) \
254	((pte_t ) page_address(pmd_page(dir)) + \
255	(((addr) >> PAGE_SHIFT) & (PTRS_PER_PTE - 1)))
256
257	/* to find an entry in a kernel page-table-directory */
258	#define pgd_offset_k(addr) pgd_offset(&init_mm, addr)
259
260	/* Get the address to the PTE for a vaddr in specific directory */
261	#define pte_offset_kernel(dir, addr) \
262	((pte_t ) pmd_page_vaddr((dir)) + \
263	(((addr) >> PAGE_SHIFT) & (PTRS_PER_PTE - 1)))
264
265	#define pte_ERROR(e) \
266	pr_err("%s:%d: bad pte %08lx.\n", \
267	__FILE__, __LINE__, pte_val(e))
268	#define pgd_ERROR(e) \
269	pr_err("%s:%d: bad pgd %08lx.\n", \
270	__FILE__, __LINE__, pgd_val(e))
271
272	/*
3ee802ea	273	* Encode and decode a swap entry (must be !pte_none(pte) && !pte_present(pte):
cbd15b3f LFT	274	*
	275	* 31 30 29 28 27 26 25 24 23 22 21 20 19 18 ... 1 0
	276	* 0 0 0 0 type. 0 0 0 0 0 0 offset.........
	277	*
	278	* This gives us up to 22 = 4 swap files and 220 * 4K = 4G per swap file.
	279	*
	280	* Note that the offset field is always non-zero, thus !pte_none(pte) is always
	281	* true.
	282	*/
	283	#define __swp_type(swp) (((swp).val >> 26) & 0x3)
	284	#define __swp_offset(swp) ((swp).val & 0xfffff)
	285	#define __swp_entry(type, off) ((swp_entry_t) { (((type) & 0x3) << 26) \
	286	\| ((off) & 0xfffff) })
	287	#define __swp_entry_to_pte(swp) ((pte_t) { (swp).val })
	288	#define __pte_to_swp_entry(pte) ((swp_entry_t) { pte_val(pte) })
	289
cbd15b3f LFT	290	#define kern_addr_valid(addr) (1)
	291
	292	#include <asm-generic/pgtable.h>
	293
	294	#define pgtable_cache_init() do { } while (0)
	295
	296	extern void __init paging_init(void);
	297	extern void __init mmu_init(void);
	298
	299	extern void update_mmu_cache(struct vm_area_struct *vma,
	300	unsigned long address, pte_t *pte);
	301
	302	#endif /* _ASM_NIOS2_PGTABLE_H */