arch/mn10300/include/asm/pgtable.h

   1 /* MN10300 Page table manipulators and constants
   2  *
   3  * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
   4  * Written by David Howells (dhowells@redhat.com)
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public Licence
   8  * as published by the Free Software Foundation; either version
   9  * 2 of the Licence, or (at your option) any later version.
  10  *
  11  *
  12  * The Linux memory management assumes a three-level page table setup. On
  13  * the i386, we use that, but "fold" the mid level into the top-level page
  14  * table, so that we physically have the same two-level page table as the
  15  * i386 mmu expects.
  16  *
  17  * This file contains the functions and defines necessary to modify and use
  18  * the i386 page table tree for the purposes of the MN10300 TLB handler
  19  * functions.
  20  */
  21 #ifndef _ASM_PGTABLE_H
  22 #define _ASM_PGTABLE_H
  23
  24 #include <asm/cpu-regs.h>
  25
  26 #ifndef __ASSEMBLY__
  27 #include <asm/processor.h>
  28 #include <asm/cache.h>
  29 #include <linux/threads.h>
  30
  31 #include <asm/bitops.h>
  32
  33 #include <linux/slab.h>
  34 #include <linux/list.h>
  35 #include <linux/spinlock.h>
  36
  37 /*
  38  * ZERO_PAGE is a global shared page that is always zero: used
  39  * for zero-mapped memory areas etc..
  40  */
  41 #define ZERO_PAGE(vaddr) (virt_to_page(empty_zero_page))
  42 extern unsigned long empty_zero_page[1024];
  43 extern spinlock_t pgd_lock;
  44 extern struct page *pgd_list;
  45
  46 extern void pmd_ctor(void *, struct kmem_cache *, unsigned long);
  47 extern void pgtable_cache_init(void);
  48 extern void paging_init(void);
  49
  50 #endif /* !__ASSEMBLY__ */
  51
  52 /*
  53  * The Linux mn10300 paging architecture only implements both the traditional
  54  * 2-level page tables
  55  */
  56 #define PGDIR_SHIFT     22
  57 #define PTRS_PER_PGD    1024
  58 #define PTRS_PER_PUD    1       /* we don't really have any PUD physically */
  59 #define PTRS_PER_PMD    1       /* we don't really have any PMD physically */
  60 #define PTRS_PER_PTE    1024
  61
  62 #define PGD_SIZE        PAGE_SIZE
  63 #define PMD_SIZE        (1UL << PMD_SHIFT)
  64 #define PGDIR_SIZE      (1UL << PGDIR_SHIFT)
  65 #define PGDIR_MASK      (~(PGDIR_SIZE - 1))
  66
  67 #define USER_PTRS_PER_PGD       (TASK_SIZE / PGDIR_SIZE)
  68 #define FIRST_USER_ADDRESS      0UL
  69
  70 #define USER_PGD_PTRS           (PAGE_OFFSET >> PGDIR_SHIFT)
  71 #define KERNEL_PGD_PTRS         (PTRS_PER_PGD - USER_PGD_PTRS)
  72
  73 #define TWOLEVEL_PGDIR_SHIFT    22
  74 #define BOOT_USER_PGD_PTRS      (__PAGE_OFFSET >> TWOLEVEL_PGDIR_SHIFT)
  75 #define BOOT_KERNEL_PGD_PTRS    (1024 - BOOT_USER_PGD_PTRS)
  76
  77 #ifndef __ASSEMBLY__
  78 extern pgd_t swapper_pg_dir[PTRS_PER_PGD];
  79 #endif
  80
  81 /*
  82  * Unfortunately, due to the way the MMU works on the MN10300, the vmalloc VM
  83  * area has to be in the lower half of the virtual address range (the upper
  84  * half is not translated through the TLB).
  85  *
  86  * So in this case, the vmalloc area goes at the bottom of the address map
  87  * (leaving a hole at the very bottom to catch addressing errors), and
  88  * userspace starts immediately above.
  89  *
  90  * The vmalloc() routines also leaves a hole of 4kB between each vmalloced
  91  * area to catch addressing errors.
  92  */
  93 #ifndef __ASSEMBLY__
  94 #define VMALLOC_OFFSET  (8UL * 1024 * 1024)
  95 #define VMALLOC_START   (0x70000000UL)
  96 #define VMALLOC_END     (0x7C000000UL)
  97 #else
  98 #define VMALLOC_OFFSET  (8 * 1024 * 1024)
  99 #define VMALLOC_START   (0x70000000)
 100 #define VMALLOC_END     (0x7C000000)
 101 #endif
 102
 103 #ifndef __ASSEMBLY__
 104 extern pte_t kernel_vmalloc_ptes[(VMALLOC_END - VMALLOC_START) / PAGE_SIZE];
 105 #endif
 106
 107 /* IPTEL2/DPTEL2 bit assignments */
 108 #define _PAGE_BIT_VALID         xPTEL2_V_BIT
 109 #define _PAGE_BIT_CACHE         xPTEL2_C_BIT
 110 #define _PAGE_BIT_PRESENT       xPTEL2_PV_BIT
 111 #define _PAGE_BIT_DIRTY         xPTEL2_D_BIT
 112 #define _PAGE_BIT_GLOBAL        xPTEL2_G_BIT
 113 #define _PAGE_BIT_ACCESSED      xPTEL2_UNUSED1_BIT      /* mustn't be loaded into IPTEL2/DPTEL2 */
 114
 115 #define _PAGE_VALID             xPTEL2_V
 116 #define _PAGE_CACHE             xPTEL2_C
 117 #define _PAGE_PRESENT           xPTEL2_PV
 118 #define _PAGE_DIRTY             xPTEL2_D
 119 #define _PAGE_PROT              xPTEL2_PR
 120 #define _PAGE_PROT_RKNU         xPTEL2_PR_ROK
 121 #define _PAGE_PROT_WKNU         xPTEL2_PR_RWK
 122 #define _PAGE_PROT_RKRU         xPTEL2_PR_ROK_ROU
 123 #define _PAGE_PROT_WKRU         xPTEL2_PR_RWK_ROU
 124 #define _PAGE_PROT_WKWU         xPTEL2_PR_RWK_RWU
 125 #define _PAGE_GLOBAL            xPTEL2_G
 126 #define _PAGE_PS_MASK           xPTEL2_PS
 127 #define _PAGE_PS_4Kb            xPTEL2_PS_4Kb
 128 #define _PAGE_PS_128Kb          xPTEL2_PS_128Kb
 129 #define _PAGE_PS_1Kb            xPTEL2_PS_1Kb
 130 #define _PAGE_PS_4Mb            xPTEL2_PS_4Mb
 131 #define _PAGE_PSE               xPTEL2_PS_4Mb           /* 4MB page */
 132 #define _PAGE_CACHE_WT          xPTEL2_CWT
 133 #define _PAGE_ACCESSED          xPTEL2_UNUSED1
 134 #define _PAGE_NX                0                       /* no-execute bit */
 135
 136 /* If _PAGE_VALID is clear, we use these: */
 137 #define _PAGE_PROTNONE          0x000           /* If not present */
 138
 139 #define __PAGE_PROT_UWAUX       0x010
 140 #define __PAGE_PROT_USER        0x020
 141 #define __PAGE_PROT_WRITE       0x040
 142
 143 #define _PAGE_PRESENTV          (_PAGE_PRESENT|_PAGE_VALID)
 144
 145 #ifndef __ASSEMBLY__
 146
 147 #define VMALLOC_VMADDR(x) ((unsigned long)(x))
 148
 149 #define _PAGE_TABLE     (_PAGE_PRESENTV | _PAGE_PROT_WKNU | _PAGE_ACCESSED | _PAGE_DIRTY)
 150 #define _PAGE_CHG_MASK  (PTE_MASK | _PAGE_ACCESSED | _PAGE_DIRTY)
 151
 152 #define __PAGE_NONE     (_PAGE_PRESENTV | _PAGE_PROT_RKNU | _PAGE_ACCESSED | _PAGE_CACHE)
 153 #define __PAGE_SHARED   (_PAGE_PRESENTV | _PAGE_PROT_WKWU | _PAGE_ACCESSED | _PAGE_CACHE)
 154 #define __PAGE_COPY     (_PAGE_PRESENTV | _PAGE_PROT_RKRU | _PAGE_ACCESSED | _PAGE_CACHE)
 155 #define __PAGE_READONLY (_PAGE_PRESENTV | _PAGE_PROT_RKRU | _PAGE_ACCESSED | _PAGE_CACHE)
 156
 157 #define PAGE_NONE               __pgprot(__PAGE_NONE     | _PAGE_NX)
 158 #define PAGE_SHARED_NOEXEC      __pgprot(__PAGE_SHARED   | _PAGE_NX)
 159 #define PAGE_COPY_NOEXEC        __pgprot(__PAGE_COPY     | _PAGE_NX)
 160 #define PAGE_READONLY_NOEXEC    __pgprot(__PAGE_READONLY | _PAGE_NX)
 161 #define PAGE_SHARED_EXEC        __pgprot(__PAGE_SHARED)
 162 #define PAGE_COPY_EXEC          __pgprot(__PAGE_COPY)
 163 #define PAGE_READONLY_EXEC      __pgprot(__PAGE_READONLY)
 164 #define PAGE_COPY               PAGE_COPY_NOEXEC
 165 #define PAGE_READONLY           PAGE_READONLY_NOEXEC
 166 #define PAGE_SHARED             PAGE_SHARED_EXEC
 167
 168 #define __PAGE_KERNEL_BASE (_PAGE_PRESENTV | _PAGE_DIRTY | _PAGE_ACCESSED | _PAGE_GLOBAL)
 169
 170 #define __PAGE_KERNEL           (__PAGE_KERNEL_BASE | _PAGE_PROT_WKNU | _PAGE_CACHE | _PAGE_NX)
 171 #define __PAGE_KERNEL_NOCACHE   (__PAGE_KERNEL_BASE | _PAGE_PROT_WKNU | _PAGE_NX)
 172 #define __PAGE_KERNEL_EXEC      (__PAGE_KERNEL & ~_PAGE_NX)
 173 #define __PAGE_KERNEL_RO        (__PAGE_KERNEL_BASE | _PAGE_PROT_RKNU | _PAGE_CACHE | _PAGE_NX)
 174 #define __PAGE_KERNEL_LARGE     (__PAGE_KERNEL | _PAGE_PSE)
 175 #define __PAGE_KERNEL_LARGE_EXEC (__PAGE_KERNEL_EXEC | _PAGE_PSE)
 176
 177 #define PAGE_KERNEL             __pgprot(__PAGE_KERNEL)
 178 #define PAGE_KERNEL_RO          __pgprot(__PAGE_KERNEL_RO)
 179 #define PAGE_KERNEL_EXEC        __pgprot(__PAGE_KERNEL_EXEC)
 180 #define PAGE_KERNEL_NOCACHE     __pgprot(__PAGE_KERNEL_NOCACHE)
 181 #define PAGE_KERNEL_LARGE       __pgprot(__PAGE_KERNEL_LARGE)
 182 #define PAGE_KERNEL_LARGE_EXEC  __pgprot(__PAGE_KERNEL_LARGE_EXEC)
 183
 184 #define __PAGE_USERIO           (__PAGE_KERNEL_BASE | _PAGE_PROT_WKWU | _PAGE_NX)
 185 #define PAGE_USERIO             __pgprot(__PAGE_USERIO)
 186
 187 /*
 188  * Whilst the MN10300 can do page protection for execute (given separate data
 189  * and insn TLBs), we are not supporting it at the moment. Write permission,
 190  * however, always implies read permission (but not execute permission).
 191  */
 192 #define __P000  PAGE_NONE
 193 #define __P001  PAGE_READONLY_NOEXEC
 194 #define __P010  PAGE_COPY_NOEXEC
 195 #define __P011  PAGE_COPY_NOEXEC
 196 #define __P100  PAGE_READONLY_EXEC
 197 #define __P101  PAGE_READONLY_EXEC
 198 #define __P110  PAGE_COPY_EXEC
 199 #define __P111  PAGE_COPY_EXEC
 200
 201 #define __S000  PAGE_NONE
 202 #define __S001  PAGE_READONLY_NOEXEC
 203 #define __S010  PAGE_SHARED_NOEXEC
 204 #define __S011  PAGE_SHARED_NOEXEC
 205 #define __S100  PAGE_READONLY_EXEC
 206 #define __S101  PAGE_READONLY_EXEC
 207 #define __S110  PAGE_SHARED_EXEC
 208 #define __S111  PAGE_SHARED_EXEC
 209
 210 /*
 211  * Define this to warn about kernel memory accesses that are
 212  * done without a 'verify_area(VERIFY_WRITE,..)'
 213  */
 214 #undef TEST_VERIFY_AREA
 215
 216 #define pte_present(x)  (pte_val(x) & _PAGE_VALID)
 217 #define pte_clear(mm, addr, xp)                         \
 218 do {                                                    \
 219         set_pte_at((mm), (addr), (xp), __pte(0));       \
 220 } while (0)
 221
 222 #define pmd_none(x)     (!pmd_val(x))
 223 #define pmd_present(x)  (!pmd_none(x))
 224 #define pmd_clear(xp)   do { set_pmd(xp, __pmd(0)); } while (0)
 225 #define pmd_bad(x)      0
 226
 227
 228 #define pages_to_mb(x) ((x) >> (20 - PAGE_SHIFT))
 229
 230 #ifndef __ASSEMBLY__
 231
 232 /*
 233  * The following only work if pte_present() is true.
 234  * Undefined behaviour if not..
 235  */
 236 static inline int pte_user(pte_t pte)   { return pte_val(pte) & __PAGE_PROT_USER; }
 237 static inline int pte_read(pte_t pte)   { return pte_val(pte) & __PAGE_PROT_USER; }
 238 static inline int pte_dirty(pte_t pte)  { return pte_val(pte) & _PAGE_DIRTY; }
 239 static inline int pte_young(pte_t pte)  { return pte_val(pte) & _PAGE_ACCESSED; }
 240 static inline int pte_write(pte_t pte)  { return pte_val(pte) & __PAGE_PROT_WRITE; }
 241 static inline int pte_special(pte_t pte){ return 0; }
 242
 243 static inline pte_t pte_rdprotect(pte_t pte)
 244 {
 245         pte_val(pte) &= ~(__PAGE_PROT_USER|__PAGE_PROT_UWAUX); return pte;
 246 }
 247 static inline pte_t pte_exprotect(pte_t pte)
 248 {
 249         pte_val(pte) |= _PAGE_NX; return pte;
 250 }
 251
 252 static inline pte_t pte_wrprotect(pte_t pte)
 253 {
 254         pte_val(pte) &= ~(__PAGE_PROT_WRITE|__PAGE_PROT_UWAUX); return pte;
 255 }
 256
 257 static inline pte_t pte_mkclean(pte_t pte)      { pte_val(pte) &= ~_PAGE_DIRTY; return pte; }
 258 static inline pte_t pte_mkold(pte_t pte)        { pte_val(pte) &= ~_PAGE_ACCESSED; return pte; }
 259 static inline pte_t pte_mkdirty(pte_t pte)      { pte_val(pte) |= _PAGE_DIRTY; return pte; }
 260 static inline pte_t pte_mkyoung(pte_t pte)      { pte_val(pte) |= _PAGE_ACCESSED; return pte; }
 261 static inline pte_t pte_mkexec(pte_t pte)       { pte_val(pte) &= ~_PAGE_NX; return pte; }
 262
 263 static inline pte_t pte_mkread(pte_t pte)
 264 {
 265         pte_val(pte) |= __PAGE_PROT_USER;
 266         if (pte_write(pte))
 267                 pte_val(pte) |= __PAGE_PROT_UWAUX;
 268         return pte;
 269 }
 270 static inline pte_t pte_mkwrite(pte_t pte)
 271 {
 272         pte_val(pte) |= __PAGE_PROT_WRITE;
 273         if (pte_val(pte) & __PAGE_PROT_USER)
 274                 pte_val(pte) |= __PAGE_PROT_UWAUX;
 275         return pte;
 276 }
 277
 278 static inline pte_t pte_mkspecial(pte_t pte)    { return pte; }
 279
 280 #define pte_ERROR(e) \
 281         printk(KERN_ERR "%s:%d: bad pte %08lx.\n", \
 282                __FILE__, __LINE__, pte_val(e))
 283 #define pgd_ERROR(e) \
 284         printk(KERN_ERR "%s:%d: bad pgd %08lx.\n", \
 285                __FILE__, __LINE__, pgd_val(e))
 286
 287 /*
 288  * The "pgd_xxx()" functions here are trivial for a folded two-level
 289  * setup: the pgd is never bad, and a pmd always exists (as it's folded
 290  * into the pgd entry)
 291  */
 292 #define pgd_clear(xp)                           do { } while (0)
 293
 294 /*
 295  * Certain architectures need to do special things when PTEs
 296  * within a page table are directly modified.  Thus, the following
 297  * hook is made available.
 298  */
 299 #define set_pte(pteptr, pteval)                 (*(pteptr) = pteval)
 300 #define set_pte_at(mm, addr, ptep, pteval)      set_pte((ptep), (pteval))
 301 #define set_pte_atomic(pteptr, pteval)          set_pte((pteptr), (pteval))
 302
 303 /*
 304  * (pmds are folded into pgds so this doesn't get actually called,
 305  * but the define is needed for a generic inline function.)
 306  */
 307 #define set_pmd(pmdptr, pmdval) (*(pmdptr) = pmdval)
 308
 309 #define ptep_get_and_clear(mm, addr, ptep) \
 310         __pte(xchg(&(ptep)->pte, 0))
 311 #define pte_same(a, b)          (pte_val(a) == pte_val(b))
 312 #define pte_page(x)             pfn_to_page(pte_pfn(x))
 313 #define pte_none(x)             (!pte_val(x))
 314 #define pte_pfn(x)              ((unsigned long) (pte_val(x) >> PAGE_SHIFT))
 315 #define __pfn_addr(pfn)         ((pfn) << PAGE_SHIFT)
 316 #define pfn_pte(pfn, prot)      __pte(__pfn_addr(pfn) | pgprot_val(prot))
 317 #define pfn_pmd(pfn, prot)      __pmd(__pfn_addr(pfn) | pgprot_val(prot))
 318
 319 /*
 320  * All present user pages are user-executable:
 321  */
 322 static inline int pte_exec(pte_t pte)
 323 {
 324         return pte_user(pte);
 325 }
 326
 327 /*
 328  * All present pages are kernel-executable:
 329  */
 330 static inline int pte_exec_kernel(pte_t pte)
 331 {
 332         return 1;
 333 }
 334
 335 /* Encode and de-code a swap entry */
 336 #define __swp_type(x)                   (((x).val >> 1) & 0x3f)
 337 #define __swp_offset(x)                 ((x).val >> 7)
 338 #define __swp_entry(type, offset) \
 339         ((swp_entry_t) { ((type) << 1) | ((offset) << 7) })
 340 #define __pte_to_swp_entry(pte)         ((swp_entry_t) { pte_val(pte) })
 341 #define __swp_entry_to_pte(x)           __pte((x).val)
 342
 343 static inline
 344 int ptep_test_and_clear_dirty(struct vm_area_struct *vma, unsigned long addr,
 345                               pte_t *ptep)
 346 {
 347         if (!pte_dirty(*ptep))
 348                 return 0;
 349         return test_and_clear_bit(_PAGE_BIT_DIRTY, &ptep->pte);
 350 }
 351
 352 static inline
 353 int ptep_test_and_clear_young(struct vm_area_struct *vma, unsigned long addr,
 354                               pte_t *ptep)
 355 {
 356         if (!pte_young(*ptep))
 357                 return 0;
 358         return test_and_clear_bit(_PAGE_BIT_ACCESSED, &ptep->pte);
 359 }
 360
 361 static inline
 362 void ptep_set_wrprotect(struct mm_struct *mm, unsigned long addr, pte_t *ptep)
 363 {
 364         pte_val(*ptep) &= ~(__PAGE_PROT_WRITE|__PAGE_PROT_UWAUX);
 365 }
 366
 367 static inline void ptep_mkdirty(pte_t *ptep)
 368 {
 369         set_bit(_PAGE_BIT_DIRTY, &ptep->pte);
 370 }
 371
 372 /*
 373  * Macro to mark a page protection value as "uncacheable".  On processors which
 374  * do not support it, this is a no-op.
 375  */
 376 #define pgprot_noncached(prot)  __pgprot(pgprot_val(prot) & ~_PAGE_CACHE)
 377
 378 /*
 379  * Macro to mark a page protection value as "Write-Through".
 380  * On processors which do not support it, this is a no-op.
 381  */
 382 #define pgprot_through(prot)    __pgprot(pgprot_val(prot) | _PAGE_CACHE_WT)
 383
 384 /*
 385  * Conversion functions: convert a page and protection to a page entry,
 386  * and a page entry and page directory to the page they refer to.
 387  */
 388
 389 #define mk_pte(page, pgprot)    pfn_pte(page_to_pfn(page), (pgprot))
 390 #define mk_pte_huge(entry) \
 391         ((entry).pte |= _PAGE_PRESENT | _PAGE_PSE | _PAGE_VALID)
 392
 393 static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
 394 {
 395         pte_val(pte) &= _PAGE_CHG_MASK;
 396         pte_val(pte) |= pgprot_val(newprot);
 397         return pte;
 398 }
 399
 400 #define page_pte(page)  page_pte_prot((page), __pgprot(0))
 401
 402 #define pmd_page_kernel(pmd) \
 403         ((unsigned long) __va(pmd_val(pmd) & PAGE_MASK))
 404
 405 #define pmd_page(pmd)   pfn_to_page(pmd_val(pmd) >> PAGE_SHIFT)
 406
 407 #define pmd_large(pmd) \
 408         ((pmd_val(pmd) & (_PAGE_PSE | _PAGE_PRESENT)) == \
 409          (_PAGE_PSE | _PAGE_PRESENT))
 410
 411 /*
 412  * the pgd page can be thought of an array like this: pgd_t[PTRS_PER_PGD]
 413  *
 414  * this macro returns the index of the entry in the pgd page which would
 415  * control the given virtual address
 416  */
 417 #define pgd_index(address) (((address) >> PGDIR_SHIFT) & (PTRS_PER_PGD - 1))
 418
 419 /*
 420  * pgd_offset() returns a (pgd_t *)
 421  * pgd_index() is used get the offset into the pgd page's array of pgd_t's;
 422  */
 423 #define pgd_offset(mm, address) ((mm)->pgd + pgd_index(address))
 424
 425 /*
 426  * a shortcut which implies the use of the kernel's pgd, instead
 427  * of a process's
 428  */
 429 #define pgd_offset_k(address)   pgd_offset(&init_mm, address)
 430
 431 /*
 432  * the pmd page can be thought of an array like this: pmd_t[PTRS_PER_PMD]
 433  *
 434  * this macro returns the index of the entry in the pmd page which would
 435  * control the given virtual address
 436  */
 437 #define pmd_index(address) \
 438         (((address) >> PMD_SHIFT) & (PTRS_PER_PMD - 1))
 439
 440 /*
 441  * the pte page can be thought of an array like this: pte_t[PTRS_PER_PTE]
 442  *
 443  * this macro returns the index of the entry in the pte page which would
 444  * control the given virtual address
 445  */
 446 #define pte_index(address) \
 447         (((address) >> PAGE_SHIFT) & (PTRS_PER_PTE - 1))
 448
 449 #define pte_offset_kernel(dir, address) \
 450         ((pte_t *) pmd_page_kernel(*(dir)) +  pte_index(address))
 451
 452 /*
 453  * Make a given kernel text page executable/non-executable.
 454  * Returns the previous executability setting of that page (which
 455  * is used to restore the previous state). Used by the SMP bootup code.
 456  * NOTE: this is an __init function for security reasons.
 457  */
 458 static inline int set_kernel_exec(unsigned long vaddr, int enable)
 459 {
 460         return 0;
 461 }
 462
 463 #define pte_offset_map(dir, address) \
 464         ((pte_t *) page_address(pmd_page(*(dir))) + pte_index(address))
 465 #define pte_unmap(pte)          do {} while (0)
 466
 467 /*
 468  * The MN10300 has external MMU info in the form of a TLB: this is adapted from
 469  * the kernel page tables containing the necessary information by tlb-mn10300.S
 470  */
 471 extern void update_mmu_cache(struct vm_area_struct *vma,
 472                              unsigned long address, pte_t *ptep);
 473
 474 #endif /* !__ASSEMBLY__ */
 475
 476 #define kern_addr_valid(addr)   (1)
 477
 478 #define MK_IOSPACE_PFN(space, pfn)      (pfn)
 479 #define GET_IOSPACE(pfn)                0
 480 #define GET_PFN(pfn)                    (pfn)
 481
 482 #define __HAVE_ARCH_PTEP_TEST_AND_CLEAR_YOUNG
 483 #define __HAVE_ARCH_PTEP_TEST_AND_CLEAR_DIRTY
 484 #define __HAVE_ARCH_PTEP_GET_AND_CLEAR
 485 #define __HAVE_ARCH_PTEP_SET_WRPROTECT
 486 #define __HAVE_ARCH_PTEP_MKDIRTY
 487 #define __HAVE_ARCH_PTE_SAME
 488 #include <asm-generic/pgtable.h>
 489
 490 #endif /* !__ASSEMBLY__ */
 491
 492 #endif /* _ASM_PGTABLE_H */