1/*
  2 * Copyright 2010 Tilera Corporation. All Rights Reserved.
  3 *
  4 *   This program is free software; you can redistribute it and/or
  5 *   modify it under the terms of the GNU General Public License
  6 *   as published by the Free Software Foundation, version 2.
  7 *
  8 *   This program is distributed in the hope that it will be useful, but
  9 *   WITHOUT ANY WARRANTY; without even the implied warranty of
 10 *   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
 11 *   NON INFRINGEMENT.  See the GNU General Public License for
 12 *   more details.
 13 */
 14
 15#ifndef _ASM_TILE_PAGE_H
 16#define _ASM_TILE_PAGE_H
 17
 18#include <linux/const.h>
 19#include <hv/hypervisor.h>
 20#include <arch/chip.h>
 21
 22/* PAGE_SHIFT and HPAGE_SHIFT determine the page sizes. */
 23#if defined(CONFIG_PAGE_SIZE_16KB)
 24#define PAGE_SHIFT	14
 25#define CTX_PAGE_FLAG	HV_CTX_PG_SM_16K
 26#elif defined(CONFIG_PAGE_SIZE_64KB)
 27#define PAGE_SHIFT	16
 28#define CTX_PAGE_FLAG	HV_CTX_PG_SM_64K
 29#else
 30#define PAGE_SHIFT	HV_LOG2_DEFAULT_PAGE_SIZE_SMALL
 31#define CTX_PAGE_FLAG	0
 32#endif
 33#define HPAGE_SHIFT	HV_LOG2_DEFAULT_PAGE_SIZE_LARGE
 34
 35#define PAGE_SIZE	(_AC(1, UL) << PAGE_SHIFT)
 36#define HPAGE_SIZE	(_AC(1, UL) << HPAGE_SHIFT)
 37
 38#define PAGE_MASK	(~(PAGE_SIZE - 1))
 39#define HPAGE_MASK	(~(HPAGE_SIZE - 1))
 40
 41/*
 42 * If the Kconfig doesn't specify, set a maximum zone order that
 43 * is enough so that we can create huge pages from small pages given
 44 * the respective sizes of the two page types.  See <linux/mmzone.h>.
 45 */
 46#ifndef CONFIG_FORCE_MAX_ZONEORDER
 47#define CONFIG_FORCE_MAX_ZONEORDER (HPAGE_SHIFT - PAGE_SHIFT + 1)
 48#endif
 49
 50#ifndef __ASSEMBLY__
 51
 52#include <linux/types.h>
 53#include <linux/string.h>
 54
 55struct page;
 56
 57static inline void clear_page(void *page)
 58{
 59	memset(page, 0, PAGE_SIZE);
 60}
 61
 62static inline void copy_page(void *to, void *from)
 63{
 64	memcpy(to, from, PAGE_SIZE);
 65}
 66
 67static inline void clear_user_page(void *page, unsigned long vaddr,
 68				struct page *pg)
 69{
 70	clear_page(page);
 71}
 72
 73static inline void copy_user_page(void *to, void *from, unsigned long vaddr,
 74				struct page *topage)
 75{
 76	copy_page(to, from);
 77}
 78
 79/*
 80 * Hypervisor page tables are made of the same basic structure.
 81 */
 82
 83typedef HV_PTE pte_t;
 84typedef HV_PTE pgd_t;
 85typedef HV_PTE pgprot_t;
 86
 87/*
 88 * User L2 page tables are managed as one L2 page table per page,
 89 * because we use the page allocator for them.  This keeps the allocation
 90 * simple, but it's also inefficient, since L2 page tables are much smaller
 91 * than pages (currently 2KB vs 64KB).  So we should revisit this.
 92 */
 93typedef struct page *pgtable_t;
 94
 95/* Must be a macro since it is used to create constants. */
 96#define __pgprot(val) hv_pte(val)
 97
 98/* Rarely-used initializers, typically with a "zero" value. */
 99#define __pte(x) hv_pte(x)
