arch/sparc/include/asm/pgtable_32.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef _SPARC_PGTABLE_H
   3 #define _SPARC_PGTABLE_H
   4
   5 /*  asm/pgtable.h:  Defines and functions used to work
   6  *                        with Sparc page tables.
   7  *
   8  *  Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
   9  *  Copyright (C) 1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
  10  */
  11
  12 #include <linux/const.h>
  13
  14 #define PMD_SHIFT               18
  15 #define PMD_SIZE                (1UL << PMD_SHIFT)
  16 #define PMD_MASK                (~(PMD_SIZE-1))
  17 #define PMD_ALIGN(__addr)       (((__addr) + ~PMD_MASK) & PMD_MASK)
  18
  19 #define PGDIR_SHIFT             24
  20 #define PGDIR_SIZE              (1UL << PGDIR_SHIFT)
  21 #define PGDIR_MASK              (~(PGDIR_SIZE-1))
  22 #define PGDIR_ALIGN(__addr)     (((__addr) + ~PGDIR_MASK) & PGDIR_MASK)
  23
  24 #ifndef __ASSEMBLY__
  25 #include <asm-generic/pgtable-nopud.h>
  26
  27 #include <linux/spinlock.h>
  28 #include <linux/mm_types.h>
  29 #include <asm/types.h>
  30 #include <asm/pgtsrmmu.h>
  31 #include <asm/vaddrs.h>
  32 #include <asm/oplib.h>
  33 #include <asm/cpu_type.h>
  34
  35
  36 struct vm_area_struct;
  37 struct page;
  38
  39 void load_mmu(void);
  40 unsigned long calc_highpages(void);
  41 unsigned long __init bootmem_init(unsigned long *pages_avail);
  42
  43 #define pte_ERROR(e)   __builtin_trap()
  44 #define pmd_ERROR(e)   __builtin_trap()
  45 #define pgd_ERROR(e)   __builtin_trap()
  46
  47 #define PTRS_PER_PTE            64
  48 #define PTRS_PER_PMD            64
  49 #define PTRS_PER_PGD            256
  50 #define USER_PTRS_PER_PGD       PAGE_OFFSET / PGDIR_SIZE
  51 #define FIRST_USER_ADDRESS      0UL
  52 #define PTE_SIZE                (PTRS_PER_PTE*4)
  53
  54 #define PAGE_NONE       SRMMU_PAGE_NONE
  55 #define PAGE_SHARED     SRMMU_PAGE_SHARED
  56 #define PAGE_COPY       SRMMU_PAGE_COPY
  57 #define PAGE_READONLY   SRMMU_PAGE_RDONLY
  58 #define PAGE_KERNEL     SRMMU_PAGE_KERNEL
  59
  60 /* Top-level page directory - dummy used by init-mm.
  61  * srmmu.c will assign the real one (which is dynamically sized) */
  62 #define swapper_pg_dir NULL
  63
  64 void paging_init(void);
  65
  66 extern unsigned long ptr_in_current_pgd;
  67
  68 /*         xwr */
  69 #define __P000  PAGE_NONE
  70 #define __P001  PAGE_READONLY
  71 #define __P010  PAGE_COPY
  72 #define __P011  PAGE_COPY
  73 #define __P100  PAGE_READONLY
  74 #define __P101  PAGE_READONLY
  75 #define __P110  PAGE_COPY
  76 #define __P111  PAGE_COPY
  77
  78 #define __S000  PAGE_NONE
  79 #define __S001  PAGE_READONLY
  80 #define __S010  PAGE_SHARED
  81 #define __S011  PAGE_SHARED
  82 #define __S100  PAGE_READONLY
  83 #define __S101  PAGE_READONLY
  84 #define __S110  PAGE_SHARED
  85 #define __S111  PAGE_SHARED
  86
  87 /* First physical page can be anywhere, the following is needed so that
  88  * va-->pa and vice versa conversions work properly without performance
  89  * hit for all __pa()/__va() operations.
  90  */
  91 extern unsigned long phys_base;
  92 extern unsigned long pfn_base;
  93
  94 /*
  95  * ZERO_PAGE is a global shared page that is always zero: used
  96  * for zero-mapped memory areas etc..
  97  */
  98 extern unsigned long empty_zero_page[PAGE_SIZE / sizeof(unsigned long)];
  99
 100 #define ZERO_PAGE(vaddr) (virt_to_page(empty_zero_page))
 101
 102 /*
 103  * In general all page table modifications should use the V8 atomic
 104  * swap instruction.  This insures the mmu and the cpu are in sync
 105  * with respect to ref/mod bits in the page tables.
 106  */
 107 static inline unsigned long srmmu_swap(unsigned long *addr, unsigned long value)
 108 {
 109         __asm__ __volatile__("swap [%2], %0" :
 110                         "=&r" (value) : "0" (value), "r" (addr) : "memory");
 111         return value;
 112 }
 113
 114 /* Certain architectures need to do special things when pte's
 115  * within a page table are directly modified.  Thus, the following
 116  * hook is made available.
 117  */
 118
 119 static inline void set_pte(pte_t *ptep, pte_t pteval)
 120 {
 121         srmmu_swap((unsigned long *)ptep, pte_val(pteval));
 122 }
 123
 124 #define set_pte_at(mm,addr,ptep,pteval) set_pte(ptep,pteval)
 125
 126 static inline int srmmu_device_memory(unsigned long x)
 127 {
 128         return ((x & 0xF0000000) != 0);
 129 }
 130
 131 static inline struct page *pmd_page(pmd_t pmd)
 132 {
 133         if (srmmu_device_memory(pmd_val(pmd)))
 134                 BUG();
 135         return pfn_to_page((pmd_val(pmd) & SRMMU_PTD_PMASK) >> (PAGE_SHIFT-4));
 136 }
 137
 138 static inline unsigned long __pmd_page(pmd_t pmd)
 139 {
 140         unsigned long v;
 141
 142         if (srmmu_device_memory(pmd_val(pmd)))
 143                 BUG();
 144
 145         v = pmd_val(pmd) & SRMMU_PTD_PMASK;
 146         return (unsigned long)__nocache_va(v << 4);
 147 }
 148
 149 static inline unsigned long pud_page_vaddr(pud_t pud)
 150 {
 151         if (srmmu_device_memory(pud_val(pud))) {
 152                 return ~0;
 153         } else {
 154                 unsigned long v = pud_val(pud) & SRMMU_PTD_PMASK;
 155                 return (unsigned long)__nocache_va(v << 4);
 156         }
 157 }
 158
 159 static inline int pte_present(pte_t pte)
 160 {
 161         return ((pte_val(pte) & SRMMU_ET_MASK) == SRMMU_ET_PTE);
 162 }
 163
 164 static inline int pte_none(pte_t pte)
 165 {
 166         return !pte_val(pte);
 167 }
 168
 169 static inline void __pte_clear(pte_t *ptep)
 170 {
 171         set_pte(ptep, __pte(0));
 172 }
 173
 174 static inline void pte_clear(struct mm_struct *mm, unsigned long addr, pte_t *ptep)
 175 {
 176         __pte_clear(ptep);
 177 }
 178
 179 static inline int pmd_bad(pmd_t pmd)
 180 {
 181         return (pmd_val(pmd) & SRMMU_ET_MASK) != SRMMU_ET_PTD;
 182 }
 183
 184 static inline int pmd_present(pmd_t pmd)
 185 {
 186         return ((pmd_val(pmd) & SRMMU_ET_MASK) == SRMMU_ET_PTD);
 187 }
 188
 189 static inline int pmd_none(pmd_t pmd)
 190 {
 191         return !pmd_val(pmd);
 192 }
 193
 194 static inline void pmd_clear(pmd_t *pmdp)
 195 {
 196         set_pte((pte_t *)&pmd_val(*pmdp), __pte(0));
 197 }
 198
 199 static inline int pud_none(pud_t pud)
 200 {
 201         return !(pud_val(pud) & 0xFFFFFFF);
 202 }
 203
 204 static inline int pud_bad(pud_t pud)
 205 {
 206         return (pud_val(pud) & SRMMU_ET_MASK) != SRMMU_ET_PTD;
 207 }
 208
 209 static inline int pud_present(pud_t pud)
 210 {
 211         return ((pud_val(pud) & SRMMU_ET_MASK) == SRMMU_ET_PTD);
 212 }
 213
 214 static inline void pud_clear(pud_t *pudp)
 215 {
 216         set_pte((pte_t *)pudp, __pte(0));
 217 }
 218
 219 /*
 220  * The following only work if pte_present() is true.
 221  * Undefined behaviour if not..
 222  */
 223 static inline int pte_write(pte_t pte)
 224 {
 225         return pte_val(pte) & SRMMU_WRITE;
 226 }
 227
 228 static inline int pte_dirty(pte_t pte)
 229 {
 230         return pte_val(pte) & SRMMU_DIRTY;
 231 }
 232
 233 static inline int pte_young(pte_t pte)
 234 {
 235         return pte_val(pte) & SRMMU_REF;
 236 }
 237
 238 static inline pte_t pte_wrprotect(pte_t pte)
 239 {
 240         return __pte(pte_val(pte) & ~SRMMU_WRITE);
 241 }
 242
 243 static inline pte_t pte_mkclean(pte_t pte)
 244 {
 245         return __pte(pte_val(pte) & ~SRMMU_DIRTY);
 246 }
 247
 248 static inline pte_t pte_mkold(pte_t pte)
 249 {
 250         return __pte(pte_val(pte) & ~SRMMU_REF);
 251 }
 252
 253 static inline pte_t pte_mkwrite(pte_t pte)
 254 {
 255         return __pte(pte_val(pte) | SRMMU_WRITE);
 256 }
 257
 258 static inline pte_t pte_mkdirty(pte_t pte)
 259 {
 260         return __pte(pte_val(pte) | SRMMU_DIRTY);
 261 }
 262
 263 static inline pte_t pte_mkyoung(pte_t pte)
 264 {
 265         return __pte(pte_val(pte) | SRMMU_REF);
 266 }
 267
 268 #define pfn_pte(pfn, prot)              mk_pte(pfn_to_page(pfn), prot)
 269
 270 static inline unsigned long pte_pfn(pte_t pte)
 271 {
 272         if (srmmu_device_memory(pte_val(pte))) {
 273                 /* Just return something that will cause
 274                  * pfn_valid() to return false.  This makes
 275                  * copy_one_pte() to just directly copy to
 276                  * PTE over.
 277                  */
 278                 return ~0UL;
 279         }
 280         return (pte_val(pte) & SRMMU_PTE_PMASK) >> (PAGE_SHIFT-4);
 281 }
 282
 283 #define pte_page(pte)   pfn_to_page(pte_pfn(pte))
 284
 285 /*
 286  * Conversion functions: convert a page and protection to a page entry,
 287  * and a page entry and page directory to the page they refer to.
 288  */
 289 static inline pte_t mk_pte(struct page *page, pgprot_t pgprot)
 290 {
 291         return __pte((page_to_pfn(page) << (PAGE_SHIFT-4)) | pgprot_val(pgprot));
 292 }
 293
 294 static inline pte_t mk_pte_phys(unsigned long page, pgprot_t pgprot)
 295 {
 296         return __pte(((page) >> 4) | pgprot_val(pgprot));
 297 }
 298
 299 static inline pte_t mk_pte_io(unsigned long page, pgprot_t pgprot, int space)
 300 {
 301         return __pte(((page) >> 4) | (space << 28) | pgprot_val(pgprot));
 302 }
 303
 304 #define pgprot_noncached pgprot_noncached
 305 static inline pgprot_t pgprot_noncached(pgprot_t prot)
 306 {
 307         pgprot_val(prot) &= ~pgprot_val(__pgprot(SRMMU_CACHE));
 308         return prot;
 309 }
 310
 311 static pte_t pte_modify(pte_t pte, pgprot_t newprot) __attribute_const__;
 312 static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
 313 {
 314         return __pte((pte_val(pte) & SRMMU_CHG_MASK) |
 315                 pgprot_val(newprot));
 316 }
 317
 318 #define pgd_index(address) ((address) >> PGDIR_SHIFT)
 319
 320 /* to find an entry in a page-table-directory */
 321 #define pgd_offset(mm, address) ((mm)->pgd + pgd_index(address))
 322
 323 /* to find an entry in a kernel page-table-directory */
 324 #define pgd_offset_k(address) pgd_offset(&init_mm, address)
 325
 326 /* Find an entry in the second-level page table.. */
 327 static inline pmd_t *pmd_offset(pud_t * dir, unsigned long address)
 328 {
 329         return (pmd_t *) pud_page_vaddr(*dir) +
 330                 ((address >> PMD_SHIFT) & (PTRS_PER_PMD - 1));
 331 }
 332
 333 /* Find an entry in the third-level page table.. */
 334 pte_t *pte_offset_kernel(pmd_t * dir, unsigned long address);
 335
 336 /*
 337  * This shortcut works on sun4m (and sun4d) because the nocache area is static.
 338  */
 339 #define pte_offset_map(d, a)            pte_offset_kernel(d,a)
 340 #define pte_unmap(pte)          do{}while(0)
 341
 342 struct seq_file;
 343 void mmu_info(struct seq_file *m);
 344
 345 /* Fault handler stuff... */
 346 #define FAULT_CODE_PROT     0x1
 347 #define FAULT_CODE_WRITE    0x2
 348 #define FAULT_CODE_USER     0x4
 349
 350 #define update_mmu_cache(vma, address, ptep) do { } while (0)
 351
 352 void srmmu_mapiorange(unsigned int bus, unsigned long xpa,
 353                       unsigned long xva, unsigned int len);
 354 void srmmu_unmapiorange(unsigned long virt_addr, unsigned int len);
 355
 356 /* Encode and de-code a swap entry */
 357 static inline unsigned long __swp_type(swp_entry_t entry)
 358 {
 359         return (entry.val >> SRMMU_SWP_TYPE_SHIFT) & SRMMU_SWP_TYPE_MASK;
 360 }
 361
 362 static inline unsigned long __swp_offset(swp_entry_t entry)
 363 {
 364         return (entry.val >> SRMMU_SWP_OFF_SHIFT) & SRMMU_SWP_OFF_MASK;
 365 }
 366
 367 static inline swp_entry_t __swp_entry(unsigned long type, unsigned long offset)
 368 {
 369         return (swp_entry_t) {
 370                 (type & SRMMU_SWP_TYPE_MASK) << SRMMU_SWP_TYPE_SHIFT
 371                 | (offset & SRMMU_SWP_OFF_MASK) << SRMMU_SWP_OFF_SHIFT };
 372 }
 373
 374 #define __pte_to_swp_entry(pte)         ((swp_entry_t) { pte_val(pte) })
 375 #define __swp_entry_to_pte(x)           ((pte_t) { (x).val })
 376
 377 static inline unsigned long
 378 __get_phys (unsigned long addr)
 379 {
 380         switch (sparc_cpu_model){
 381         case sun4m:
 382         case sun4d:
 383                 return ((srmmu_get_pte (addr) & 0xffffff00) << 4);
 384         default:
 385                 return 0;
 386         }
 387 }
 388
 389 static inline int
 390 __get_iospace (unsigned long addr)
 391 {
 392         switch (sparc_cpu_model){
 393         case sun4m:
 394         case sun4d:
 395                 return (srmmu_get_pte (addr) >> 28);
 396         default:
 397                 return -1;
 398         }
 399 }
 400
 401 extern unsigned long *sparc_valid_addr_bitmap;
 402
 403 /* Needs to be defined here and not in linux/mm.h, as it is arch dependent */
 404 #define kern_addr_valid(addr) \
 405         (test_bit(__pa((unsigned long)(addr))>>20, sparc_valid_addr_bitmap))
 406
 407 /*
 408  * For sparc32&64, the pfn in io_remap_pfn_range() carries <iospace> in
 409  * its high 4 bits.  These macros/functions put it there or get it from there.
 410  */
 411 #define MK_IOSPACE_PFN(space, pfn)      (pfn | (space << (BITS_PER_LONG - 4)))
 412 #define GET_IOSPACE(pfn)                (pfn >> (BITS_PER_LONG - 4))
 413 #define GET_PFN(pfn)                    (pfn & 0x0fffffffUL)
 414
 415 int remap_pfn_range(struct vm_area_struct *, unsigned long, unsigned long,
 416                     unsigned long, pgprot_t);
 417
 418 static inline int io_remap_pfn_range(struct vm_area_struct *vma,
 419                                      unsigned long from, unsigned long pfn,
 420                                      unsigned long size, pgprot_t prot)
 421 {
 422         unsigned long long offset, space, phys_base;
 423
 424         offset = ((unsigned long long) GET_PFN(pfn)) << PAGE_SHIFT;
 425         space = GET_IOSPACE(pfn);
 426         phys_base = offset | (space << 32ULL);
 427
 428         return remap_pfn_range(vma, from, phys_base >> PAGE_SHIFT, size, prot);
 429 }
 430 #define io_remap_pfn_range io_remap_pfn_range
 431
 432 #define __HAVE_ARCH_PTEP_SET_ACCESS_FLAGS
 433 #define ptep_set_access_flags(__vma, __address, __ptep, __entry, __dirty) \
 434 ({                                                                        \
 435         int __changed = !pte_same(*(__ptep), __entry);                    \
 436         if (__changed) {                                                  \
 437                 set_pte_at((__vma)->vm_mm, (__address), __ptep, __entry); \
 438                 flush_tlb_page(__vma, __address);                         \
 439         }                                                                 \
 440         __changed;                                                        \
 441 })
 442
 443 #include <asm-generic/pgtable.h>
 444
 445 #endif /* !(__ASSEMBLY__) */
 446
 447 #define VMALLOC_START           _AC(0xfe600000,UL)
 448 #define VMALLOC_END             _AC(0xffc00000,UL)
 449
 450 /* We provide our own get_unmapped_area to cope with VA holes for userland */
 451 #define HAVE_ARCH_UNMAPPED_AREA
 452
 453 #endif /* !(_SPARC_PGTABLE_H) */