[BACK]Return to pmap.h CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sys / arch / arm / include / arm32

Annotation of src/sys/arch/arm/include/arm32/pmap.h, Revision 1.4

1.4     ! matt        1: /*     $NetBSD: pmap.h,v 1.3 2001/03/04 07:30:20 matt Exp $    */
1.1       reinoud     2:
                      3: /*
                      4:  * Copyright (c) 1994,1995 Mark Brinicombe.
                      5:  * All rights reserved.
                      6:  *
                      7:  * Redistribution and use in source and binary forms, with or without
                      8:  * modification, are permitted provided that the following conditions
                      9:  * are met:
                     10:  * 1. Redistributions of source code must retain the above copyright
                     11:  *    notice, this list of conditions and the following disclaimer.
                     12:  * 2. Redistributions in binary form must reproduce the above copyright
                     13:  *    notice, this list of conditions and the following disclaimer in the
                     14:  *    documentation and/or other materials provided with the distribution.
                     15:  * 3. All advertising materials mentioning features or use of this software
                     16:  *    must display the following acknowledgement:
                     17:  *     This product includes software developed by Mark Brinicombe
                     18:  * 4. The name of the author may not be used to endorse or promote products
                     19:  *    derived from this software without specific prior written permission.
                     20:  *
                     21:  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
                     22:  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
                     23:  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
                     24:  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
                     25:  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
                     26:  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
                     27:  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
                     28:  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
                     29:  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
                     30:  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
                     31:  */
                     32:
                     33: #ifndef        _ARM32_PMAP_H_
                     34: #define        _ARM32_PMAP_H_
                     35:
                     36: #include <machine/cpufunc.h>
                     37: #include <machine/pte.h>
                     38:
                     39: /*
                     40:  * Data structures used by pmap
                     41:  */
                     42:
                     43: /*
                     44:  * Structure that describes a Level 1 page table and the flags
                     45:  * associated with it.
                     46:  */
                     47: struct l1pt {
                     48:        SIMPLEQ_ENTRY(l1pt)     pt_queue;       /* Queue pointers */
                     49:        struct pglist           pt_plist;       /* Allocated page list */
1.2       matt       50:        vaddr_t                 pt_va;          /* Allocated virtual address */
1.1       reinoud    51:        int                     pt_flags;       /* Flags */
                     52: };
                     53: #define        PTFLAG_STATIC           1               /* Statically allocated */
                     54: #define PTFLAG_KPT             2               /* Kernel pt's are mapped */
                     55: #define PTFLAG_CLEAN           4               /* L1 is clean */
                     56:
                     57: /*
                     58:  * The pmap structure itself.
                     59:  */
                     60: struct pmap {
                     61:        pd_entry_t              *pm_pdir;       /* KVA of page directory */
                     62:        struct l1pt             *pm_l1pt;       /* L1 descriptor */
                     63:        void                    *pm_unused1;    /* Reserved for l2 map */
1.3       matt       64:        paddr_t                 pm_pptpt;       /* PA of pt's page table */
1.2       matt       65:        vaddr_t                 pm_vptpt;       /* VA of pt's page table */
1.1       reinoud    66:        short                   pm_dref;        /* page directory ref count */
                     67:        short                   pm_count;       /* pmap reference count */
                     68:        simple_lock_data_t      pm_lock;        /* lock on pmap */
                     69:        struct pmap_statistics  pm_stats;       /* pmap statistics */
                     70: };
                     71:
                     72: typedef struct pmap *pmap_t;
                     73:
                     74: /*
                     75:  * For each vm_page_t, there is a list of all currently valid virtual
                     76:  * mappings of that page.  An entry is a pv_entry_t, the list is pv_table.
                     77:  */
                     78: typedef struct pv_entry {
                     79:        struct pv_entry *pv_next;       /* next pv_entry */
                     80:        pmap_t          pv_pmap;        /* pmap where mapping lies */
1.2       matt       81:        vaddr_t         pv_va;          /* virtual address for mapping */
1.1       reinoud    82:        int             pv_flags;       /* flags */
                     83: } *pv_entry_t;
                     84:
                     85: /*
                     86:  * A pv_page_info struture looks like this. It is used to contain status
                     87:  * information for pv_entry freelists.
                     88:  */
                     89: struct pv_page;
                     90:
                     91: struct pv_page_info {
                     92:        TAILQ_ENTRY(pv_page) pgi_list;
                     93:        struct pv_entry *pgi_freelist;
                     94:        int pgi_nfree;
                     95: };
                     96:
                     97: /*
                     98:  * A pv_page itself looks like this. pv_entries are requested from the VM a
                     99:  * pv_page at a time.
                    100:  *
                    101:  * We also define a macro that states the number of pv_entries per page
                    102:  * allocated.
                    103:  */
                    104: #define NPVPPG ((NBPG - sizeof(struct pv_page_info)) / sizeof(struct pv_entry))
                    105:
                    106: struct pv_page {
                    107:        struct pv_page_info pvp_pgi;
                    108:        struct pv_entry pvp_pv[NPVPPG];
                    109: };
                    110:
                    111: /*
                    112:  * Page hooks. I'll eliminate these sometime soon :-)
                    113:  *
                    114:  * For speed we store the both the virtual address and the page table
                    115:  * entry address for each page hook.
                    116:  */
                    117: typedef struct {
1.2       matt      118:         vaddr_t va;
1.1       reinoud   119:         pt_entry_t *pte;
                    120: } pagehook_t;
                    121:
                    122: /*
                    123:  * Physical / virtual address structure. In a number of places (particularly
                    124:  * during bootstrapping) we need to keep track of the physical and virtual
                    125:  * addresses of various pages
                    126:  */
                    127: typedef struct {
1.3       matt      128:        paddr_t pv_pa;
1.2       matt      129:        vaddr_t pv_va;
1.1       reinoud   130: } pv_addr_t;
                    131:
                    132: /*
                    133:  * _KERNEL specific macros, functions and prototypes
                    134:  */
                    135:
                    136: #ifdef  _KERNEL
                    137:
                    138: /*
                    139:  * Commonly referenced structures
                    140:  */
                    141: extern pv_entry_t      pv_table;       /* Phys to virt mappings, per page. */
                    142: extern pmap_t          kernel_pmap;    /* pmap pointer used for the kernel */
                    143: extern struct pmap     kernel_pmap_store;  /* kernel_pmap points to this */