100#define __pgd(x) hv_pte(x)
101
102static inline u64 pgprot_val(pgprot_t pgprot)
103{
104	return hv_pte_val(pgprot);
105}
106
107static inline u64 pte_val(pte_t pte)
108{
109	return hv_pte_val(pte);
110}
111
112static inline u64 pgd_val(pgd_t pgd)
113{
114	return hv_pte_val(pgd);
115}
116
117#ifdef __tilegx__
118
119typedef HV_PTE pmd_t;
120
121#define __pmd(x) hv_pte(x)
122
123static inline u64 pmd_val(pmd_t pmd)
124{
125	return hv_pte_val(pmd);
126}
127
128#endif
129
130static inline __attribute_const__ int get_order(unsigned long size)
131{
132	return BITS_PER_LONG - __builtin_clzl((size - 1) >> PAGE_SHIFT);
133}
134
135#endif /* !__ASSEMBLY__ */
136
137#define HUGETLB_PAGE_ORDER	(HPAGE_SHIFT - PAGE_SHIFT)
138
139#define HUGE_MAX_HSTATE		6
140
141#ifdef CONFIG_HUGETLB_PAGE
142#define HAVE_ARCH_HUGETLB_UNMAPPED_AREA
143#endif
144
145/* Each memory controller has PAs distinct in their high bits. */
146#define NR_PA_HIGHBIT_SHIFT (CHIP_PA_WIDTH() - CHIP_LOG_NUM_MSHIMS())
147#define NR_PA_HIGHBIT_VALUES (1 << CHIP_LOG_NUM_MSHIMS())
148#define __pa_to_highbits(pa) ((phys_addr_t)(pa) >> NR_PA_HIGHBIT_SHIFT)
149#define __pfn_to_highbits(pfn) ((pfn) >> (NR_PA_HIGHBIT_SHIFT - PAGE_SHIFT))
150
151#ifdef __tilegx__
152
153/*
154 * We reserve the lower half of memory for user-space programs, and the
155 * upper half for system code.  We re-map all of physical memory in the
156 * upper half, which takes a quarter of our VA space.  Then we have
157 * the vmalloc regions.  The supervisor code lives at 0xfffffff700000000,
158 * with the hypervisor above that.
159 *
160 * Loadable kernel modules are placed immediately after the static
161 * supervisor code, with each being allocated a 256MB region of
162 * address space, so we don't have to worry about the range of "jal"
163 * and other branch instructions.
164 *
165 * For now we keep life simple and just allocate one pmd (4GB) for vmalloc.
166 * Similarly, for now we don't play any struct page mapping games.
167 */
168
169#if CHIP_PA_WIDTH() + 2 > CHIP_VA_WIDTH()
170# error Too much PA to map with the VA available!
171#endif
172#define HALF_VA_SPACE           (_AC(1, UL) << (CHIP_VA_WIDTH() - 1))
173
174#define MEM_LOW_END		(HALF_VA_SPACE - 1)         /* low half */
175#define MEM_HIGH_START		(-HALF_VA_SPACE)            /* high half */
176#define PAGE_OFFSET		MEM_HIGH_START
177#define _VMALLOC_START		_AC(0xfffffff500000000, UL) /* 4 GB */
178#define HUGE_VMAP_BASE		_AC(0xfffffff600000000, UL) /* 4 GB */
179#define MEM_SV_START		_AC(0xfffffff700000000, UL) /* 256 MB */
180#define MEM_SV_INTRPT		MEM_SV_START
181#define MEM_MODULE_START	_AC(0xfffffff710000000, UL) /* 256 MB */
182#define MEM_MODULE_END		(MEM_MODULE_START + (256*1024*1024))
183#define MEM_HV_START		_AC(0xfffffff800000000, UL) /* 32 GB */
184
185/* Highest DTLB address we will use */
186#define KERNEL_HIGH_VADDR	MEM_SV_START
187
188/* Since we don't currently provide any fixmaps, we use an impossible VA. */
189#define FIXADDR_TOP             MEM_HV_START
190
191#else /* !__tilegx__ */
192
193/*
194 * A PAGE_OFFSET of 0xC0000000 means that the kernel has
195 * a virtual address space of one gigabyte, which limits the
196 * amount of physical memory you can use to about 768MB.
197 * If you want more physical memory than this then see the CONFIG_HIGHMEM
198 * option in the kernel configuration.
199 *
200 * The top 16MB chunk in the table below is unavailable to Linux.  Since
201 * the kernel interrupt vectors must live at ether 0xfe000000 or 0xfd000000
202 * (depending on whether the kernel is at PL2 or Pl1), we map all of the
203 * bottom of RAM at this address with a huge page table entry to minimize
204 * its ITLB footprint (as well as at PAGE_OFFSET).  The last architected
205 * requirement is that user interrupt vectors live at 0xfc000000, so we
206 * make that range of memory available to user processes.  The remaining
207 * regions are sized as shown; the first four addresses use the PL 1
208 * values, and after that, we show "typical" values, since the actual
209 * addresses depend on kernel #defines.
210 *
211 * MEM_HV_INTRPT                   0xfe000000
212 * MEM_SV_INTRPT (kernel code)     0xfd000000
213 * MEM_USER_INTRPT (user vector)   0xfc000000
214 * FIX_KMAP_xxx                    0xf8000000 (via NR_CPUS * KM_TYPE_NR)
215 * PKMAP_BASE                      0xf7000000 (via LAST_PKMAP)
216 * HUGE_VMAP                       0xf3000000 (via CONFIG_NR_HUGE_VMAPS)
217 * VMALLOC_START                   0xf0000000 (via __VMALLOC_RESERVE)
218 * mapped LOWMEM                   0xc0000000
219 */
220
221#define MEM_USER_INTRPT		_AC(0xfc000000, UL)
222#if CONFIG_KERNEL_PL == 1
223#define MEM_SV_INTRPT		_AC(0xfd000000, UL)
224#define MEM_HV_INTRPT		_AC(0xfe000000, UL)
225#else
226#define MEM_GUEST_INTRPT	_AC(0xfd000000, UL)
227#define MEM_SV_INTRPT		_AC(0xfe000000, UL)
228#define MEM_HV_INTRPT		_AC(0xff000000, UL)
229#endif
230
231#define INTRPT_SIZE		0x4000
232
233/* Tolerate page size larger than the architecture interrupt region size. */
234#if PAGE_SIZE > INTRPT_SIZE
235#undef INTRPT_SIZE
236#define INTRPT_SIZE PAGE_SIZE
237#endif
238
239#define KERNEL_HIGH_VADDR	MEM_USER_INTRPT
240#define FIXADDR_TOP		(KERNEL_HIGH_VADDR - PAGE_SIZE)
241
242#define PAGE_OFFSET		_AC(CONFIG_PAGE_OFFSET, UL)
243
244/* On 32-bit architectures we mix kernel modules in with other vmaps. */
245#define MEM_MODULE_START	VMALLOC_START
246#define MEM_MODULE_END		VMALLOC_END
247
248#endif /* __tilegx__ */
249
250#ifndef __ASSEMBLY__
251
252#ifdef CONFIG_HIGHMEM
253
254/* Map kernel virtual addresses to page frames, in HPAGE_SIZE chunks. */
255extern unsigned long pbase_map[];
256extern void *vbase_map[];
257
258static inline unsigned long kaddr_to_pfn(const volatile void *_kaddr)
259{
260	unsigned long kaddr = (unsigned long)_kaddr;
261	return pbase_map[kaddr >> HPAGE_SHIFT] +
262		((kaddr & (HPAGE_SIZE - 1)) >> PAGE_SHIFT);
263}
264
265static inline void *pfn_to_kaddr(unsigned long pfn)
266{
267	return vbase_map[__pfn_to_highbits(pfn)] + (pfn << PAGE_SHIFT);
268}
269
270static inline phys_addr_t virt_to_phys(const volatile void *kaddr)
271{
272	unsigned long pfn = kaddr_to_pfn(kaddr);
273	return ((phys_addr_t)pfn << PAGE_SHIFT) +
274		((unsigned long)kaddr & (PAGE_SIZE-1));
275}
276
277static inline void *phys_to_virt(phys_addr_t paddr)
278{
279	return pfn_to_kaddr(paddr >> PAGE_SHIFT) + (paddr & (PAGE_SIZE-1));
280}
281
282/* With HIGHMEM, we pack PAGE_OFFSET through high_memory with all valid VAs. */
283static inline int virt_addr_valid(const volatile void *kaddr)
284{
285	extern void *high_memory;  /* copied from <linux/mm.h> */
286	return ((unsigned long)kaddr >= PAGE_OFFSET && kaddr < high_memory);
287}
288
289#else /* !CONFIG_HIGHMEM */
290
291static inline unsigned long kaddr_to_pfn(const volatile void *kaddr)
292{
293	return ((unsigned long)kaddr - PAGE_OFFSET) >> PAGE_SHIFT;
294}
295
296static inline void *pfn_to_kaddr(unsigned long pfn)
297{
298	return (void *)((pfn << PAGE_SHIFT) + PAGE_OFFSET);
299}
300
301static inline phys_addr_t virt_to_phys(const volatile void *kaddr)
302{
303	return (phys_addr_t)((unsigned long)kaddr - PAGE_OFFSET);
304}
305
306static inline void *phys_to_virt(phys_addr_t paddr)
307{
308	return (void *)((unsigned long)paddr + PAGE_OFFSET);
309}
310
311/* Check that the given address is within some mapped range of PAs. */
312#define virt_addr_valid(kaddr) pfn_valid(kaddr_to_pfn(kaddr))
313
314#endif /* !CONFIG_HIGHMEM */
315
316/* All callers are not consistent in how they call these functions. */
317#define __pa(kaddr) virt_to_phys((void *)(unsigned long)(kaddr))
318#define __va(paddr) phys_to_virt((phys_addr_t)(paddr))
319
320extern int devmem_is_allowed(unsigned long pagenr);
321
322#ifdef CONFIG_FLATMEM
323static inline int pfn_valid(unsigned long pfn)
324{
325	return pfn < max_mapnr;
326}
327#endif
328
329/* Provide as macros since these require some other headers included. */
330#define page_to_pa(page) ((phys_addr_t)(page_to_pfn(page)) << PAGE_SHIFT)
331#define virt_to_page(kaddr) pfn_to_page(kaddr_to_pfn((void *)(kaddr)))
332#define page_to_virt(page) pfn_to_kaddr(page_to_pfn(page))
333
334struct mm_struct;
335extern pte_t *virt_to_pte(struct mm_struct *mm, unsigned long addr);
336
337#endif /* !__ASSEMBLY__ */
338
339#define VM_DATA_DEFAULT_FLAGS \
340	(VM_READ | VM_WRITE | VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC)
341
342#include <asm-generic/memory_model.h>
343
344#endif /* _ASM_TILE_PAGE_H */