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-arm / pgtable.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-08-11  |  12.9 KB  |  382 lines

  1. /*
  2.  *  linux/include/asm-arm/pgtable.h
  3.  *
  4.  *  Copyright (C) 1995-2002 Russell King
  5.  *
  6.  * This program is free software; you can redistribute it and/or modify
  7.  * it under the terms of the GNU General Public License version 2 as
  8.  * published by the Free Software Foundation.
  9.  */
  10. #ifndef _ASMARM_PGTABLE_H
  11. #define _ASMARM_PGTABLE_H
  12.  
  13. #include <asm-generic/4level-fixup.h>
  14.  
  15. #include <asm/memory.h>
  16. #include <asm/proc-fns.h>
  17. #include <asm/arch/vmalloc.h>
  18.  
  19. /*
  20.  * Just any arbitrary offset to the start of the vmalloc VM area: the
  21.  * current 8MB value just means that there will be a 8MB "hole" after the
  22.  * physical memory until the kernel virtual memory starts.  That means that
  23.  * any out-of-bounds memory accesses will hopefully be caught.
  24.  * The vmalloc() routines leaves a hole of 4kB between each vmalloced
  25.  * area for the same reason. ;)
  26.  *
  27.  * Note that platforms may override VMALLOC_START, but they must provide
  28.  * VMALLOC_END.  VMALLOC_END defines the (exclusive) limit of this space,
  29.  * which may not overlap IO space.
  30.  */
  31. #ifndef VMALLOC_START
  32. #define VMALLOC_OFFSET        (8*1024*1024)
  33. #define VMALLOC_START        (((unsigned long)high_memory + VMALLOC_OFFSET) & ~(VMALLOC_OFFSET-1))
  34. #endif
  35.  
  36. /*
  37.  * Hardware-wise, we have a two level page table structure, where the first
  38.  * level has 4096 entries, and the second level has 256 entries.  Each entry
  39.  * is one 32-bit word.  Most of the bits in the second level entry are used
  40.  * by hardware, and there aren't any "accessed" and "dirty" bits.
  41.  *
  42.  * Linux on the other hand has a three level page table structure, which can
  43.  * be wrapped to fit a two level page table structure easily - using the PGD
  44.  * and PTE only.  However, Linux also expects one "PTE" table per page, and
  45.  * at least a "dirty" bit.
  46.  *
  47.  * Therefore, we tweak the implementation slightly - we tell Linux that we
  48.  * have 2048 entries in the first level, each of which is 8 bytes (iow, two
  49.  * hardware pointers to the second level.)  The second level contains two
  50.  * hardware PTE tables arranged contiguously, followed by Linux versions
  51.  * which contain the state information Linux needs.  We, therefore, end up
  52.  * with 512 entries in the "PTE" level.
  53.  *
  54.  * This leads to the page tables having the following layout:
  55.  *
  56.  *    pgd             pte
  57.  * |        |
  58.  * +--------+ +0
  59.  * |        |-----> +------------+ +0
  60.  * +- - - - + +4    |  h/w pt 0  |
  61.  * |        |-----> +------------+ +1024
  62.  * +--------+ +8    |  h/w pt 1  |
  63.  * |        |       +------------+ +2048
  64.  * +- - - - +       | Linux pt 0 |
  65.  * |        |       +------------+ +3072
  66.  * +--------+       | Linux pt 1 |
  67.  * |        |       +------------+ +4096
  68.  *
  69.  * See L_PTE_xxx below for definitions of bits in the "Linux pt", and
  70.  * PTE_xxx for definitions of bits appearing in the "h/w pt".
  71.  *
  72.  * PMD_xxx definitions refer to bits in the first level page table.
  73.  *
  74.  * The "dirty" bit is emulated by only granting hardware write permission
  75.  * iff the page is marked "writable" and "dirty" in the Linux PTE.  This
  76.  * means that a write to a clean page will cause a permission fault, and
  77.  * the Linux MM layer will mark the page dirty via handle_pte_fault().
  78.  * For the hardware to notice the permission change, the TLB entry must
  79.  * be flushed, and ptep_establish() does that for us.
  80.  *
  81.  * The "accessed" or "young" bit is emulated by a similar method; we only
  82.  * allow accesses to the page if the "young" bit is set.  Accesses to the
  83.  * page will cause a fault, and handle_pte_fault() will set the young bit
  84.  * for us as long as the page is marked present in the corresponding Linux
  85.  * PTE entry.  Again, ptep_establish() will ensure that the TLB is up to
  86.  * date.
  87.  *
  88.  * However, when the "young" bit is cleared, we deny access to the page
  89.  * by clearing the hardware PTE.  Currently Linux does not flush the TLB
  90.  * for us in this case, which means the TLB will retain the transation
  91.  * until either the TLB entry is evicted under pressure, or a context
  92.  * switch which changes the user space mapping occurs.
  93.  */
  94. #define PTRS_PER_PTE        512
  95. #define PTRS_PER_PMD        1
  96. #define PTRS_PER_PGD        2048
  97.  
  98. /*
  99.  * PMD_SHIFT determines the size of the area a second-level page table can map
  100.  * PGDIR_SHIFT determines what a third-level page table entry can map
  101.  */
  102. #define PMD_SHIFT        21
  103. #define PGDIR_SHIFT        21
  104.  
  105. #define LIBRARY_TEXT_START    0x0c000000
  106.  
  107. #ifndef __ASSEMBLY__
  108. extern void __pte_error(const char *file, int line, unsigned long val);
  109. extern void __pmd_error(const char *file, int line, unsigned long val);
  110. extern void __pgd_error(const char *file, int line, unsigned long val);
  111.  
  112. #define pte_ERROR(pte)        __pte_error(__FILE__, __LINE__, pte_val(pte))
  113. #define pmd_ERROR(pmd)        __pmd_error(__FILE__, __LINE__, pmd_val(pmd))
  114. #define pgd_ERROR(pgd)        __pgd_error(__FILE__, __LINE__, pgd_val(pgd))
  115. #endif /* !__ASSEMBLY__ */
  116.  
  117. #define PMD_SIZE        (1UL << PMD_SHIFT)
  118. #define PMD_MASK        (~(PMD_SIZE-1))
  119. #define PGDIR_SIZE        (1UL << PGDIR_SHIFT)
  120. #define PGDIR_MASK        (~(PGDIR_SIZE-1))
  121.  
  122. /*
  123.  * This is the lowest virtual address we can permit any user space
  124.  * mapping to be mapped at.  This is particularly important for
  125.  * non-high vector CPUs.
  126.  */
  127. #define FIRST_USER_ADDRESS    PAGE_SIZE
  128.  
  129. #define FIRST_USER_PGD_NR    1
  130. #define USER_PTRS_PER_PGD    ((TASK_SIZE/PGDIR_SIZE) - FIRST_USER_PGD_NR)
  131.  
  132. /*
  133.  * ARMv6 supersection address mask and size definitions.
  134.  */
  135. #define SUPERSECTION_SHIFT    24
  136. #define SUPERSECTION_SIZE    (1UL << SUPERSECTION_SHIFT)
  137. #define SUPERSECTION_MASK    (~(SUPERSECTION_SIZE-1))
  138.  
  139. /*
  140.  * "Linux" PTE definitions.
  141.  *
  142.  * We keep two sets of PTEs - the hardware and the linux version.
  143.  * This allows greater flexibility in the way we map the Linux bits
  144.  * onto the hardware tables, and allows us to have YOUNG and DIRTY
  145.  * bits.
  146.  *
  147.  * The PTE table pointer refers to the hardware entries; the "Linux"
  148.  * entries are stored 1024 bytes below.
  149.  */
  150. #define L_PTE_PRESENT        (1 << 0)
  151. #define L_PTE_FILE        (1 << 1)    /* only when !PRESENT */
  152. #define L_PTE_YOUNG        (1 << 1)
  153. #define L_PTE_BUFFERABLE    (1 << 2)    /* matches PTE */
  154. #define L_PTE_CACHEABLE        (1 << 3)    /* matches PTE */
  155. #define L_PTE_USER        (1 << 4)
  156. #define L_PTE_WRITE        (1 << 5)
  157. #define L_PTE_EXEC        (1 << 6)
  158. #define L_PTE_DIRTY        (1 << 7)
  159. #define L_PTE_COHERENT        (1 << 9)    /* I/O coherent (xsc3) */
  160. #define L_PTE_SHARED        (1 << 10)    /* shared between CPUs (v6) */
  161. #define L_PTE_ASID        (1 << 11)    /* non-global (use ASID, v6) */
  162.  
  163. #ifndef __ASSEMBLY__
  164.  
  165. /*
  166.  * The following macros handle the cache and bufferable bits...
  167.  */
  168. #define _L_PTE_DEFAULT    L_PTE_PRESENT | L_PTE_YOUNG | L_PTE_CACHEABLE | L_PTE_BUFFERABLE
  169. #define _L_PTE_READ    L_PTE_USER | L_PTE_EXEC
  170.  
  171. extern pgprot_t        pgprot_kernel;
  172.  
  173. #define PAGE_NONE       __pgprot(_L_PTE_DEFAULT)
  174. #define PAGE_COPY       __pgprot(_L_PTE_DEFAULT | _L_PTE_READ)
  175. #define PAGE_SHARED     __pgprot(_L_PTE_DEFAULT | _L_PTE_READ | L_PTE_WRITE)
  176. #define PAGE_READONLY   __pgprot(_L_PTE_DEFAULT | _L_PTE_READ)
  177. #define PAGE_KERNEL    pgprot_kernel
  178.  
  179. #endif /* __ASSEMBLY__ */
  180.  
  181. /*
  182.  * The table below defines the page protection levels that we insert into our
  183.  * Linux page table version.  These get translated into the best that the
  184.  * architecture can perform.  Note that on most ARM hardware:
  185.  *  1) We cannot do execute protection
  186.  *  2) If we could do execute protection, then read is implied
  187.  *  3) write implies read permissions
  188.  */
  189. #define __P000  PAGE_NONE
  190. #define __P001  PAGE_READONLY
  191. #define __P010  PAGE_COPY
  192. #define __P011  PAGE_COPY
  193. #define __P100  PAGE_READONLY
  194. #define __P101  PAGE_READONLY
  195. #define __P110  PAGE_COPY
  196. #define __P111  PAGE_COPY
  197.  
  198. #define __S000  PAGE_NONE
  199. #define __S001  PAGE_READONLY
  200. #define __S010  PAGE_SHARED
  201. #define __S011  PAGE_SHARED
  202. #define __S100  PAGE_READONLY
  203. #define __S101  PAGE_READONLY
  204. #define __S110  PAGE_SHARED
  205. #define __S111  PAGE_SHARED
  206.  
  207. #ifndef __ASSEMBLY__
  208. /*
  209.  * ZERO_PAGE is a global shared page that is always zero: used
  210.  * for zero-mapped memory areas etc..
  211.  */
  212. extern struct page *empty_zero_page;
  213. #define ZERO_PAGE(vaddr)    (empty_zero_page)
  214.  
  215. #define pte_pfn(pte)        (pte_val(pte) >> PAGE_SHIFT)
  216. #define pfn_pte(pfn,prot)    (__pte(((pfn) << PAGE_SHIFT) | pgprot_val(prot)))
  217.  
  218. #define pte_none(pte)        (!pte_val(pte))
  219. #define pte_clear(mm,addr,ptep)    set_pte_at((mm),(addr),(ptep), __pte(0))
  220. #define pte_page(pte)        (pfn_to_page(pte_pfn(pte)))
  221. #define pte_offset_kernel(dir,addr)    (pmd_page_kernel(*(dir)) + __pte_index(addr))
  222. #define pte_offset_map(dir,addr)    (pmd_page_kernel(*(dir)) + __pte_index(addr))
  223. #define pte_offset_map_nested(dir,addr)    (pmd_page_kernel(*(dir)) + __pte_index(addr))
  224. #define pte_unmap(pte)        do { } while (0)
  225. #define pte_unmap_nested(pte)    do { } while (0)
  226.  
  227. #define set_pte(ptep, pte)    cpu_set_pte(ptep,pte)
  228. #define set_pte_at(mm,addr,ptep,pteval) set_pte(ptep,pteval)
  229.  
  230. /*
  231.  * The following only work if pte_present() is true.
  232.  * Undefined behaviour if not..
  233.  */
  234. #define pte_present(pte)    (pte_val(pte) & L_PTE_PRESENT)
  235. #define pte_read(pte)        (pte_val(pte) & L_PTE_USER)
  236. #define pte_write(pte)        (pte_val(pte) & L_PTE_WRITE)
  237. #define pte_exec(pte)        (pte_val(pte) & L_PTE_EXEC)
  238. #define pte_dirty(pte)        (pte_val(pte) & L_PTE_DIRTY)
  239. #define pte_young(pte)        (pte_val(pte) & L_PTE_YOUNG)
  240.  
  241. /*
  242.  * The following only works if pte_present() is not true.
  243.  */
  244. #define pte_file(pte)        (pte_val(pte) & L_PTE_FILE)
  245. #define pte_to_pgoff(x)        (pte_val(x) >> 2)
  246. #define pgoff_to_pte(x)        __pte(((x) << 2) | L_PTE_FILE)
  247.  
  248. #define PTE_FILE_MAX_BITS    30
  249.  
  250. #define PTE_BIT_FUNC(fn,op) \
  251. static inline pte_t pte_##fn(pte_t pte) { pte_val(pte) op; return pte; }
  252.  
  253. /*PTE_BIT_FUNC(rdprotect, &= ~L_PTE_USER);*/
  254. /*PTE_BIT_FUNC(mkread,    |= L_PTE_USER);*/
  255. PTE_BIT_FUNC(wrprotect, &= ~L_PTE_WRITE);
  256. PTE_BIT_FUNC(mkwrite,   |= L_PTE_WRITE);
  257. PTE_BIT_FUNC(exprotect, &= ~L_PTE_EXEC);
  258. PTE_BIT_FUNC(mkexec,    |= L_PTE_EXEC);
  259. PTE_BIT_FUNC(mkclean,   &= ~L_PTE_DIRTY);
  260. PTE_BIT_FUNC(mkdirty,   |= L_PTE_DIRTY);
  261. PTE_BIT_FUNC(mkold,     &= ~L_PTE_YOUNG);
  262. PTE_BIT_FUNC(mkyoung,   |= L_PTE_YOUNG);
  263.  
  264. /*
  265.  * Mark the prot value as uncacheable and unbufferable.
  266.  */
  267. #define pgprot_noncached(prot)    __pgprot(pgprot_val(prot) & ~(L_PTE_CACHEABLE | L_PTE_BUFFERABLE))
  268. #define pgprot_writecombine(prot) __pgprot(pgprot_val(prot) & ~L_PTE_CACHEABLE)
  269.  
  270. #define pmd_none(pmd)        (!pmd_val(pmd))
  271. #define pmd_present(pmd)    (pmd_val(pmd))
  272. #define pmd_bad(pmd)        (pmd_val(pmd) & 2)
  273.  
  274. #define copy_pmd(pmdpd,pmdps)        \
  275.     do {                \
  276.         pmdpd[0] = pmdps[0];    \
  277.         pmdpd[1] = pmdps[1];    \
  278.         flush_pmd_entry(pmdpd);    \
  279.     } while (0)
  280.  
  281. #define pmd_clear(pmdp)            \
  282.     do {                \
  283.         pmdp[0] = __pmd(0);    \
  284.         pmdp[1] = __pmd(0);    \
  285.         clean_pmd_entry(pmdp);    \
  286.     } while (0)
  287.  
  288. static inline pte_t *pmd_page_kernel(pmd_t pmd)
  289. {
  290.     unsigned long ptr;
  291.  
  292.     ptr = pmd_val(pmd) & ~(PTRS_PER_PTE * sizeof(void *) - 1);
  293.     ptr += PTRS_PER_PTE * sizeof(void *);
  294.  
  295.     return __va(ptr);
  296. }
  297.  
  298. #define pmd_page(pmd) virt_to_page(__va(pmd_val(pmd)))
  299.  
  300. /*
  301.  * Permanent address of a page. We never have highmem, so this is trivial.
  302.  */
  303. #define pages_to_mb(x)        ((x) >> (20 - PAGE_SHIFT))
  304.  
  305. /*
  306.  * Conversion functions: convert a page and protection to a page entry,
  307.  * and a page entry and page directory to the page they refer to.
  308.  */
  309. #define mk_pte(page,prot)    pfn_pte(page_to_pfn(page),prot)
  310.  
  311. /*
  312.  * The "pgd_xxx()" functions here are trivial for a folded two-level
  313.  * setup: the pgd is never bad, and a pmd always exists (as it's folded
  314.  * into the pgd entry)
  315.  */
  316. #define pgd_none(pgd)        (0)
  317. #define pgd_bad(pgd)        (0)
  318. #define pgd_present(pgd)    (1)
  319. #define pgd_clear(pgdp)        do { } while (0)
  320. #define set_pgd(pgd,pgdp)    do { } while (0)
  321.  
  322. /* to find an entry in a page-table-directory */
  323. #define pgd_index(addr)        ((addr) >> PGDIR_SHIFT)
  324.  
  325. #define pgd_offset(mm, addr)    ((mm)->pgd+pgd_index(addr))
  326.  
  327. /* to find an entry in a kernel page-table-directory */
  328. #define pgd_offset_k(addr)    pgd_offset(&init_mm, addr)
  329.  
  330. /* Find an entry in the second-level page table.. */
  331. #define pmd_offset(dir, addr)    ((pmd_t *)(dir))
  332.  
  333. /* Find an entry in the third-level page table.. */
  334. #define __pte_index(addr)    (((addr) >> PAGE_SHIFT) & (PTRS_PER_PTE - 1))
  335.  
  336. static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
  337. {
  338.     const unsigned long mask = L_PTE_EXEC | L_PTE_WRITE | L_PTE_USER;
  339.     pte_val(pte) = (pte_val(pte) & ~mask) | (pgprot_val(newprot) & mask);
  340.     return pte;
  341. }
  342.  
  343. extern pgd_t swapper_pg_dir[PTRS_PER_PGD];
  344.  
  345. /* Encode and decode a swap entry.
  346.  *
  347.  * We support up to 32GB of swap on 4k machines
  348.  */
  349. #define __swp_type(x)        (((x).val >> 2) & 0x7f)
  350. #define __swp_offset(x)        ((x).val >> 9)
  351. #define __swp_entry(type,offset) ((swp_entry_t) { ((type) << 2) | ((offset) << 9) })
  352. #define __pte_to_swp_entry(pte)    ((swp_entry_t) { pte_val(pte) })
  353. #define __swp_entry_to_pte(swp)    ((pte_t) { (swp).val })
  354.  
  355. /* Needs to be defined here and not in linux/mm.h, as it is arch dependent */
  356. /* FIXME: this is not correct */
  357. #define kern_addr_valid(addr)    (1)
  358.  
  359. #include <asm-generic/pgtable.h>
  360.  
  361. /*
  362.  * We provide our own arch_get_unmapped_area to cope with VIPT caches.
  363.  */
  364. #define HAVE_ARCH_UNMAPPED_AREA
  365.  
  366. /*
  367.  * remap a physical page `pfn' of size `size' with page protection `prot'
  368.  * into virtual address `from'
  369.  */
  370. #define io_remap_pfn_range(vma,from,pfn,size,prot) \
  371.         remap_pfn_range(vma, from, pfn, size, prot)
  372.  
  373. #define MK_IOSPACE_PFN(space, pfn)    (pfn)
  374. #define GET_IOSPACE(pfn)        0
  375. #define GET_PFN(pfn)            (pfn)
  376.  
  377. #define pgtable_cache_init() do { } while (0)
  378.  
  379. #endif /* !__ASSEMBLY__ */
  380.  
  381. #endif /* _ASMARM_PGTABLE_H */
  382.