Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Ralf Baechle | 875d43e | 2005-09-03 15:56:16 -0700 | [diff] [blame] | 11 | #ifdef CONFIG_32BIT |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 12 | #include <asm/pgtable-32.h> |
| 13 | #endif |
Ralf Baechle | 875d43e | 2005-09-03 15:56:16 -0700 | [diff] [blame] | 14 | #ifdef CONFIG_64BIT |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 15 | #include <asm/pgtable-64.h> |
| 16 | #endif |
| 17 | |
Pete Popov | f10fae0 | 2005-07-14 00:17:05 +0000 | [diff] [blame] | 18 | #include <asm/io.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 19 | #include <asm/pgtable-bits.h> |
| 20 | |
Tim Schmielau | 8c65b4a | 2005-11-07 00:59:43 -0800 | [diff] [blame] | 21 | struct mm_struct; |
| 22 | struct vm_area_struct; |
| 23 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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) \ |
Franck Bui-Huu | 99e3b94 | 2006-10-19 13:19:59 +0200 | [diff] [blame] | 70 | (virt_to_page((void *)(empty_zero_page + (((unsigned long)(vaddr)) & zero_page_mask)))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 71 | |
| 72 | extern void paging_init(void); |
| 73 | |
| 74 | /* |
| 75 | * Conversion functions: convert a page and protection to a page entry, |
| 76 | * and a page entry and page directory to the page they refer to. |
| 77 | */ |
Franck Bui-Huu | c9d0696 | 2007-03-19 17:36:42 +0100 | [diff] [blame^] | 78 | #define pmd_phys(pmd) virt_to_phys((void *)pmd_val(pmd)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 79 | #define pmd_page(pmd) (pfn_to_page(pmd_phys(pmd) >> PAGE_SHIFT)) |
Dave McCracken | 46a82b2 | 2006-09-25 23:31:48 -0700 | [diff] [blame] | 80 | #define pmd_page_vaddr(pmd) pmd_val(pmd) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 81 | |
Ralf Baechle | 6e760c8 | 2005-07-06 12:08:11 +0000 | [diff] [blame] | 82 | #if defined(CONFIG_64BIT_PHYS_ADDR) && defined(CONFIG_CPU_MIPS32_R1) |
Sergei Shtylyov | 6e95389 | 2006-04-16 23:27:21 +0400 | [diff] [blame] | 83 | |
| 84 | #define pte_none(pte) (!(((pte).pte_low | (pte).pte_high) & ~_PAGE_GLOBAL)) |
| 85 | #define pte_present(pte) ((pte).pte_low & _PAGE_PRESENT) |
| 86 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 87 | static inline void set_pte(pte_t *ptep, pte_t pte) |
| 88 | { |
| 89 | ptep->pte_high = pte.pte_high; |
| 90 | smp_wmb(); |
| 91 | ptep->pte_low = pte.pte_low; |
| 92 | //printk("pte_high %x pte_low %x\n", ptep->pte_high, ptep->pte_low); |
| 93 | |
Sergei Shtylyov | 6e95389 | 2006-04-16 23:27:21 +0400 | [diff] [blame] | 94 | if (pte.pte_low & _PAGE_GLOBAL) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 95 | pte_t *buddy = ptep_buddy(ptep); |
| 96 | /* |
| 97 | * Make sure the buddy is global too (if it's !none, |
| 98 | * it better already be global) |
| 99 | */ |
Sergei Shtylyov | 6e95389 | 2006-04-16 23:27:21 +0400 | [diff] [blame] | 100 | if (pte_none(*buddy)) { |
| 101 | buddy->pte_low |= _PAGE_GLOBAL; |
| 102 | buddy->pte_high |= _PAGE_GLOBAL; |
| 103 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 104 | } |
| 105 | } |
| 106 | #define set_pte_at(mm,addr,ptep,pteval) set_pte(ptep,pteval) |
| 107 | |
| 108 | static inline void pte_clear(struct mm_struct *mm, unsigned long addr, pte_t *ptep) |
| 109 | { |
Sergei Shtylyov | 6e95389 | 2006-04-16 23:27:21 +0400 | [diff] [blame] | 110 | pte_t null = __pte(0); |
| 111 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 112 | /* Preserve global status for the pair */ |
Sergei Shtylyov | 6e95389 | 2006-04-16 23:27:21 +0400 | [diff] [blame] | 113 | if (ptep_buddy(ptep)->pte_low & _PAGE_GLOBAL) |
| 114 | null.pte_low = null.pte_high = _PAGE_GLOBAL; |
| 115 | |
| 116 | set_pte_at(mm, addr, ptep, null); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 117 | } |
| 118 | #else |
Sergei Shtylyov | 6e95389 | 2006-04-16 23:27:21 +0400 | [diff] [blame] | 119 | |
| 120 | #define pte_none(pte) (!(pte_val(pte) & ~_PAGE_GLOBAL)) |
| 121 | #define pte_present(pte) (pte_val(pte) & _PAGE_PRESENT) |
| 122 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 123 | /* |
| 124 | * Certain architectures need to do special things when pte's |
| 125 | * within a page table are directly modified. Thus, the following |
| 126 | * hook is made available. |
| 127 | */ |
| 128 | static inline void set_pte(pte_t *ptep, pte_t pteval) |
| 129 | { |
| 130 | *ptep = pteval; |
| 131 | #if !defined(CONFIG_CPU_R3000) && !defined(CONFIG_CPU_TX39XX) |
| 132 | if (pte_val(pteval) & _PAGE_GLOBAL) { |
| 133 | pte_t *buddy = ptep_buddy(ptep); |
| 134 | /* |
| 135 | * Make sure the buddy is global too (if it's !none, |
| 136 | * it better already be global) |
| 137 | */ |
| 138 | if (pte_none(*buddy)) |
| 139 | pte_val(*buddy) = pte_val(*buddy) | _PAGE_GLOBAL; |
| 140 | } |
| 141 | #endif |
| 142 | } |
| 143 | #define set_pte_at(mm,addr,ptep,pteval) set_pte(ptep,pteval) |
| 144 | |
| 145 | static inline void pte_clear(struct mm_struct *mm, unsigned long addr, pte_t *ptep) |
| 146 | { |
| 147 | #if !defined(CONFIG_CPU_R3000) && !defined(CONFIG_CPU_TX39XX) |
| 148 | /* Preserve global status for the pair */ |
| 149 | if (pte_val(*ptep_buddy(ptep)) & _PAGE_GLOBAL) |
| 150 | set_pte_at(mm, addr, ptep, __pte(_PAGE_GLOBAL)); |
| 151 | else |
| 152 | #endif |
| 153 | set_pte_at(mm, addr, ptep, __pte(0)); |
| 154 | } |
| 155 | #endif |
| 156 | |
| 157 | /* |
Ralf Baechle | c6e8b58 | 2005-02-10 12:19:59 +0000 | [diff] [blame] | 158 | * (pmds are folded into puds so this doesn't get actually called, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 159 | * but the define is needed for a generic inline function.) |
| 160 | */ |
| 161 | #define set_pmd(pmdptr, pmdval) do { *(pmdptr) = (pmdval); } while(0) |
Ralf Baechle | c6e8b58 | 2005-02-10 12:19:59 +0000 | [diff] [blame] | 162 | |
| 163 | #ifdef CONFIG_64BIT |
| 164 | /* |
| 165 | * (puds are folded into pgds so this doesn't get actually called, |
| 166 | * but the define is needed for a generic inline function.) |
| 167 | */ |
| 168 | #define set_pud(pudptr, pudval) do { *(pudptr) = (pudval); } while(0) |
| 169 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 170 | |
| 171 | #define PGD_T_LOG2 ffz(~sizeof(pgd_t)) |
| 172 | #define PMD_T_LOG2 ffz(~sizeof(pmd_t)) |
| 173 | #define PTE_T_LOG2 ffz(~sizeof(pte_t)) |
| 174 | |
| 175 | extern pgd_t swapper_pg_dir[PTRS_PER_PGD]; |
| 176 | |
| 177 | /* |
| 178 | * The following only work if pte_present() is true. |
| 179 | * Undefined behaviour if not.. |
| 180 | */ |
| 181 | static inline int pte_user(pte_t pte) { BUG(); return 0; } |
Ralf Baechle | 6e760c8 | 2005-07-06 12:08:11 +0000 | [diff] [blame] | 182 | #if defined(CONFIG_64BIT_PHYS_ADDR) && defined(CONFIG_CPU_MIPS32_R1) |
Sergei Shtylyov | 6e95389 | 2006-04-16 23:27:21 +0400 | [diff] [blame] | 183 | static inline int pte_read(pte_t pte) { return pte.pte_low & _PAGE_READ; } |
| 184 | static inline int pte_write(pte_t pte) { return pte.pte_low & _PAGE_WRITE; } |
| 185 | static inline int pte_dirty(pte_t pte) { return pte.pte_low & _PAGE_MODIFIED; } |
| 186 | static inline int pte_young(pte_t pte) { return pte.pte_low & _PAGE_ACCESSED; } |
| 187 | static inline int pte_file(pte_t pte) { return pte.pte_low & _PAGE_FILE; } |
| 188 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 189 | static inline pte_t pte_wrprotect(pte_t pte) |
| 190 | { |
Sergei Shtylyov | 6e95389 | 2006-04-16 23:27:21 +0400 | [diff] [blame] | 191 | pte.pte_low &= ~(_PAGE_WRITE | _PAGE_SILENT_WRITE); |
| 192 | pte.pte_high &= ~_PAGE_SILENT_WRITE; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 193 | return pte; |
| 194 | } |
| 195 | |
| 196 | static inline pte_t pte_rdprotect(pte_t pte) |
| 197 | { |
Sergei Shtylyov | 6e95389 | 2006-04-16 23:27:21 +0400 | [diff] [blame] | 198 | pte.pte_low &= ~(_PAGE_READ | _PAGE_SILENT_READ); |
| 199 | pte.pte_high &= ~_PAGE_SILENT_READ; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 200 | return pte; |
| 201 | } |
| 202 | |
| 203 | static inline pte_t pte_mkclean(pte_t pte) |
| 204 | { |
Sergei Shtylyov | 6e95389 | 2006-04-16 23:27:21 +0400 | [diff] [blame] | 205 | pte.pte_low &= ~(_PAGE_MODIFIED | _PAGE_SILENT_WRITE); |
| 206 | pte.pte_high &= ~_PAGE_SILENT_WRITE; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 207 | return pte; |
| 208 | } |
| 209 | |
| 210 | static inline pte_t pte_mkold(pte_t pte) |
| 211 | { |
Sergei Shtylyov | 6e95389 | 2006-04-16 23:27:21 +0400 | [diff] [blame] | 212 | pte.pte_low &= ~(_PAGE_ACCESSED | _PAGE_SILENT_READ); |
| 213 | pte.pte_high &= ~_PAGE_SILENT_READ; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 214 | return pte; |
| 215 | } |
| 216 | |
| 217 | static inline pte_t pte_mkwrite(pte_t pte) |
| 218 | { |
Sergei Shtylyov | 6e95389 | 2006-04-16 23:27:21 +0400 | [diff] [blame] | 219 | pte.pte_low |= _PAGE_WRITE; |
| 220 | if (pte.pte_low & _PAGE_MODIFIED) { |
| 221 | pte.pte_low |= _PAGE_SILENT_WRITE; |
| 222 | pte.pte_high |= _PAGE_SILENT_WRITE; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 223 | } |
| 224 | return pte; |
| 225 | } |
| 226 | |
| 227 | static inline pte_t pte_mkread(pte_t pte) |
| 228 | { |
Sergei Shtylyov | 6e95389 | 2006-04-16 23:27:21 +0400 | [diff] [blame] | 229 | pte.pte_low |= _PAGE_READ; |
| 230 | if (pte.pte_low & _PAGE_ACCESSED) { |
| 231 | pte.pte_low |= _PAGE_SILENT_READ; |
| 232 | pte.pte_high |= _PAGE_SILENT_READ; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 233 | } |
| 234 | return pte; |
| 235 | } |
| 236 | |
| 237 | static inline pte_t pte_mkdirty(pte_t pte) |
| 238 | { |
Sergei Shtylyov | 6e95389 | 2006-04-16 23:27:21 +0400 | [diff] [blame] | 239 | pte.pte_low |= _PAGE_MODIFIED; |
| 240 | if (pte.pte_low & _PAGE_WRITE) { |
| 241 | pte.pte_low |= _PAGE_SILENT_WRITE; |
| 242 | pte.pte_high |= _PAGE_SILENT_WRITE; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 243 | } |
| 244 | return pte; |
| 245 | } |
| 246 | |
| 247 | static inline pte_t pte_mkyoung(pte_t pte) |
| 248 | { |
Sergei Shtylyov | 6e95389 | 2006-04-16 23:27:21 +0400 | [diff] [blame] | 249 | pte.pte_low |= _PAGE_ACCESSED; |
| 250 | if (pte.pte_low & _PAGE_READ) |
| 251 | pte.pte_low |= _PAGE_SILENT_READ; |
| 252 | pte.pte_high |= _PAGE_SILENT_READ; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 253 | return pte; |
| 254 | } |
| 255 | #else |
| 256 | static inline int pte_read(pte_t pte) { return pte_val(pte) & _PAGE_READ; } |
| 257 | static inline int pte_write(pte_t pte) { return pte_val(pte) & _PAGE_WRITE; } |
| 258 | static inline int pte_dirty(pte_t pte) { return pte_val(pte) & _PAGE_MODIFIED; } |
| 259 | static inline int pte_young(pte_t pte) { return pte_val(pte) & _PAGE_ACCESSED; } |
| 260 | static inline int pte_file(pte_t pte) { return pte_val(pte) & _PAGE_FILE; } |
| 261 | |
| 262 | static inline pte_t pte_wrprotect(pte_t pte) |
| 263 | { |
| 264 | pte_val(pte) &= ~(_PAGE_WRITE | _PAGE_SILENT_WRITE); |
| 265 | return pte; |
| 266 | } |
| 267 | |
| 268 | static inline pte_t pte_rdprotect(pte_t pte) |
| 269 | { |
| 270 | pte_val(pte) &= ~(_PAGE_READ | _PAGE_SILENT_READ); |
| 271 | return pte; |
| 272 | } |
| 273 | |
| 274 | static inline pte_t pte_mkclean(pte_t pte) |
| 275 | { |
| 276 | pte_val(pte) &= ~(_PAGE_MODIFIED|_PAGE_SILENT_WRITE); |
| 277 | return pte; |
| 278 | } |
| 279 | |
| 280 | static inline pte_t pte_mkold(pte_t pte) |
| 281 | { |
| 282 | pte_val(pte) &= ~(_PAGE_ACCESSED|_PAGE_SILENT_READ); |
| 283 | return pte; |
| 284 | } |
| 285 | |
| 286 | static inline pte_t pte_mkwrite(pte_t pte) |
| 287 | { |
| 288 | pte_val(pte) |= _PAGE_WRITE; |
| 289 | if (pte_val(pte) & _PAGE_MODIFIED) |
| 290 | pte_val(pte) |= _PAGE_SILENT_WRITE; |
| 291 | return pte; |
| 292 | } |
| 293 | |
| 294 | static inline pte_t pte_mkread(pte_t pte) |
| 295 | { |
| 296 | pte_val(pte) |= _PAGE_READ; |
| 297 | if (pte_val(pte) & _PAGE_ACCESSED) |
| 298 | pte_val(pte) |= _PAGE_SILENT_READ; |
| 299 | return pte; |
| 300 | } |
| 301 | |
| 302 | static inline pte_t pte_mkdirty(pte_t pte) |
| 303 | { |
| 304 | pte_val(pte) |= _PAGE_MODIFIED; |
| 305 | if (pte_val(pte) & _PAGE_WRITE) |
| 306 | pte_val(pte) |= _PAGE_SILENT_WRITE; |
| 307 | return pte; |
| 308 | } |
| 309 | |
| 310 | static inline pte_t pte_mkyoung(pte_t pte) |
| 311 | { |
| 312 | pte_val(pte) |= _PAGE_ACCESSED; |
| 313 | if (pte_val(pte) & _PAGE_READ) |
| 314 | pte_val(pte) |= _PAGE_SILENT_READ; |
| 315 | return pte; |
| 316 | } |
| 317 | #endif |
| 318 | |
| 319 | /* |
| 320 | * Macro to make mark a page protection value as "uncacheable". Note |
| 321 | * that "protection" is really a misnomer here as the protection value |
| 322 | * contains the memory attribute bits, dirty bits, and various other |
| 323 | * bits as well. |
| 324 | */ |
| 325 | #define pgprot_noncached pgprot_noncached |
| 326 | |
| 327 | static inline pgprot_t pgprot_noncached(pgprot_t _prot) |
| 328 | { |
| 329 | unsigned long prot = pgprot_val(_prot); |
| 330 | |
| 331 | prot = (prot & ~_CACHE_MASK) | _CACHE_UNCACHED; |
| 332 | |
| 333 | return __pgprot(prot); |
| 334 | } |
| 335 | |
| 336 | /* |
| 337 | * Conversion functions: convert a page and protection to a page entry, |
| 338 | * and a page entry and page directory to the page they refer to. |
| 339 | */ |
| 340 | #define mk_pte(page, pgprot) pfn_pte(page_to_pfn(page), (pgprot)) |
| 341 | |
Ralf Baechle | 6e760c8 | 2005-07-06 12:08:11 +0000 | [diff] [blame] | 342 | #if defined(CONFIG_64BIT_PHYS_ADDR) && defined(CONFIG_CPU_MIPS32_R1) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 343 | static inline pte_t pte_modify(pte_t pte, pgprot_t newprot) |
| 344 | { |
Sergei Shtylyov | 79e0bc3 | 2006-05-03 22:56:43 +0400 | [diff] [blame] | 345 | pte.pte_low &= _PAGE_CHG_MASK; |
| 346 | pte.pte_high &= ~0x3f; |
| 347 | pte.pte_low |= pgprot_val(newprot); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 348 | pte.pte_high |= pgprot_val(newprot) & 0x3f; |
| 349 | return pte; |
| 350 | } |
| 351 | #else |
| 352 | static inline pte_t pte_modify(pte_t pte, pgprot_t newprot) |
| 353 | { |
| 354 | return __pte((pte_val(pte) & _PAGE_CHG_MASK) | pgprot_val(newprot)); |
| 355 | } |
| 356 | #endif |
| 357 | |
| 358 | |
| 359 | extern void __update_tlb(struct vm_area_struct *vma, unsigned long address, |
| 360 | pte_t pte); |
| 361 | extern void __update_cache(struct vm_area_struct *vma, unsigned long address, |
| 362 | pte_t pte); |
| 363 | |
| 364 | static inline void update_mmu_cache(struct vm_area_struct *vma, |
| 365 | unsigned long address, pte_t pte) |
| 366 | { |
| 367 | __update_tlb(vma, address, pte); |
| 368 | __update_cache(vma, address, pte); |
| 369 | } |
| 370 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 371 | #define kern_addr_valid(addr) (1) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 372 | |
| 373 | #ifdef CONFIG_64BIT_PHYS_ADDR |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 374 | extern int remap_pfn_range(struct vm_area_struct *vma, unsigned long from, unsigned long pfn, unsigned long size, pgprot_t prot); |
| 375 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 376 | static inline int io_remap_pfn_range(struct vm_area_struct *vma, |
| 377 | unsigned long vaddr, |
| 378 | unsigned long pfn, |
| 379 | unsigned long size, |
| 380 | pgprot_t prot) |
| 381 | { |
| 382 | phys_t phys_addr_high = fixup_bigphys_addr(pfn << PAGE_SHIFT, size); |
Thiemo Seufer | ac5d8c0 | 2005-04-11 12:24:16 +0000 | [diff] [blame] | 383 | return remap_pfn_range(vma, vaddr, phys_addr_high >> PAGE_SHIFT, size, prot); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 384 | } |
| 385 | #else |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 386 | #define io_remap_pfn_range(vma, vaddr, pfn, size, prot) \ |
| 387 | remap_pfn_range(vma, vaddr, pfn, size, prot) |
| 388 | #endif |
| 389 | |
| 390 | #define MK_IOSPACE_PFN(space, pfn) (pfn) |
| 391 | #define GET_IOSPACE(pfn) 0 |
| 392 | #define GET_PFN(pfn) (pfn) |
| 393 | |
| 394 | #include <asm-generic/pgtable.h> |
| 395 | |
| 396 | /* |
| 397 | * We provide our own get_unmapped area to cope with the virtual aliasing |
| 398 | * constraints placed on us by the cache architecture. |
| 399 | */ |
| 400 | #define HAVE_ARCH_UNMAPPED_AREA |
| 401 | |
| 402 | /* |
| 403 | * No page table caches to initialise |
| 404 | */ |
| 405 | #define pgtable_cache_init() do { } while (0) |
| 406 | |
| 407 | #endif /* _ASM_PGTABLE_H */ |