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