Don't include linux/config.h from anywhere else in include/
[powerpc.git] / include / asm-mips / pgtable.h
1 /*
2  * This file is subject to the terms and conditions of the GNU General Public
3  * License.  See the file "COPYING" in the main directory of this archive
4  * for more details.
5  *
6  * Copyright (C) 2003 Ralf Baechle
7  */
8 #ifndef _ASM_PGTABLE_H
9 #define _ASM_PGTABLE_H
10
11 #ifdef CONFIG_32BIT
12 #include <asm/pgtable-32.h>
13 #endif
14 #ifdef CONFIG_64BIT
15 #include <asm/pgtable-64.h>
16 #endif
17
18 #include <asm/io.h>
19 #include <asm/pgtable-bits.h>
20
21 struct mm_struct;
22 struct vm_area_struct;
23
24 #define PAGE_NONE       __pgprot(_PAGE_PRESENT | _CACHE_CACHABLE_NONCOHERENT)
25 #define PAGE_SHARED     __pgprot(_PAGE_PRESENT | _PAGE_READ | _PAGE_WRITE | \
26                         PAGE_CACHABLE_DEFAULT)
27 #define PAGE_COPY       __pgprot(_PAGE_PRESENT | _PAGE_READ | \
28                         PAGE_CACHABLE_DEFAULT)
29 #define PAGE_READONLY   __pgprot(_PAGE_PRESENT | _PAGE_READ | \
30                         PAGE_CACHABLE_DEFAULT)
31 #define PAGE_KERNEL     __pgprot(_PAGE_PRESENT | __READABLE | __WRITEABLE | \
32                         _PAGE_GLOBAL | PAGE_CACHABLE_DEFAULT)
33 #define PAGE_USERIO     __pgprot(_PAGE_PRESENT | _PAGE_READ | _PAGE_WRITE | \
34                         PAGE_CACHABLE_DEFAULT)
35 #define PAGE_KERNEL_UNCACHED __pgprot(_PAGE_PRESENT | __READABLE | \
36                         __WRITEABLE | _PAGE_GLOBAL | _CACHE_UNCACHED)
37
38 /*
39  * MIPS can't do page protection for execute, and considers that the same like
40  * read. Also, write permissions imply read permissions. This is the closest
41  * we can get by reasonable means..
42  */
43 #define __P000  PAGE_NONE
44 #define __P001  PAGE_READONLY
45 #define __P010  PAGE_COPY
46 #define __P011  PAGE_COPY
47 #define __P100  PAGE_READONLY
48 #define __P101  PAGE_READONLY
49 #define __P110  PAGE_COPY
50 #define __P111  PAGE_COPY
51
52 #define __S000  PAGE_NONE
53 #define __S001  PAGE_READONLY
54 #define __S010  PAGE_SHARED
55 #define __S011  PAGE_SHARED
56 #define __S100  PAGE_READONLY
57 #define __S101  PAGE_READONLY
58 #define __S110  PAGE_SHARED
59 #define __S111  PAGE_SHARED
60
61 /*
62  * ZERO_PAGE is a global shared page that is always zero; used
63  * for zero-mapped memory areas etc..
64  */
65
66 extern unsigned long empty_zero_page;
67 extern unsigned long zero_page_mask;
68
69 #define ZERO_PAGE(vaddr) \
70         (virt_to_page(empty_zero_page + (((unsigned long)(vaddr)) & zero_page_mask)))
71
72 #define __HAVE_ARCH_MULTIPLE_ZERO_PAGE
73
74 extern void paging_init(void);
75
76 /*
77  * Conversion functions: convert a page and protection to a page entry,
78  * and a page entry and page directory to the page they refer to.
79  */
80 #define pmd_phys(pmd)           (pmd_val(pmd) - PAGE_OFFSET)
81 #define pmd_page(pmd)           (pfn_to_page(pmd_phys(pmd) >> PAGE_SHIFT))
82 #define pmd_page_kernel(pmd)    pmd_val(pmd)
83
84 #define pte_none(pte)           (!(pte_val(pte) & ~_PAGE_GLOBAL))
85 #define pte_present(pte)        (pte_val(pte) & _PAGE_PRESENT)
86
87 #if defined(CONFIG_64BIT_PHYS_ADDR) && defined(CONFIG_CPU_MIPS32_R1)
88 static inline void set_pte(pte_t *ptep, pte_t pte)
89 {
90         ptep->pte_high = pte.pte_high;
91         smp_wmb();
92         ptep->pte_low = pte.pte_low;
93         //printk("pte_high %x pte_low %x\n", ptep->pte_high, ptep->pte_low);
94
95         if (pte_val(pte) & _PAGE_GLOBAL) {
96                 pte_t *buddy = ptep_buddy(ptep);
97                 /*
98                  * Make sure the buddy is global too (if it's !none,
99                  * it better already be global)
100                  */
101                 if (pte_none(*buddy))
102                         buddy->pte_low |= _PAGE_GLOBAL;
103         }
104 }
105 #define set_pte_at(mm,addr,ptep,pteval) set_pte(ptep,pteval)
106
107 static inline void pte_clear(struct mm_struct *mm, unsigned long addr, pte_t *ptep)
108 {
109         /* Preserve global status for the pair */
110         if (pte_val(*ptep_buddy(ptep)) & _PAGE_GLOBAL)
111                 set_pte_at(mm, addr, ptep, __pte(_PAGE_GLOBAL));
112         else
113                 set_pte_at(mm, addr, ptep, __pte(0));
114 }
115 #else
116 /*
117  * Certain architectures need to do special things when pte's
118  * within a page table are directly modified.  Thus, the following
119  * hook is made available.
120  */
121 static inline void set_pte(pte_t *ptep, pte_t pteval)
122 {
123         *ptep = pteval;
124 #if !defined(CONFIG_CPU_R3000) && !defined(CONFIG_CPU_TX39XX)
125         if (pte_val(pteval) & _PAGE_GLOBAL) {
126                 pte_t *buddy = ptep_buddy(ptep);
127                 /*
128                  * Make sure the buddy is global too (if it's !none,
129                  * it better already be global)
130                  */
131                 if (pte_none(*buddy))
132                         pte_val(*buddy) = pte_val(*buddy) | _PAGE_GLOBAL;
133         }
134 #endif
135 }
136 #define set_pte_at(mm,addr,ptep,pteval) set_pte(ptep,pteval)
137
138 static inline void pte_clear(struct mm_struct *mm, unsigned long addr, pte_t *ptep)
139 {
140 #if !defined(CONFIG_CPU_R3000) && !defined(CONFIG_CPU_TX39XX)
141         /* Preserve global status for the pair */
142         if (pte_val(*ptep_buddy(ptep)) & _PAGE_GLOBAL)
143                 set_pte_at(mm, addr, ptep, __pte(_PAGE_GLOBAL));
144         else
145 #endif
146                 set_pte_at(mm, addr, ptep, __pte(0));
147 }
148 #endif
149
150 /*
151  * (pmds are folded into puds so this doesn't get actually called,
152  * but the define is needed for a generic inline function.)
153  */
154 #define set_pmd(pmdptr, pmdval) do { *(pmdptr) = (pmdval); } while(0)
155
156 #ifdef CONFIG_64BIT
157 /*
158  * (puds are folded into pgds so this doesn't get actually called,
159  * but the define is needed for a generic inline function.)
160  */
161 #define set_pud(pudptr, pudval) do { *(pudptr) = (pudval); } while(0)
162 #endif
163
164 #define PGD_T_LOG2      ffz(~sizeof(pgd_t))
165 #define PMD_T_LOG2      ffz(~sizeof(pmd_t))
166 #define PTE_T_LOG2      ffz(~sizeof(pte_t))
167
168 extern pgd_t swapper_pg_dir[PTRS_PER_PGD];
169
170 /*
171  * The following only work if pte_present() is true.
172  * Undefined behaviour if not..
173  */
174 static inline int pte_user(pte_t pte)   { BUG(); return 0; }
175 #if defined(CONFIG_64BIT_PHYS_ADDR) && defined(CONFIG_CPU_MIPS32_R1)
176 static inline int pte_read(pte_t pte)   { return (pte).pte_low & _PAGE_READ; }
177 static inline int pte_write(pte_t pte)  { return (pte).pte_low & _PAGE_WRITE; }
178 static inline int pte_dirty(pte_t pte)  { return (pte).pte_low & _PAGE_MODIFIED; }
179 static inline int pte_young(pte_t pte)  { return (pte).pte_low & _PAGE_ACCESSED; }
180 static inline int pte_file(pte_t pte)   { return (pte).pte_low & _PAGE_FILE; }
181 static inline pte_t pte_wrprotect(pte_t pte)
182 {
183         (pte).pte_low &= ~(_PAGE_WRITE | _PAGE_SILENT_WRITE);
184         (pte).pte_high &= ~_PAGE_SILENT_WRITE;
185         return pte;
186 }
187
188 static inline pte_t pte_rdprotect(pte_t pte)
189 {
190         (pte).pte_low &= ~(_PAGE_READ | _PAGE_SILENT_READ);
191         (pte).pte_high &= ~_PAGE_SILENT_READ;
192         return pte;
193 }
194
195 static inline pte_t pte_mkclean(pte_t pte)
196 {
197         (pte).pte_low &= ~(_PAGE_MODIFIED|_PAGE_SILENT_WRITE);
198         (pte).pte_high &= ~_PAGE_SILENT_WRITE;
199         return pte;
200 }
201
202 static inline pte_t pte_mkold(pte_t pte)
203 {
204         (pte).pte_low &= ~(_PAGE_ACCESSED|_PAGE_SILENT_READ);
205         (pte).pte_high &= ~_PAGE_SILENT_READ;
206         return pte;
207 }
208
209 static inline pte_t pte_mkwrite(pte_t pte)
210 {
211         (pte).pte_low |= _PAGE_WRITE;
212         if ((pte).pte_low & _PAGE_MODIFIED) {
213                 (pte).pte_low |= _PAGE_SILENT_WRITE;
214                 (pte).pte_high |= _PAGE_SILENT_WRITE;
215         }
216         return pte;
217 }
218
219 static inline pte_t pte_mkread(pte_t pte)
220 {
221         (pte).pte_low |= _PAGE_READ;
222         if ((pte).pte_low & _PAGE_ACCESSED) {
223                 (pte).pte_low |= _PAGE_SILENT_READ;
224                 (pte).pte_high |= _PAGE_SILENT_READ;
225         }
226         return pte;
227 }
228
229 static inline pte_t pte_mkdirty(pte_t pte)
230 {
231         (pte).pte_low |= _PAGE_MODIFIED;
232         if ((pte).pte_low & _PAGE_WRITE) {
233                 (pte).pte_low |= _PAGE_SILENT_WRITE;
234                 (pte).pte_high |= _PAGE_SILENT_WRITE;
235         }
236         return pte;
237 }
238
239 static inline pte_t pte_mkyoung(pte_t pte)
240 {
241         (pte).pte_low |= _PAGE_ACCESSED;
242         if ((pte).pte_low & _PAGE_READ)
243                 (pte).pte_low |= _PAGE_SILENT_READ;
244                 (pte).pte_high |= _PAGE_SILENT_READ;
245         return pte;
246 }
247 #else
248 static inline int pte_read(pte_t pte)   { return pte_val(pte) & _PAGE_READ; }
249 static inline int pte_write(pte_t pte)  { return pte_val(pte) & _PAGE_WRITE; }
250 static inline int pte_dirty(pte_t pte)  { return pte_val(pte) & _PAGE_MODIFIED; }
251 static inline int pte_young(pte_t pte)  { return pte_val(pte) & _PAGE_ACCESSED; }
252 static inline int pte_file(pte_t pte)   { return pte_val(pte) & _PAGE_FILE; }
253
254 static inline pte_t pte_wrprotect(pte_t pte)
255 {
256         pte_val(pte) &= ~(_PAGE_WRITE | _PAGE_SILENT_WRITE);
257         return pte;
258 }
259
260 static inline pte_t pte_rdprotect(pte_t pte)
261 {
262         pte_val(pte) &= ~(_PAGE_READ | _PAGE_SILENT_READ);
263         return pte;
264 }
265
266 static inline pte_t pte_mkclean(pte_t pte)
267 {
268         pte_val(pte) &= ~(_PAGE_MODIFIED|_PAGE_SILENT_WRITE);
269         return pte;
270 }
271
272 static inline pte_t pte_mkold(pte_t pte)
273 {
274         pte_val(pte) &= ~(_PAGE_ACCESSED|_PAGE_SILENT_READ);
275         return pte;
276 }
277
278 static inline pte_t pte_mkwrite(pte_t pte)
279 {
280         pte_val(pte) |= _PAGE_WRITE;
281         if (pte_val(pte) & _PAGE_MODIFIED)
282                 pte_val(pte) |= _PAGE_SILENT_WRITE;
283         return pte;
284 }
285
286 static inline pte_t pte_mkread(pte_t pte)
287 {
288         pte_val(pte) |= _PAGE_READ;
289         if (pte_val(pte) & _PAGE_ACCESSED)
290                 pte_val(pte) |= _PAGE_SILENT_READ;
291         return pte;
292 }
293
294 static inline pte_t pte_mkdirty(pte_t pte)
295 {
296         pte_val(pte) |= _PAGE_MODIFIED;
297         if (pte_val(pte) & _PAGE_WRITE)
298                 pte_val(pte) |= _PAGE_SILENT_WRITE;
299         return pte;
300 }
301
302 static inline pte_t pte_mkyoung(pte_t pte)
303 {
304         pte_val(pte) |= _PAGE_ACCESSED;
305         if (pte_val(pte) & _PAGE_READ)
306                 pte_val(pte) |= _PAGE_SILENT_READ;
307         return pte;
308 }
309 #endif
310
311 /*
312  * Macro to make mark a page protection value as "uncacheable".  Note
313  * that "protection" is really a misnomer here as the protection value
314  * contains the memory attribute bits, dirty bits, and various other
315  * bits as well.
316  */
317 #define pgprot_noncached pgprot_noncached
318
319 static inline pgprot_t pgprot_noncached(pgprot_t _prot)
320 {
321         unsigned long prot = pgprot_val(_prot);
322
323         prot = (prot & ~_CACHE_MASK) | _CACHE_UNCACHED;
324
325         return __pgprot(prot);
326 }
327
328 /*
329  * Conversion functions: convert a page and protection to a page entry,
330  * and a page entry and page directory to the page they refer to.
331  */
332 #define mk_pte(page, pgprot)    pfn_pte(page_to_pfn(page), (pgprot))
333
334 #if defined(CONFIG_64BIT_PHYS_ADDR) && defined(CONFIG_CPU_MIPS32_R1)
335 static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
336 {
337         pte.pte_low &= _PAGE_CHG_MASK;
338         pte.pte_low |= pgprot_val(newprot);
339         pte.pte_high |= pgprot_val(newprot) & 0x3f;
340         return pte;
341 }
342 #else
343 static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
344 {
345         return __pte((pte_val(pte) & _PAGE_CHG_MASK) | pgprot_val(newprot));
346 }
347 #endif
348
349
350 extern void __update_tlb(struct vm_area_struct *vma, unsigned long address,
351         pte_t pte);
352 extern void __update_cache(struct vm_area_struct *vma, unsigned long address,
353         pte_t pte);
354
355 static inline void update_mmu_cache(struct vm_area_struct *vma,
356         unsigned long address, pte_t pte)
357 {
358         __update_tlb(vma, address, pte);
359         __update_cache(vma, address, pte);
360 }
361
362 #ifndef CONFIG_NEED_MULTIPLE_NODES
363 #define kern_addr_valid(addr)   (1)
364 #endif
365
366 #ifdef CONFIG_64BIT_PHYS_ADDR
367 extern int remap_pfn_range(struct vm_area_struct *vma, unsigned long from, unsigned long pfn, unsigned long size, pgprot_t prot);
368
369 static inline int io_remap_pfn_range(struct vm_area_struct *vma,
370                 unsigned long vaddr,
371                 unsigned long pfn,
372                 unsigned long size,
373                 pgprot_t prot)
374 {
375         phys_t phys_addr_high = fixup_bigphys_addr(pfn << PAGE_SHIFT, size);
376         return remap_pfn_range(vma, vaddr, phys_addr_high >> PAGE_SHIFT, size, prot);
377 }
378 #else
379 #define io_remap_pfn_range(vma, vaddr, pfn, size, prot)         \
380                 remap_pfn_range(vma, vaddr, pfn, size, prot)
381 #endif
382
383 #define MK_IOSPACE_PFN(space, pfn)      (pfn)
384 #define GET_IOSPACE(pfn)                0
385 #define GET_PFN(pfn)                    (pfn)
386
387 #include <asm-generic/pgtable.h>
388
389 /*
390  * We provide our own get_unmapped area to cope with the virtual aliasing
391  * constraints placed on us by the cache architecture.
392  */
393 #define HAVE_ARCH_UNMAPPED_AREA
394
395 /*
396  * No page table caches to initialise
397  */
398 #define pgtable_cache_init()    do { } while (0)
399
400 #endif /* _ASM_PGTABLE_H */