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