LXR linux/arch/m68k/include/asm/mcf

   1#ifndef _MCF_PGTABLE_H
   2#define _MCF_PGTABLE_H
   3
   4#include <asm/mcfmmu.h>
   5#include <asm/page.h>
   6
   7/*
   8 * MMUDR bits, in proper place. We write these directly into the MMUDR
   9 * after masking from the pte.
  10 */
  11#define CF_PAGE_LOCKED          MMUDR_LK        /* 0x00000002 */
  12#define CF_PAGE_EXEC            MMUDR_X         /* 0x00000004 */
  13#define CF_PAGE_WRITABLE        MMUDR_W         /* 0x00000008 */
  14#define CF_PAGE_READABLE        MMUDR_R         /* 0x00000010 */
  15#define CF_PAGE_SYSTEM          MMUDR_SP        /* 0x00000020 */
  16#define CF_PAGE_COPYBACK        MMUDR_CM_CCB    /* 0x00000040 */
  17#define CF_PAGE_NOCACHE         MMUDR_CM_NCP    /* 0x00000080 */
  18
  19#define CF_CACHEMASK            (~MMUDR_CM_CCB)
  20#define CF_PAGE_MMUDR_MASK      0x000000fe
  21
  22#define _PAGE_NOCACHE030        CF_PAGE_NOCACHE
  23
  24/*
  25 * MMUTR bits, need shifting down.
  26 */
  27#define CF_PAGE_MMUTR_MASK      0x00000c00
  28#define CF_PAGE_MMUTR_SHIFT     10
  29
  30#define CF_PAGE_VALID           (MMUTR_V << CF_PAGE_MMUTR_SHIFT)
  31#define CF_PAGE_SHARED          (MMUTR_SG << CF_PAGE_MMUTR_SHIFT)
  32
  33/*
  34 * Fake bits, not implemented in CF, will get masked out before
  35 * hitting hardware.
  36 */
  37#define CF_PAGE_DIRTY           0x00000001
  38#define CF_PAGE_ACCESSED        0x00001000
  39
  40#define _PAGE_CACHE040          0x020   /* 68040 cache mode, cachable, copyback */
  41#define _PAGE_NOCACHE_S         0x040   /* 68040 no-cache mode, serialized */
  42#define _PAGE_NOCACHE           0x060   /* 68040 cache mode, non-serialized */
  43#define _PAGE_CACHE040W         0x000   /* 68040 cache mode, cachable, write-through */
  44#define _DESCTYPE_MASK          0x003
  45#define _CACHEMASK040           (~0x060)
  46#define _PAGE_GLOBAL040         0x400   /* 68040 global bit, used for kva descs */
  47
  48/*
  49 * Externally used page protection values.
  50 */
  51#define _PAGE_PRESENT   (CF_PAGE_VALID)
  52#define _PAGE_ACCESSED  (CF_PAGE_ACCESSED)
  53#define _PAGE_DIRTY     (CF_PAGE_DIRTY)
  54#define _PAGE_READWRITE (CF_PAGE_READABLE \
  55                                | CF_PAGE_WRITABLE \
  56                                | CF_PAGE_SYSTEM \
  57                                | CF_PAGE_SHARED)
  58
  59/*
  60 * Compound page protection values.
  61 */
  62#define PAGE_NONE       __pgprot(CF_PAGE_VALID \
  63                                 | CF_PAGE_ACCESSED)
  64
  65#define PAGE_SHARED     __pgprot(CF_PAGE_VALID \
  66                                 | CF_PAGE_ACCESSED \
  67                                 | CF_PAGE_SHARED)
  68
  69#define PAGE_INIT       __pgprot(CF_PAGE_VALID \
  70                                 | CF_PAGE_READABLE \
  71                                 | CF_PAGE_WRITABLE \
  72                                 | CF_PAGE_EXEC \
  73                                 | CF_PAGE_SYSTEM)
  74
  75#define PAGE_KERNEL     __pgprot(CF_PAGE_VALID \
  76                                 | CF_PAGE_ACCESSED \
  77                                 | CF_PAGE_READABLE \
  78                                 | CF_PAGE_WRITABLE \
  79                                 | CF_PAGE_EXEC \
  80                                 | CF_PAGE_SYSTEM \
  81                                 | CF_PAGE_SHARED)
  82
  83#define PAGE_COPY       __pgprot(CF_PAGE_VALID \
  84                                 | CF_PAGE_ACCESSED \
  85                                 | CF_PAGE_READABLE \
  86                                 | CF_PAGE_DIRTY)
  87
  88/*
  89 * Page protections for initialising protection_map. See mm/mmap.c
  90 * for use. In general, the bit positions are xwr, and P-items are
  91 * private, the S-items are shared.
  92 */
  93#define __P000          PAGE_NONE
  94#define __P001          __pgprot(CF_PAGE_VALID \
  95                                 | CF_PAGE_ACCESSED \
  96                                 | CF_PAGE_READABLE)
  97#define __P010          __pgprot(CF_PAGE_VALID \
  98                                 | CF_PAGE_ACCESSED \
  99                                 | CF_PAGE_WRITABLE)
 100#define __P011          __pgprot(CF_PAGE_VALID \
 101                                 | CF_PAGE_ACCESSED \
 102                                 | CF_PAGE_READABLE \
 103                                 | CF_PAGE_WRITABLE)
 104#define __P100          __pgprot(CF_PAGE_VALID \
 105                                 | CF_PAGE_ACCESSED \
 106                                 | CF_PAGE_EXEC)
 107#define __P101          __pgprot(CF_PAGE_VALID \
 108                                 | CF_PAGE_ACCESSED \
 109                                 | CF_PAGE_READABLE \
 110                                 | CF_PAGE_EXEC)
 111#define __P110          __pgprot(CF_PAGE_VALID \
 112                                 | CF_PAGE_ACCESSED \
 113                                 | CF_PAGE_WRITABLE \
 114                                 | CF_PAGE_EXEC)
 115#define __P111          __pgprot(CF_PAGE_VALID \
 116                                 | CF_PAGE_ACCESSED \
 117                                 | CF_PAGE_READABLE \
 118                                 | CF_PAGE_WRITABLE \
 119                                 | CF_PAGE_EXEC)
 120
 121#define __S000          PAGE_NONE
 122#define __S001          __pgprot(CF_PAGE_VALID \
 123                                 | CF_PAGE_ACCESSED \
 124                                 | CF_PAGE_READABLE)
 125#define __S010          PAGE_SHARED
 126#define __S011          __pgprot(CF_PAGE_VALID \
 127                                 | CF_PAGE_ACCESSED \
 128                                 | CF_PAGE_SHARED \
 129                                 | CF_PAGE_READABLE)
 130#define __S100          __pgprot(CF_PAGE_VALID \
 131                                 | CF_PAGE_ACCESSED \
 132                                 | CF_PAGE_EXEC)
 133#define __S101          __pgprot(CF_PAGE_VALID \
 134                                 | CF_PAGE_ACCESSED \
 135                                 | CF_PAGE_READABLE \
 136                                 | CF_PAGE_EXEC)
 137#define __S110          __pgprot(CF_PAGE_VALID \
 138                                 | CF_PAGE_ACCESSED \
 139                                 | CF_PAGE_SHARED \
 140                                 | CF_PAGE_EXEC)
 141#define __S111          __pgprot(CF_PAGE_VALID \
 142                                 | CF_PAGE_ACCESSED \
 143                                 | CF_PAGE_SHARED \
 144                                 | CF_PAGE_READABLE \
 145                                 | CF_PAGE_EXEC)
 146
 147#define PTE_MASK        PAGE_MASK
 148#define CF_PAGE_CHG_MASK (PTE_MASK | CF_PAGE_ACCESSED | CF_PAGE_DIRTY)
 149
 150#ifndef __ASSEMBLY__
 151
 152/*
 153 * Conversion functions: convert a page and protection to a page entry,
 154 * and a page entry and page directory to the page they refer to.
 155 */
 156#define mk_pte(page, pgprot) pfn_pte(page_to_pfn(page), (pgprot))
 157
 158static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
 159{
 160        pte_val(pte) = (pte_val(pte) & CF_PAGE_CHG_MASK) | pgprot_val(newprot);
 161        return pte;
 162}
 163
 164#define pmd_set(pmdp, ptep) do {} while (0)
 165
 166static inline void pgd_set(pgd_t *pgdp, pmd_t *pmdp)
 167{
 168        pgd_val(*pgdp) = virt_to_phys(pmdp);
 169}
 170
 171#define __pte_page(pte) ((unsigned long) (pte_val(pte) & PAGE_MASK))
 172#define __pmd_page(pmd) ((unsigned long) (pmd_val(pmd)))
 173
 174static inline int pte_none(pte_t pte)
 175{
 176        return !pte_val(pte);
 177}
 178
 179static inline int pte_present(pte_t pte)
 180{
 181        return pte_val(pte) & CF_PAGE_VALID;
 182}
 183
 184static inline void pte_clear(struct mm_struct *mm, unsigned long addr,
 185        pte_t *ptep)
 186{
 187        pte_val(*ptep) = 0;
 188}
 189
 190#define pte_pagenr(pte) ((__pte_page(pte) - PAGE_OFFSET) >> PAGE_SHIFT)
 191#define pte_page(pte)   virt_to_page(__pte_page(pte))
 192
 193static inline int pmd_none2(pmd_t *pmd) { return !pmd_val(*pmd); }
 194#define pmd_none(pmd) pmd_none2(&(pmd))
 195static inline int pmd_bad2(pmd_t *pmd) { return 0; }
 196#define pmd_bad(pmd) pmd_bad2(&(pmd))
 197#define pmd_present(pmd) (!pmd_none2(&(pmd)))
 198static inline void pmd_clear(pmd_t *pmdp) { pmd_val(*pmdp) = 0; }
 199
 200static inline int pgd_none(pgd_t pgd) { return 0; }
 201static inline int pgd_bad(pgd_t pgd) { return 0; }
 202static inline int pgd_present(pgd_t pgd) { return 1; }
 203static inline void pgd_clear(pgd_t *pgdp) {}
 204
 205#define pte_ERROR(e) \
 206        printk(KERN_ERR "%s:%d: bad pte %08lx.\n",      \
 207        __FILE__, __LINE__, pte_val(e))
 208#define pmd_ERROR(e) \
 209        printk(KERN_ERR "%s:%d: bad pmd %08lx.\n",      \
 210        __FILE__, __LINE__, pmd_val(e))
 211#define pgd_ERROR(e) \
 212        printk(KERN_ERR "%s:%d: bad pgd %08lx.\n",      \
 213        __FILE__, __LINE__, pgd_val(e))
 214
 215/*
 216 * The following only work if pte_present() is true.
 217 * Undefined behaviour if not...
 218 * [we have the full set here even if they don't change from m68k]
 219 */
 220static inline int pte_read(pte_t pte)
 221{
 222        return pte_val(pte) & CF_PAGE_READABLE;
 223}
 224
 225static inline int pte_write(pte_t pte)
 226{
 227        return pte_val(pte) & CF_PAGE_WRITABLE;
 228}
 229
 230static inline int pte_exec(pte_t pte)
 231{
 232        return pte_val(pte) & CF_PAGE_EXEC;
 233}
 234
 235static inline int pte_dirty(pte_t pte)
 236{
 237        return pte_val(pte) & CF_PAGE_DIRTY;
 238}
 239
 240static inline int pte_young(pte_t pte)
 241{
 242        return pte_val(pte) & CF_PAGE_ACCESSED;
 243}
 244
 245static inline int pte_special(pte_t pte)
 246{
 247        return 0;
 248}
 249
 250static inline pte_t pte_wrprotect(pte_t pte)
 251{
 252        pte_val(pte) &= ~CF_PAGE_WRITABLE;
 253        return pte;
 254}
 255
 256static inline pte_t pte_rdprotect(pte_t pte)
 257{
 258        pte_val(pte) &= ~CF_PAGE_READABLE;
 259        return pte;
 260}
 261
 262static inline pte_t pte_exprotect(pte_t pte)
 263{
 264        pte_val(pte) &= ~CF_PAGE_EXEC;
 265        return pte;
 266}
 267
 268static inline pte_t pte_mkclean(pte_t pte)
 269{
 270        pte_val(pte) &= ~CF_PAGE_DIRTY;
 271        return pte;
 272}
 273
 274static inline pte_t pte_mkold(pte_t pte)
 275{
 276        pte_val(pte) &= ~CF_PAGE_ACCESSED;
 277        return pte;
 278}
 279
 280static inline pte_t pte_mkwrite(pte_t pte)
 281{
 282        pte_val(pte) |= CF_PAGE_WRITABLE;
 283        return pte;
 284}
 285
 286static inline pte_t pte_mkread(pte_t pte)
 287{
 288        pte_val(pte) |= CF_PAGE_READABLE;
 289        return pte;
 290}
 291
 292static inline pte_t pte_mkexec(pte_t pte)
 293{
 294        pte_val(pte) |= CF_PAGE_EXEC;
 295        return pte;
 296}
 297
 298static inline pte_t pte_mkdirty(pte_t pte)
 299{
 300        pte_val(pte) |= CF_PAGE_DIRTY;
 301        return pte;
 302}
 303
 304static inline pte_t pte_mkyoung(pte_t pte)
 305{
 306        pte_val(pte) |= CF_PAGE_ACCESSED;
 307        return pte;
 308}
 309
 310static inline pte_t pte_mknocache(pte_t pte)
 311{
 312        pte_val(pte) |= 0x80 | (pte_val(pte) & ~0x40);
 313        return pte;
 314}
 315
 316static inline pte_t pte_mkcache(pte_t pte)
 317{
 318        pte_val(pte) &= ~CF_PAGE_NOCACHE;
 319        return pte;
 320}
 321
 322static inline pte_t pte_mkspecial(pte_t pte)
 323{
 324        return pte;
 325}
 326
 327#define swapper_pg_dir kernel_pg_dir
 328extern pgd_t kernel_pg_dir[PTRS_PER_PGD];
 329
 330/*
 331 * Find an entry in a pagetable directory.
 332 */
 333#define pgd_index(address)      ((address) >> PGDIR_SHIFT)
 334#define pgd_offset(mm, address) ((mm)->pgd + pgd_index(address))
 335
 336/*
 337 * Find an entry in a kernel pagetable directory.
 338 */
 339#define pgd_offset_k(address)   pgd_offset(&init_mm, address)
 340
 341/*
 342 * Find an entry in the second-level pagetable.
 343 */
 344static inline pmd_t *pmd_offset(pgd_t *pgd, unsigned long address)
 345{
 346        return (pmd_t *) pgd;
 347}
 348
 349/*
 350 * Find an entry in the third-level pagetable.
 351 */
 352#define __pte_offset(address)   ((address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1))
 353#define pte_offset_kernel(dir, address) \
 354        ((pte_t *) __pmd_page(*(dir)) + __pte_offset(address))
 355
 356/*
 357 * Disable caching for page at given kernel virtual address.
 358 */
 359static inline void nocache_page(void *vaddr)
 360{
 361        pgd_t *dir;
 362        pmd_t *pmdp;
 363        pte_t *ptep;
 364        unsigned long addr = (unsigned long) vaddr;
 365
 366        dir = pgd_offset_k(addr);
 367        pmdp = pmd_offset(dir, addr);
 368        ptep = pte_offset_kernel(pmdp, addr);
 369        *ptep = pte_mknocache(*ptep);
 370}
 371
 372/*
 373 * Enable caching for page at given kernel virtual address.
 374 */
 375static inline void cache_page(void *vaddr)
 376{
 377        pgd_t *dir;
 378        pmd_t *pmdp;
 379        pte_t *ptep;
 380        unsigned long addr = (unsigned long) vaddr;
 381
 382        dir = pgd_offset_k(addr);
 383        pmdp = pmd_offset(dir, addr);
 384        ptep = pte_offset_kernel(pmdp, addr);
 385        *ptep = pte_mkcache(*ptep);
 386}
 387
 388/*
 389 * Encode and de-code a swap entry (must be !pte_none(e) && !pte_present(e))
 390 */
 391#define __swp_type(x)           ((x).val & 0xFF)
 392#define __swp_offset(x)         ((x).val >> 11)
 393#define __swp_entry(typ, off)   ((swp_entry_t) { (typ) | \
 394                                        (off << 11) })
 395#define __pte_to_swp_entry(pte) ((swp_entry_t) { pte_val(pte) })
 396#define __swp_entry_to_pte(x)   (__pte((x).val))
 397
 398#define pmd_page(pmd)           (pfn_to_page(pmd_val(pmd) >> PAGE_SHIFT))
 399
 400#define pte_offset_map(pmdp, addr) ((pte_t *)__pmd_page(*pmdp) + \
 401                                       __pte_offset(addr))
 402#define pte_unmap(pte)          ((void) 0)
 403#define pfn_pte(pfn, prot)      __pte(((pfn) << PAGE_SHIFT) | pgprot_val(prot))
 404#define pte_pfn(pte)            (pte_val(pte) >> PAGE_SHIFT)
 405
 406#endif  /* !__ASSEMBLY__ */
 407#endif  /* _MCF_PGTABLE_H */
 408