Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/sage/ceph...
[linux-2.6.git] / arch / mips / include / asm / 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_WRITE | (kernel_uses_smartmips_rixi ? 0 : _PAGE_READ) | \
26                                  _page_cachable_default)
27 #define PAGE_COPY       __pgprot(_PAGE_PRESENT | (kernel_uses_smartmips_rixi ? 0 : _PAGE_READ) | \
28                                  (kernel_uses_smartmips_rixi ?  _PAGE_NO_EXEC : 0) | _page_cachable_default)
29 #define PAGE_READONLY   __pgprot(_PAGE_PRESENT | (kernel_uses_smartmips_rixi ? 0 : _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 | (kernel_uses_smartmips_rixi ? 0 : _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  * If _PAGE_NO_EXEC is not defined, we can't do page protection for
40  * execute, and consider it to be the same as read. Also, write
41  * permissions imply read permissions. This is the closest we can get
42  * by reasonable means..
43  */
44
45 /*
46  * Dummy values to fill the table in mmap.c
47  * The real values will be generated at runtime
48  */
49 #define __P000 __pgprot(0)
50 #define __P001 __pgprot(0)
51 #define __P010 __pgprot(0)
52 #define __P011 __pgprot(0)
53 #define __P100 __pgprot(0)
54 #define __P101 __pgprot(0)
55 #define __P110 __pgprot(0)
56 #define __P111 __pgprot(0)
57
58 #define __S000 __pgprot(0)
59 #define __S001 __pgprot(0)
60 #define __S010 __pgprot(0)
61 #define __S011 __pgprot(0)
62 #define __S100 __pgprot(0)
63 #define __S101 __pgprot(0)
64 #define __S110 __pgprot(0)
65 #define __S111 __pgprot(0)
66
67 extern unsigned long _page_cachable_default;
68
69 /*
70  * ZERO_PAGE is a global shared page that is always zero; used
71  * for zero-mapped memory areas etc..
72  */
73
74 extern unsigned long empty_zero_page;
75 extern unsigned long zero_page_mask;
76
77 #define ZERO_PAGE(vaddr) \
78         (virt_to_page((void *)(empty_zero_page + (((unsigned long)(vaddr)) & zero_page_mask))))
79
80 #define is_zero_pfn is_zero_pfn
81 static inline int is_zero_pfn(unsigned long pfn)
82 {
83         extern unsigned long zero_pfn;
84         unsigned long offset_from_zero_pfn = pfn - zero_pfn;
85         return offset_from_zero_pfn <= (zero_page_mask >> PAGE_SHIFT);
86 }
87
88 #define my_zero_pfn(addr)       page_to_pfn(ZERO_PAGE(addr))
89
90 extern void paging_init(void);
91
92 /*
93  * Conversion functions: convert a page and protection to a page entry,
94  * and a page entry and page directory to the page they refer to.
95  */
96 #define pmd_phys(pmd)           virt_to_phys((void *)pmd_val(pmd))
97 #define pmd_page(pmd)           (pfn_to_page(pmd_phys(pmd) >> PAGE_SHIFT))
98 #define pmd_page_vaddr(pmd)     pmd_val(pmd)
99
100 #if defined(CONFIG_64BIT_PHYS_ADDR) && defined(CONFIG_CPU_MIPS32)
101
102 #define pte_none(pte)           (!(((pte).pte_low | (pte).pte_high) & ~_PAGE_GLOBAL))
103 #define pte_present(pte)        ((pte).pte_low & _PAGE_PRESENT)
104
105 static inline void set_pte(pte_t *ptep, pte_t pte)
106 {
107         ptep->pte_high = pte.pte_high;
108         smp_wmb();
109         ptep->pte_low = pte.pte_low;
110         //printk("pte_high %x pte_low %x\n", ptep->pte_high, ptep->pte_low);
111
112         if (pte.pte_low & _PAGE_GLOBAL) {
113                 pte_t *buddy = ptep_buddy(ptep);
114                 /*
115                  * Make sure the buddy is global too (if it's !none,
116                  * it better already be global)
117                  */
118                 if (pte_none(*buddy)) {
119                         buddy->pte_low  |= _PAGE_GLOBAL;
120                         buddy->pte_high |= _PAGE_GLOBAL;
121                 }
122         }
123 }
124 #define set_pte_at(mm, addr, ptep, pteval) set_pte(ptep, pteval)
125
126 static inline void pte_clear(struct mm_struct *mm, unsigned long addr, pte_t *ptep)
127 {
128         pte_t null = __pte(0);
129
130         /* Preserve global status for the pair */
131         if (ptep_buddy(ptep)->pte_low & _PAGE_GLOBAL)
132                 null.pte_low = null.pte_high = _PAGE_GLOBAL;
133
134         set_pte_at(mm, addr, ptep, null);
135 }
136 #else
137
138 #define pte_none(pte)           (!(pte_val(pte) & ~_PAGE_GLOBAL))
139 #define pte_present(pte)        (pte_val(pte) & _PAGE_PRESENT)
140
141 /*
142  * Certain architectures need to do special things when pte's
143  * within a page table are directly modified.  Thus, the following
144  * hook is made available.
145  */
146 static inline void set_pte(pte_t *ptep, pte_t pteval)
147 {
148         *ptep = pteval;
149 #if !defined(CONFIG_CPU_R3000) && !defined(CONFIG_CPU_TX39XX)
150         if (pte_val(pteval) & _PAGE_GLOBAL) {
151                 pte_t *buddy = ptep_buddy(ptep);
152                 /*
153                  * Make sure the buddy is global too (if it's !none,
154                  * it better already be global)
155                  */
156                 if (pte_none(*buddy))
157                         pte_val(*buddy) = pte_val(*buddy) | _PAGE_GLOBAL;
158         }
159 #endif
160 }
161 #define set_pte_at(mm, addr, ptep, pteval) set_pte(ptep, pteval)
162
163 static inline void pte_clear(struct mm_struct *mm, unsigned long addr, pte_t *ptep)
164 {
165 #if !defined(CONFIG_CPU_R3000) && !defined(CONFIG_CPU_TX39XX)
166         /* Preserve global status for the pair */
167         if (pte_val(*ptep_buddy(ptep)) & _PAGE_GLOBAL)
168                 set_pte_at(mm, addr, ptep, __pte(_PAGE_GLOBAL));
169         else
170 #endif
171                 set_pte_at(mm, addr, ptep, __pte(0));
172 }
173 #endif
174
175 /*
176  * (pmds are folded into puds so this doesn't get actually called,
177  * but the define is needed for a generic inline function.)
178  */
179 #define set_pmd(pmdptr, pmdval) do { *(pmdptr) = (pmdval); } while(0)
180
181 #ifndef __PAGETABLE_PMD_FOLDED
182 /*
183  * (puds are folded into pgds so this doesn't get actually called,
184  * but the define is needed for a generic inline function.)
185  */
186 #define set_pud(pudptr, pudval) do { *(pudptr) = (pudval); } while(0)
187 #endif
188
189 #define PGD_T_LOG2      (__builtin_ffs(sizeof(pgd_t)) - 1)
190 #define PMD_T_LOG2      (__builtin_ffs(sizeof(pmd_t)) - 1)
191 #define PTE_T_LOG2      (__builtin_ffs(sizeof(pte_t)) - 1)
192
193 /*
194  * We used to declare this array with size but gcc 3.3 and older are not able
195  * to find that this expression is a constant, so the size is dropped.
196  */
197 extern pgd_t swapper_pg_dir[];
198
199 /*
200  * The following only work if pte_present() is true.
201  * Undefined behaviour if not..
202  */
203 #if defined(CONFIG_64BIT_PHYS_ADDR) && defined(CONFIG_CPU_MIPS32)
204 static inline int pte_write(pte_t pte)  { return pte.pte_low & _PAGE_WRITE; }
205 static inline int pte_dirty(pte_t pte)  { return pte.pte_low & _PAGE_MODIFIED; }
206 static inline int pte_young(pte_t pte)  { return pte.pte_low & _PAGE_ACCESSED; }
207 static inline int pte_file(pte_t pte)   { return pte.pte_low & _PAGE_FILE; }
208
209 static inline pte_t pte_wrprotect(pte_t pte)
210 {
211         pte.pte_low  &= ~(_PAGE_WRITE | _PAGE_SILENT_WRITE);
212         pte.pte_high &= ~_PAGE_SILENT_WRITE;
213         return pte;
214 }
215
216 static inline pte_t pte_mkclean(pte_t pte)
217 {
218         pte.pte_low  &= ~(_PAGE_MODIFIED | _PAGE_SILENT_WRITE);
219         pte.pte_high &= ~_PAGE_SILENT_WRITE;
220         return pte;
221 }
222
223 static inline pte_t pte_mkold(pte_t pte)
224 {
225         pte.pte_low  &= ~(_PAGE_ACCESSED | _PAGE_SILENT_READ);
226         pte.pte_high &= ~_PAGE_SILENT_READ;
227         return pte;
228 }
229
230 static inline pte_t pte_mkwrite(pte_t pte)
231 {
232         pte.pte_low |= _PAGE_WRITE;
233         if (pte.pte_low & _PAGE_MODIFIED) {
234                 pte.pte_low  |= _PAGE_SILENT_WRITE;
235                 pte.pte_high |= _PAGE_SILENT_WRITE;
236         }
237         return pte;
238 }
239
240 static inline pte_t pte_mkdirty(pte_t pte)
241 {
242         pte.pte_low |= _PAGE_MODIFIED;
243         if (pte.pte_low & _PAGE_WRITE) {
244                 pte.pte_low  |= _PAGE_SILENT_WRITE;
245                 pte.pte_high |= _PAGE_SILENT_WRITE;
246         }
247         return pte;
248 }
249
250 static inline pte_t pte_mkyoung(pte_t pte)
251 {
252         pte.pte_low |= _PAGE_ACCESSED;
253         if (pte.pte_low & _PAGE_READ) {
254                 pte.pte_low  |= _PAGE_SILENT_READ;
255                 pte.pte_high |= _PAGE_SILENT_READ;
256         }
257         return pte;
258 }
259 #else
260 static inline int pte_write(pte_t pte)  { return pte_val(pte) & _PAGE_WRITE; }
261 static inline int pte_dirty(pte_t pte)  { return pte_val(pte) & _PAGE_MODIFIED; }
262 static inline int pte_young(pte_t pte)  { return pte_val(pte) & _PAGE_ACCESSED; }
263 static inline int pte_file(pte_t pte)   { return pte_val(pte) & _PAGE_FILE; }
264
265 static inline pte_t pte_wrprotect(pte_t pte)
266 {
267         pte_val(pte) &= ~(_PAGE_WRITE | _PAGE_SILENT_WRITE);
268         return pte;
269 }
270
271 static inline pte_t pte_mkclean(pte_t pte)
272 {
273         pte_val(pte) &= ~(_PAGE_MODIFIED|_PAGE_SILENT_WRITE);
274         return pte;
275 }
276
277 static inline pte_t pte_mkold(pte_t pte)
278 {
279         pte_val(pte) &= ~(_PAGE_ACCESSED|_PAGE_SILENT_READ);
280         return pte;
281 }
282
283 static inline pte_t pte_mkwrite(pte_t pte)
284 {
285         pte_val(pte) |= _PAGE_WRITE;
286         if (pte_val(pte) & _PAGE_MODIFIED)
287                 pte_val(pte) |= _PAGE_SILENT_WRITE;
288         return pte;
289 }
290
291 static inline pte_t pte_mkdirty(pte_t pte)
292 {
293         pte_val(pte) |= _PAGE_MODIFIED;
294         if (pte_val(pte) & _PAGE_WRITE)
295                 pte_val(pte) |= _PAGE_SILENT_WRITE;
296         return pte;
297 }
298
299 static inline pte_t pte_mkyoung(pte_t pte)
300 {
301         pte_val(pte) |= _PAGE_ACCESSED;
302         if (kernel_uses_smartmips_rixi) {
303                 if (!(pte_val(pte) & _PAGE_NO_READ))
304                         pte_val(pte) |= _PAGE_SILENT_READ;
305         } else {
306                 if (pte_val(pte) & _PAGE_READ)
307                         pte_val(pte) |= _PAGE_SILENT_READ;
308         }
309         return pte;
310 }
311
312 #ifdef _PAGE_HUGE
313 static inline int pte_huge(pte_t pte)   { return pte_val(pte) & _PAGE_HUGE; }
314
315 static inline pte_t pte_mkhuge(pte_t pte)
316 {
317         pte_val(pte) |= _PAGE_HUGE;
318         return pte;
319 }
320 #endif /* _PAGE_HUGE */
321 #endif
322 static inline int pte_special(pte_t pte)        { return 0; }
323 static inline pte_t pte_mkspecial(pte_t pte)    { return pte; }
324
325 /*
326  * Macro to make mark a page protection value as "uncacheable".  Note
327  * that "protection" is really a misnomer here as the protection value
328  * contains the memory attribute bits, dirty bits, and various other
329  * bits as well.
330  */
331 #define pgprot_noncached pgprot_noncached
332
333 static inline pgprot_t pgprot_noncached(pgprot_t _prot)
334 {
335         unsigned long prot = pgprot_val(_prot);
336
337         prot = (prot & ~_CACHE_MASK) | _CACHE_UNCACHED;
338
339         return __pgprot(prot);
340 }
341
342 /*
343  * Conversion functions: convert a page and protection to a page entry,
344  * and a page entry and page directory to the page they refer to.
345  */
346 #define mk_pte(page, pgprot)    pfn_pte(page_to_pfn(page), (pgprot))
347
348 #if defined(CONFIG_64BIT_PHYS_ADDR) && defined(CONFIG_CPU_MIPS32)
349 static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
350 {
351         pte.pte_low  &= _PAGE_CHG_MASK;
352         pte.pte_high &= ~0x3f;
353         pte.pte_low  |= pgprot_val(newprot);
354         pte.pte_high |= pgprot_val(newprot) & 0x3f;
355         return pte;
356 }
357 #else
358 static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
359 {
360         return __pte((pte_val(pte) & _PAGE_CHG_MASK) | pgprot_val(newprot));
361 }
362 #endif
363
364
365 extern void __update_tlb(struct vm_area_struct *vma, unsigned long address,
366         pte_t pte);
367 extern void __update_cache(struct vm_area_struct *vma, unsigned long address,
368         pte_t pte);
369
370 static inline void update_mmu_cache(struct vm_area_struct *vma,
371         unsigned long address, pte_t *ptep)
372 {
373         pte_t pte = *ptep;
374         __update_tlb(vma, address, pte);
375         __update_cache(vma, address, pte);
376 }
377
378 #define kern_addr_valid(addr)   (1)
379
380 #ifdef CONFIG_64BIT_PHYS_ADDR
381 extern int remap_pfn_range(struct vm_area_struct *vma, unsigned long from, unsigned long pfn, unsigned long size, pgprot_t prot);
382
383 static inline int io_remap_pfn_range(struct vm_area_struct *vma,
384                 unsigned long vaddr,
385                 unsigned long pfn,
386                 unsigned long size,
387                 pgprot_t prot)
388 {
389         phys_t phys_addr_high = fixup_bigphys_addr(pfn << PAGE_SHIFT, size);
390         return remap_pfn_range(vma, vaddr, phys_addr_high >> PAGE_SHIFT, size, prot);
391 }
392 #else
393 #define io_remap_pfn_range(vma, vaddr, pfn, size, prot)         \
394                 remap_pfn_range(vma, vaddr, pfn, size, prot)
395 #endif
396
397 #include <asm-generic/pgtable.h>
398
399 /*
400  * uncached accelerated TLB map for video memory access
401  */
402 #ifdef CONFIG_CPU_SUPPORTS_UNCACHED_ACCELERATED
403 #define __HAVE_PHYS_MEM_ACCESS_PROT
404
405 struct file;
406 pgprot_t phys_mem_access_prot(struct file *file, unsigned long pfn,
407                 unsigned long size, pgprot_t vma_prot);
408 int phys_mem_access_prot_allowed(struct file *file, unsigned long pfn,
409                 unsigned long size, pgprot_t *vma_prot);
410 #endif
411
412 /*
413  * We provide our own get_unmapped area to cope with the virtual aliasing
414  * constraints placed on us by the cache architecture.
415  */
416 #define HAVE_ARCH_UNMAPPED_AREA
417
418 /*
419  * No page table caches to initialise
420  */
421 #define pgtable_cache_init()    do { } while (0)
422
423 #endif /* _ASM_PGTABLE_H */