home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / src / linux-headers-2.6.17-6 / include / asm-m68k / sun3_pgtable.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-08-11  |  8.4 KB  |  239 lines
  1. #ifndef _SUN3_PGTABLE_H
  2. #define _SUN3_PGTABLE_H
  3.  
  4. #include <asm/sun3mmu.h>
  5.  
  6. #ifndef __ASSEMBLY__
  7. #include <asm/virtconvert.h>
  8. #include <linux/linkage.h>
  9.  
  10. /*
  11.  * This file contains all the things which change drastically for the sun3
  12.  * pagetable stuff, to avoid making too much of a mess of the generic m68k
  13.  * `pgtable.h'; this should only be included from the generic file. --m
  14.  */
  15.  
  16. /* For virtual address to physical address conversion */
  17. #define VTOP(addr)    __pa(addr)
  18. #define PTOV(addr)    __va(addr)
  19.  
  20.  
  21. #endif    /* !__ASSEMBLY__ */
  22.  
  23. /* These need to be defined for compatibility although the sun3 doesn't use them */
  24. #define _PAGE_NOCACHE030 0x040
  25. #define _CACHEMASK040   (~0x060)
  26. #define _PAGE_NOCACHE_S 0x040
  27.  
  28. /* Page protection values within PTE. */
  29. #define SUN3_PAGE_VALID     (0x80000000)
  30. #define SUN3_PAGE_WRITEABLE (0x40000000)
  31. #define SUN3_PAGE_SYSTEM    (0x20000000)
  32. #define SUN3_PAGE_NOCACHE   (0x10000000)
  33. #define SUN3_PAGE_ACCESSED  (0x02000000)
  34. #define SUN3_PAGE_MODIFIED  (0x01000000)
  35.  
  36.  
  37. /* Externally used page protection values. */
  38. #define _PAGE_PRESENT    (SUN3_PAGE_VALID)
  39. #define _PAGE_ACCESSED    (SUN3_PAGE_ACCESSED)
  40.  
  41. #define PTE_FILE_MAX_BITS 28
  42.  
  43. /* Compound page protection values. */
  44. //todo: work out which ones *should* have SUN3_PAGE_NOCACHE and fix...
  45. // is it just PAGE_KERNEL and PAGE_SHARED?
  46. #define PAGE_NONE    __pgprot(SUN3_PAGE_VALID \
  47.                  | SUN3_PAGE_ACCESSED \
  48.                  | SUN3_PAGE_NOCACHE)
  49. #define PAGE_SHARED    __pgprot(SUN3_PAGE_VALID \
  50.                  | SUN3_PAGE_WRITEABLE \
  51.                  | SUN3_PAGE_ACCESSED \
  52.                  | SUN3_PAGE_NOCACHE)
  53. #define PAGE_COPY    __pgprot(SUN3_PAGE_VALID \
  54.                  | SUN3_PAGE_ACCESSED \
  55.                  | SUN3_PAGE_NOCACHE)
  56. #define PAGE_READONLY    __pgprot(SUN3_PAGE_VALID \
  57.                  | SUN3_PAGE_ACCESSED \
  58.                  | SUN3_PAGE_NOCACHE)
  59. #define PAGE_KERNEL    __pgprot(SUN3_PAGE_VALID \
  60.                  | SUN3_PAGE_WRITEABLE \
  61.                  | SUN3_PAGE_SYSTEM \
  62.                  | SUN3_PAGE_NOCACHE \
  63.                  | SUN3_PAGE_ACCESSED \
  64.                  | SUN3_PAGE_MODIFIED)
  65. #define PAGE_INIT    __pgprot(SUN3_PAGE_VALID \
  66.                  | SUN3_PAGE_WRITEABLE \
  67.                  | SUN3_PAGE_SYSTEM \
  68.                  | SUN3_PAGE_NOCACHE)
  69.  
  70. /*
  71.  * Page protections for initialising protection_map. The sun3 has only two
  72.  * protection settings, valid (implying read and execute) and writeable. These
  73.  * are as close as we can get...
  74.  */
  75. #define __P000    PAGE_NONE
  76. #define __P001    PAGE_READONLY
  77. #define __P010    PAGE_COPY
  78. #define __P011    PAGE_COPY
  79. #define __P100    PAGE_READONLY
  80. #define __P101    PAGE_READONLY
  81. #define __P110    PAGE_COPY
  82. #define __P111    PAGE_COPY
  83.  
  84. #define __S000    PAGE_NONE
  85. #define __S001    PAGE_READONLY
  86. #define __S010    PAGE_SHARED
  87. #define __S011    PAGE_SHARED
  88. #define __S100    PAGE_READONLY
  89. #define __S101    PAGE_READONLY
  90. #define __S110    PAGE_SHARED
  91. #define __S111    PAGE_SHARED
  92.  
  93. /* Use these fake page-protections on PMDs. */
  94. #define SUN3_PMD_VALID    (0x00000001)
  95. #define SUN3_PMD_MASK    (0x0000003F)
  96. #define SUN3_PMD_MAGIC    (0x0000002B)
  97.  
  98. #ifndef __ASSEMBLY__
  99.  
  100. /*
  101.  * Conversion functions: convert a page and protection to a page entry,
  102.  * and a page entry and page directory to the page they refer to.
  103.  */
  104. #define mk_pte(page, pgprot) pfn_pte(page_to_pfn(page), (pgprot))
  105.  
  106. static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
  107. {
  108.     pte_val(pte) = (pte_val(pte) & SUN3_PAGE_CHG_MASK) | pgprot_val(newprot);
  109.     return pte;
  110. }
  111.  
  112. #define pmd_set(pmdp,ptep) do {} while (0)
  113.  
  114. static inline void pgd_set(pgd_t *pgdp, pmd_t *pmdp)
  115. {
  116.     pgd_val(*pgdp) = virt_to_phys(pmdp);
  117. }
  118.  
  119. #define __pte_page(pte) \
  120. ((unsigned long) __va ((pte_val (pte) & SUN3_PAGE_PGNUM_MASK) << PAGE_SHIFT))
  121. #define __pmd_page(pmd) \
  122. ((unsigned long) __va (pmd_val (pmd) & PAGE_MASK))
  123.  
  124. static inline int pte_none (pte_t pte) { return !pte_val (pte); }
  125. static inline int pte_present (pte_t pte) { return pte_val (pte) & SUN3_PAGE_VALID; }
  126. static inline void pte_clear (struct mm_struct *mm, unsigned long addr, pte_t *ptep)
  127. {
  128.     pte_val (*ptep) = 0;
  129. }
  130.  
  131. #define pte_pfn(pte)            (pte_val(pte) & SUN3_PAGE_PGNUM_MASK)
  132. #define pfn_pte(pfn, pgprot) \
  133. ({ pte_t __pte; pte_val(__pte) = pfn | pgprot_val(pgprot); __pte; })
  134.  
  135. #define pte_page(pte)        (mem_map+((__pte_page(pte) - PAGE_OFFSET) >> PAGE_SHIFT))
  136. #define pmd_page(pmd)        (mem_map+((__pmd_page(pmd) - PAGE_OFFSET) >> PAGE_SHIFT))
  137.  
  138.  
  139. static inline int pmd_none2 (pmd_t *pmd) { return !pmd_val (*pmd); }
  140. #define pmd_none(pmd) pmd_none2(&(pmd))
  141. //static inline int pmd_bad (pmd_t pmd) { return (pmd_val (pmd) & SUN3_PMD_MASK) != SUN3_PMD_MAGIC; }
  142. static inline int pmd_bad2 (pmd_t *pmd) { return 0; }
  143. #define pmd_bad(pmd) pmd_bad2(&(pmd))
  144. static inline int pmd_present2 (pmd_t *pmd) { return pmd_val (*pmd) & SUN3_PMD_VALID; }
  145. /* #define pmd_present(pmd) pmd_present2(&(pmd)) */
  146. #define pmd_present(pmd) (!pmd_none2(&(pmd)))
  147. static inline void pmd_clear (pmd_t *pmdp) { pmd_val (*pmdp) = 0; }
  148.  
  149. static inline int pgd_none (pgd_t pgd) { return 0; }
  150. static inline int pgd_bad (pgd_t pgd) { return 0; }
  151. static inline int pgd_present (pgd_t pgd) { return 1; }
  152. static inline void pgd_clear (pgd_t *pgdp) {}
  153.  
  154.  
  155. #define pte_ERROR(e) \
  156.     printk("%s:%d: bad pte %08lx.\n", __FILE__, __LINE__, pte_val(e))
  157. #define pmd_ERROR(e) \
  158.     printk("%s:%d: bad pmd %08lx.\n", __FILE__, __LINE__, pmd_val(e))
  159. #define pgd_ERROR(e) \
  160.     printk("%s:%d: bad pgd %08lx.\n", __FILE__, __LINE__, pgd_val(e))
  161.  
  162.  
  163. /*
  164.  * The following only work if pte_present() is true.
  165.  * Undefined behaviour if not...
  166.  * [we have the full set here even if they don't change from m68k]
  167.  */
  168. static inline int pte_read(pte_t pte)        { return 1; }
  169. static inline int pte_write(pte_t pte)        { return pte_val(pte) & SUN3_PAGE_WRITEABLE; }
  170. static inline int pte_exec(pte_t pte)        { return 1; }
  171. static inline int pte_dirty(pte_t pte)        { return pte_val(pte) & SUN3_PAGE_MODIFIED; }
  172. static inline int pte_young(pte_t pte)        { return pte_val(pte) & SUN3_PAGE_ACCESSED; }
  173. static inline int pte_file(pte_t pte)        { return pte_val(pte) & SUN3_PAGE_ACCESSED; }
  174.  
  175. static inline pte_t pte_wrprotect(pte_t pte)    { pte_val(pte) &= ~SUN3_PAGE_WRITEABLE; return pte; }
  176. static inline pte_t pte_rdprotect(pte_t pte)    { return pte; }
  177. static inline pte_t pte_exprotect(pte_t pte)    { return pte; }
  178. static inline pte_t pte_mkclean(pte_t pte)    { pte_val(pte) &= ~SUN3_PAGE_MODIFIED; return pte; }
  179. static inline pte_t pte_mkold(pte_t pte)    { pte_val(pte) &= ~SUN3_PAGE_ACCESSED; return pte; }
  180. static inline pte_t pte_mkwrite(pte_t pte)    { pte_val(pte) |= SUN3_PAGE_WRITEABLE; return pte; }
  181. static inline pte_t pte_mkread(pte_t pte)    { return pte; }
  182. static inline pte_t pte_mkexec(pte_t pte)    { return pte; }
  183. static inline pte_t pte_mkdirty(pte_t pte)    { pte_val(pte) |= SUN3_PAGE_MODIFIED; return pte; }
  184. static inline pte_t pte_mkyoung(pte_t pte)    { pte_val(pte) |= SUN3_PAGE_ACCESSED; return pte; }
  185. static inline pte_t pte_mknocache(pte_t pte)    { pte_val(pte) |= SUN3_PAGE_NOCACHE; return pte; }
  186. // use this version when caches work...
  187. //static inline pte_t pte_mkcache(pte_t pte)    { pte_val(pte) &= SUN3_PAGE_NOCACHE; return pte; }
  188. // until then, use:
  189. static inline pte_t pte_mkcache(pte_t pte)    { return pte; }
  190.  
  191. extern pgd_t swapper_pg_dir[PTRS_PER_PGD];
  192. extern pgd_t kernel_pg_dir[PTRS_PER_PGD];
  193.  
  194. /* Find an entry in a pagetable directory. */
  195. #define pgd_index(address)     ((address) >> PGDIR_SHIFT)
  196.  
  197. #define pgd_offset(mm, address) \
  198. ((mm)->pgd + pgd_index(address))
  199.  
  200. /* Find an entry in a kernel pagetable directory. */
  201. #define pgd_offset_k(address) pgd_offset(&init_mm, address)
  202.  
  203. /* Find an entry in the second-level pagetable. */
  204. static inline pmd_t *pmd_offset (pgd_t *pgd, unsigned long address)
  205. {
  206.     return (pmd_t *) pgd;
  207. }
  208.  
  209. static inline unsigned long pte_to_pgoff(pte_t pte)
  210. {
  211.     return pte.pte & SUN3_PAGE_PGNUM_MASK;
  212. }
  213.  
  214. static inline pte_t pgoff_to_pte(unsigned off)
  215. {
  216.     pte_t pte = { off + SUN3_PAGE_ACCESSED };
  217.     return pte;
  218. }
  219.  
  220.  
  221. /* Find an entry in the third-level pagetable. */
  222. #define pte_index(address) ((address >> PAGE_SHIFT) & (PTRS_PER_PTE-1))
  223. #define pte_offset_kernel(pmd, address) ((pte_t *) __pmd_page(*pmd) + pte_index(address))
  224. /* FIXME: should we bother with kmap() here? */
  225. #define pte_offset_map(pmd, address) ((pte_t *)kmap(pmd_page(*pmd)) + pte_index(address))
  226. #define pte_offset_map_nested(pmd, address) pte_offset_map(pmd, address)
  227. #define pte_unmap(pte) kunmap(pte)
  228. #define pte_unmap_nested(pte) kunmap(pte)
  229.  
  230. /* Macros to (de)construct the fake PTEs representing swap pages. */
  231. #define __swp_type(x)        ((x).val & 0x7F)
  232. #define __swp_offset(x)        (((x).val) >> 7)
  233. #define __swp_entry(type,offset) ((swp_entry_t) { ((type) | ((offset) << 7)) })
  234. #define __pte_to_swp_entry(pte)    ((swp_entry_t) { pte_val(pte) })
  235. #define __swp_entry_to_pte(x)    ((pte_t) { (x).val })
  236.  
  237. #endif    /* !__ASSEMBLY__ */
  238. #endif    /* !_SUN3_PGTABLE_H */
  239.