blob: 7e40f37781790206a1174830f295258d89ec648f [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Ralf Baechle875d43e2005-09-03 15:56:16 -070011#ifdef CONFIG_32BIT
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#include <asm/pgtable-32.h>
13#endif
Ralf Baechle875d43e2005-09-03 15:56:16 -070014#ifdef CONFIG_64BIT
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <asm/pgtable-64.h>
16#endif
17
Pete Popovf10fae02005-07-14 00:17:05 +000018#include <asm/io.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <asm/pgtable-bits.h>
20
Tim Schmielau8c65b4a2005-11-07 00:59:43 -080021struct mm_struct;
22struct vm_area_struct;
23
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#define PAGE_NONE __pgprot(_PAGE_PRESENT | _CACHE_CACHABLE_NONCOHERENT)
David Daney6dd93442010-02-10 15:12:47 -080025#define PAGE_SHARED __pgprot(_PAGE_PRESENT | _PAGE_WRITE | (kernel_uses_smartmips_rixi ? 0 : _PAGE_READ) | \
Chris Dearman35133692007-09-19 00:58:24 +010026 _page_cachable_default)
David Daney6dd93442010-02-10 15:12:47 -080027#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) | \
Chris Dearman35133692007-09-19 00:58:24 +010030 _page_cachable_default)
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#define PAGE_KERNEL __pgprot(_PAGE_PRESENT | __READABLE | __WRITEABLE | \
Chris Dearman35133692007-09-19 00:58:24 +010032 _PAGE_GLOBAL | _page_cachable_default)
David Daney6dd93442010-02-10 15:12:47 -080033#define PAGE_USERIO __pgprot(_PAGE_PRESENT | (kernel_uses_smartmips_rixi ? 0 : _PAGE_READ) | _PAGE_WRITE | \
Chris Dearman35133692007-09-19 00:58:24 +010034 _page_cachable_default)
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#define PAGE_KERNEL_UNCACHED __pgprot(_PAGE_PRESENT | __READABLE | \
36 __WRITEABLE | _PAGE_GLOBAL | _CACHE_UNCACHED)
37
38/*
David Daney6dd93442010-02-10 15:12:47 -080039 * 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..
Linus Torvalds1da177e2005-04-16 15:20:36 -070043 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
Chris Dearman35133692007-09-19 00:58:24 +010045/*
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
67extern unsigned long _page_cachable_default;
Linus Torvalds1da177e2005-04-16 15:20:36 -070068
69/*
70 * ZERO_PAGE is a global shared page that is always zero; used
71 * for zero-mapped memory areas etc..
72 */
73
74extern unsigned long empty_zero_page;
75extern unsigned long zero_page_mask;
76
77#define ZERO_PAGE(vaddr) \
Franck Bui-Huu99e3b942006-10-19 13:19:59 +020078 (virt_to_page((void *)(empty_zero_page + (((unsigned long)(vaddr)) & zero_page_mask))))
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
Hugh Dickins62eede62009-09-21 17:03:34 -070080#define is_zero_pfn is_zero_pfn
81static 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070090extern 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 */
Franck Bui-Huuc9d06962007-03-19 17:36:42 +010096#define pmd_phys(pmd) virt_to_phys((void *)pmd_val(pmd))
Linus Torvalds1da177e2005-04-16 15:20:36 -070097#define pmd_page(pmd) (pfn_to_page(pmd_phys(pmd) >> PAGE_SHIFT))
Dave McCracken46a82b22006-09-25 23:31:48 -070098#define pmd_page_vaddr(pmd) pmd_val(pmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -070099
Chris Dearman962f4802007-09-19 00:46:32 +0100100#if defined(CONFIG_64BIT_PHYS_ADDR) && defined(CONFIG_CPU_MIPS32)
Sergei Shtylyov6e953892006-04-16 23:27:21 +0400101
102#define pte_none(pte) (!(((pte).pte_low | (pte).pte_high) & ~_PAGE_GLOBAL))
103#define pte_present(pte) ((pte).pte_low & _PAGE_PRESENT)
104
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105static 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
Sergei Shtylyov6e953892006-04-16 23:27:21 +0400112 if (pte.pte_low & _PAGE_GLOBAL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 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 */
Sergei Shtylyov6e953892006-04-16 23:27:21 +0400118 if (pte_none(*buddy)) {
119 buddy->pte_low |= _PAGE_GLOBAL;
120 buddy->pte_high |= _PAGE_GLOBAL;
121 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 }
123}
Ralf Baechle21a151d2007-10-11 23:46:15 +0100124#define set_pte_at(mm, addr, ptep, pteval) set_pte(ptep, pteval)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125
126static inline void pte_clear(struct mm_struct *mm, unsigned long addr, pte_t *ptep)
127{
Sergei Shtylyov6e953892006-04-16 23:27:21 +0400128 pte_t null = __pte(0);
129
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 /* Preserve global status for the pair */
Sergei Shtylyov6e953892006-04-16 23:27:21 +0400131 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135}
136#else
Sergei Shtylyov6e953892006-04-16 23:27:21 +0400137
138#define pte_none(pte) (!(pte_val(pte) & ~_PAGE_GLOBAL))
139#define pte_present(pte) (pte_val(pte) & _PAGE_PRESENT)
140
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141/*
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 */
146static 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}
Ralf Baechle21a151d2007-10-11 23:46:15 +0100161#define set_pte_at(mm, addr, ptep, pteval) set_pte(ptep, pteval)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162
163static 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/*
Ralf Baechlec6e8b582005-02-10 12:19:59 +0000176 * (pmds are folded into puds so this doesn't get actually called,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 * but the define is needed for a generic inline function.)
178 */
179#define set_pmd(pmdptr, pmdval) do { *(pmdptr) = (pmdval); } while(0)
Ralf Baechlec6e8b582005-02-10 12:19:59 +0000180
David Daney325f8a02009-12-04 13:52:36 -0800181#ifndef __PAGETABLE_PMD_FOLDED
Ralf Baechlec6e8b582005-02-10 12:19:59 +0000182/*
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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188
Ralf Baechle5ff97472007-08-01 15:25:28 +0100189#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)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192
Ralf Baechle9975e772007-08-13 12:44:41 +0100193/*
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 */
197extern pgd_t swapper_pg_dir[];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198
199/*
200 * The following only work if pte_present() is true.
201 * Undefined behaviour if not..
202 */
Chris Dearman962f4802007-09-19 00:46:32 +0100203#if defined(CONFIG_64BIT_PHYS_ADDR) && defined(CONFIG_CPU_MIPS32)
Sergei Shtylyov6e953892006-04-16 23:27:21 +0400204static inline int pte_write(pte_t pte) { return pte.pte_low & _PAGE_WRITE; }
205static inline int pte_dirty(pte_t pte) { return pte.pte_low & _PAGE_MODIFIED; }
206static inline int pte_young(pte_t pte) { return pte.pte_low & _PAGE_ACCESSED; }
207static inline int pte_file(pte_t pte) { return pte.pte_low & _PAGE_FILE; }
208
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209static inline pte_t pte_wrprotect(pte_t pte)
210{
Sergei Shtylyov6e953892006-04-16 23:27:21 +0400211 pte.pte_low &= ~(_PAGE_WRITE | _PAGE_SILENT_WRITE);
212 pte.pte_high &= ~_PAGE_SILENT_WRITE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 return pte;
214}
215
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216static inline pte_t pte_mkclean(pte_t pte)
217{
Sergei Shtylyov6e953892006-04-16 23:27:21 +0400218 pte.pte_low &= ~(_PAGE_MODIFIED | _PAGE_SILENT_WRITE);
219 pte.pte_high &= ~_PAGE_SILENT_WRITE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 return pte;
221}
222
223static inline pte_t pte_mkold(pte_t pte)
224{
Sergei Shtylyov6e953892006-04-16 23:27:21 +0400225 pte.pte_low &= ~(_PAGE_ACCESSED | _PAGE_SILENT_READ);
226 pte.pte_high &= ~_PAGE_SILENT_READ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 return pte;
228}
229
230static inline pte_t pte_mkwrite(pte_t pte)
231{
Sergei Shtylyov6e953892006-04-16 23:27:21 +0400232 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 }
237 return pte;
238}
239
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240static inline pte_t pte_mkdirty(pte_t pte)
241{
Sergei Shtylyov6e953892006-04-16 23:27:21 +0400242 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 }
247 return pte;
248}
249
250static inline pte_t pte_mkyoung(pte_t pte)
251{
Sergei Shtylyov6e953892006-04-16 23:27:21 +0400252 pte.pte_low |= _PAGE_ACCESSED;
Ilpo Järvinen057229f2008-05-02 14:08:20 +0300253 if (pte.pte_low & _PAGE_READ) {
Sergei Shtylyov6e953892006-04-16 23:27:21 +0400254 pte.pte_low |= _PAGE_SILENT_READ;
255 pte.pte_high |= _PAGE_SILENT_READ;
Ilpo Järvinen057229f2008-05-02 14:08:20 +0300256 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 return pte;
258}
259#else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260static inline int pte_write(pte_t pte) { return pte_val(pte) & _PAGE_WRITE; }
261static inline int pte_dirty(pte_t pte) { return pte_val(pte) & _PAGE_MODIFIED; }
262static inline int pte_young(pte_t pte) { return pte_val(pte) & _PAGE_ACCESSED; }
263static inline int pte_file(pte_t pte) { return pte_val(pte) & _PAGE_FILE; }
264
265static inline pte_t pte_wrprotect(pte_t pte)
266{
267 pte_val(pte) &= ~(_PAGE_WRITE | _PAGE_SILENT_WRITE);
268 return pte;
269}
270
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271static inline pte_t pte_mkclean(pte_t pte)
272{
273 pte_val(pte) &= ~(_PAGE_MODIFIED|_PAGE_SILENT_WRITE);
274 return pte;
275}
276
277static inline pte_t pte_mkold(pte_t pte)
278{
279 pte_val(pte) &= ~(_PAGE_ACCESSED|_PAGE_SILENT_READ);
280 return pte;
281}
282
283static 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291static 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
299static inline pte_t pte_mkyoung(pte_t pte)
300{
301 pte_val(pte) |= _PAGE_ACCESSED;
David Daney6dd93442010-02-10 15:12:47 -0800302 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 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 return pte;
310}
David Daneydd794392009-05-27 17:47:43 -0700311
312#ifdef _PAGE_HUGE
313static inline int pte_huge(pte_t pte) { return pte_val(pte) & _PAGE_HUGE; }
314
315static inline pte_t pte_mkhuge(pte_t pte)
316{
317 pte_val(pte) |= _PAGE_HUGE;
318 return pte;
319}
320#endif /* _PAGE_HUGE */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321#endif
Nick Piggin7e675132008-04-28 02:13:00 -0700322static inline int pte_special(pte_t pte) { return 0; }
323static inline pte_t pte_mkspecial(pte_t pte) { return pte; }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324
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
333static 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
Chris Dearman962f4802007-09-19 00:46:32 +0100348#if defined(CONFIG_64BIT_PHYS_ADDR) && defined(CONFIG_CPU_MIPS32)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
350{
Sergei Shtylyov79e0bc32006-05-03 22:56:43 +0400351 pte.pte_low &= _PAGE_CHG_MASK;
352 pte.pte_high &= ~0x3f;
353 pte.pte_low |= pgprot_val(newprot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 pte.pte_high |= pgprot_val(newprot) & 0x3f;
355 return pte;
356}
357#else
358static 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
365extern void __update_tlb(struct vm_area_struct *vma, unsigned long address,
366 pte_t pte);
367extern void __update_cache(struct vm_area_struct *vma, unsigned long address,
368 pte_t pte);
369
370static inline void update_mmu_cache(struct vm_area_struct *vma,
Russell King4b3073e2009-12-18 16:40:18 +0000371 unsigned long address, pte_t *ptep)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372{
Russell King4b3073e2009-12-18 16:40:18 +0000373 pte_t pte = *ptep;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 __update_tlb(vma, address, pte);
375 __update_cache(vma, address, pte);
376}
377
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378#define kern_addr_valid(addr) (1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379
380#ifdef CONFIG_64BIT_PHYS_ADDR
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381extern int remap_pfn_range(struct vm_area_struct *vma, unsigned long from, unsigned long pfn, unsigned long size, pgprot_t prot);
382
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383static 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);
Thiemo Seuferac5d8c02005-04-11 12:24:16 +0000390 return remap_pfn_range(vma, vaddr, phys_addr_high >> PAGE_SHIFT, size, prot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391}
392#else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393#define io_remap_pfn_range(vma, vaddr, pfn, size, prot) \
394 remap_pfn_range(vma, vaddr, pfn, size, prot)
395#endif
396
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397#include <asm-generic/pgtable.h>
398
399/*
Wu Zhangjin22f1fdf2009-11-11 13:59:23 +0800400 * uncached accelerated TLB map for video memory access
401 */
402#ifdef CONFIG_CPU_SUPPORTS_UNCACHED_ACCELERATED
403#define __HAVE_PHYS_MEM_ACCESS_PROT
404
405struct file;
406pgprot_t phys_mem_access_prot(struct file *file, unsigned long pfn,
407 unsigned long size, pgprot_t vma_prot);
408int phys_mem_access_prot_allowed(struct file *file, unsigned long pfn,
409 unsigned long size, pgprot_t *vma_prot);
410#endif
411
412/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 * 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 */