arch/m68k/include/asm/mcf_pgtable.h

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