1.4     ! matt      144: extern int             pmap_debug_level; /* Only exists if PMAP_DEBUG */
1.1       reinoud   145:
                    146: /*
                    147:  * Macros that we need to export
                    148:  */
                    149: #define pmap_kernel()                  (&kernel_pmap_store)
                    150: #define pmap_update()                  /*cpu_tlb_flushID()*/
                    151: #define        pmap_resident_count(pmap)       ((pmap)->pm_stats.resident_count)
                    152: #define        pmap_wired_count(pmap)          ((pmap)->pm_stats.wired_count)
                    153:
                    154: #define pmap_phys_address(ppn)         (arm_page_to_byte((ppn)))
                    155:
                    156: /*
                    157:  * Functions that we need to export
                    158:  */
1.3       matt      159: extern boolean_t pmap_testbit __P((paddr_t, int));
                    160: extern void pmap_changebit __P((paddr_t, int, int));
1.2       matt      161: extern vaddr_t pmap_map __P((vaddr_t, vaddr_t, vaddr_t, int));
1.4     ! matt      162: extern void pmap_procwr __P((struct proc *, vaddr_t, int));
1.1       reinoud   163: #define        PMAP_NEED_PROCWR
1.4     ! matt      164:
        !           165: /*
        !           166:  * Functions we use internally
        !           167:  */
        !           168: extern void pmap_bootstrap __P((pd_entry_t *, pv_addr_t));
        !           169: extern void pmap_debug __P((int));
        !           170: extern int pmap_handled_emulation __P((pmap_t, vaddr_t));
        !           171: extern int pmap_modified_emulation __P((pmap_t, vaddr_t));
        !           172: extern void pmap_postinit __P((void));
        !           173: extern pt_entry_t *pmap_pte __P((pmap_t, vaddr_t));
1.1       reinoud   174:
                    175: #endif /* _KERNEL */
                    176:
                    177: /*
                    178:  * Useful macros and constants
                    179:  */
                    180:
                    181: /* Virtual address to page table entry */
                    182: #define vtopte(va) \
                    183:        ((pt_entry_t *)(PROCESS_PAGE_TBLS_BASE + \
                    184:        (arm_byte_to_page((unsigned int)(va)) << 2)))
                    185:
                    186: /* Virtual address to physical address */
                    187: #define vtophys(va) \
                    188:        ((*vtopte(va) & PG_FRAME) | ((unsigned int)(va) & ~PG_FRAME))
                    189:
                    190: /* L1 and L2 page table macros */
1.2       matt      191: #define pmap_pde(m, v) (&((m)->pm_pdir[((vaddr_t)(v) >> PDSHIFT)&4095]))
1.1       reinoud   192: #define pmap_pte_pa(pte)       (*(pte) & PG_FRAME)
                    193: #define pmap_pde_v(pde)                (*(pde) != 0)
                    194: #define pmap_pte_v(pte)                (*(pte) != 0)
                    195:
                    196: /* Size of the kernel part of the L1 page table */
                    197: #define KERNEL_PD_SIZE \
                    198:        (PD_SIZE - (KERNEL_SPACE_START >> PDSHIFT) * sizeof(pd_entry_t))
                    199:
                    200: #endif /* _ARM32_PMAP_H_ */

CVSweb <webmaster@jp.NetBSD.org>