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