/*-
* Copyright 2014 Svatopluk Kraus <onwahe@gmail.com>
* Copyright 2014 Michal Meloun <meloun@miracle.cz>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $FreeBSD$
*/
#ifndef _MACHINE_PMAP_VAR_H_
#define _MACHINE_PMAP_VAR_H_
#include <machine/cpu-v6.h>
#include <machine/pte-v6.h>
/*
* Various PMAP defines, exports, and inline functions
* definitions also usable in other MD code.
*/
/* A number of pages in L1 page table. */
#define NPG_IN_PT1 (NB_IN_PT1 / PAGE_SIZE)
/* A number of L2 page tables in a page. */
#define NPT2_IN_PG (PAGE_SIZE / NB_IN_PT2)
/* A number of L2 page table entries in a page. */
#define NPTE2_IN_PG (NPT2_IN_PG * NPTE2_IN_PT2)
#ifdef _KERNEL
/*
* A L2 page tables page contains NPT2_IN_PG L2 page tables. Masking of
* pte1_idx by PT2PG_MASK gives us an index to associated L2 page table
* in a page. The PT2PG_SHIFT definition depends on NPT2_IN_PG strictly.
* I.e., (1 << PT2PG_SHIFT) == NPT2_IN_PG must be fulfilled.
*/
#define PT2PG_SHIFT 2
#define PT2PG_MASK ((1 << PT2PG_SHIFT) - 1)
/*
* A PT2TAB holds all allocated L2 page table pages in a pmap.
* Right shifting of virtual address by PT2TAB_SHIFT gives us an index
* to L2 page table page in PT2TAB which holds the address mapping.
*/
#define PT2TAB_ENTRIES (NPTE1_IN_PT1 / NPT2_IN_PG)
#define PT2TAB_SHIFT (PTE1_SHIFT + PT2PG_SHIFT)
/*
* All allocated L2 page table pages in a pmap are mapped into PT2MAP space.
* An virtual address right shifting by PT2MAP_SHIFT gives us an index to PTE2
* which maps the address.
*/
#define PT2MAP_SIZE (NPTE1_IN_PT1 * NB_IN_PT2)
#define PT2MAP_SHIFT PTE2_SHIFT
extern pt1_entry_t *kern_pt1;
extern pt2_entry_t *kern_pt2tab;
extern pt2_entry_t *PT2MAP;
/*
* Virtual interface for L1 page table management.
*/
static __inline u_int
pte1_index(vm_offset_t va)
{
return (va >> PTE1_SHIFT);
}
static __inline pt1_entry_t *
pte1_ptr(pt1_entry_t *pt1, vm_offset_t va)
{
return (pt1 + pte1_index(va));
}
static __inline vm_offset_t
pte1_trunc(vm_offset_t va)
{
return (va & PTE1_FRAME);
}
static __inline vm_offset_t
pte1_roundup(vm_offset_t va)
{
return ((va + PTE1_OFFSET) & PTE1_FRAME);
}
/*
* Virtual interface for L1 page table entries management.
*
* XXX: Some of the following functions now with a synchronization barrier
* are called in a loop, so it could be useful to have two versions of them.
* One with the barrier and one without the barrier. In this case, pure
* barrier pte1_sync() should be implemented as well.
*/
static __inline void
pte1_sync(pt1_entry_t *pte1p)
{
dsb();
#ifndef PMAP_PTE_NOCACHE
if (!cpuinfo.coherent_walk)
dcache_wb_pou((vm_offset_t)pte1p, sizeof(*pte1p));
#endif
}
static __inline void
pte1_sync_range(pt1_entry_t *pte1p, vm_size_t size)
{
dsb();
#ifndef PMAP_PTE_NOCACHE
if (!cpuinfo.coherent_walk)
dcache_wb_pou((vm_offset_t)pte1p, size);
#endif
}
static __inline void
pte1_store(pt1_entry_t *pte1p, pt1_entry_t pte1)
{
dmb();
*pte1p = pte1;
pte1_sync(pte1p);
}
static __inline void
pte1_clear(pt1_entry_t *pte1p)
{
pte1_store(pte1p, 0);
}
static __inline void
pte1_clear_bit(pt1_entry_t *pte1p, uint32_t bit)
{
*pte1p &= ~bit;
pte1_sync(pte1p);
}
static __inline boolean_t
pte1_is_link(pt1_entry_t pte1)
{
return ((pte1 & L1_TYPE_MASK) == L1_TYPE_C);
}
static __inline int
pte1_is_section(pt1_entry_t pte1)
{
return ((pte1 & L1_TYPE_MASK) == L1_TYPE_S);
}
static __inline boolean_t
pte1_is_dirty(pt1_entry_t pte1)
{
return ((pte1 & (PTE1_NM | PTE1_RO)) == 0);
}
static __inline boolean_t
pte1_is_global(pt1_entry_t pte1)
{
return ((pte1 & PTE1_NG) == 0);
}
static __inline boolean_t
pte1_is_valid(pt1_entry_t pte1)
{
int l1_type;
l1_type = pte1 & L1_TYPE_MASK;
return ((l1_type == L1_TYPE_C) || (l1_type == L1_TYPE_S));
}
static __inline boolean_t
pte1_is_wired(pt1_entry_t pte1)
{
return (pte1 & PTE1_W);
}
static __inline pt1_entry_t
pte1_load(pt1_entry_t *pte1p)
{
pt1_entry_t pte1;
pte1 = *pte1p;
return (pte1);
}
static __inline pt1_entry_t
pte1_load_clear(pt1_entry_t *pte1p)
{
pt1_entry_t opte1;
opte1 = *pte1p;
*pte1p = 0;
pte1_sync(pte1p);
return (opte1);
}
static __inline void
pte1_set_bit(pt1_entry_t *pte1p, uint32_t bit)
{
*pte1p |= bit;
pte1_sync(pte1p);
}
static __inline vm_paddr_t
pte1_pa(pt1_entry_t pte1)
{
return ((vm_paddr_t)(pte1 & PTE1_FRAME));
}
static __inline vm_paddr_t
pte1_link_pa(pt1_entry_t pte1)
{
return ((vm_paddr_t)(pte1 & L1_C_ADDR_MASK));
}
/*
* Virtual interface for L2 page table entries management.
*
* XXX: Some of the following functions now with a synchronization barrier
* are called in a loop, so it could be useful to have two versions of them.
* One with the barrier and one without the barrier.
*/
static __inline void
pte2_sync(pt2_entry_t *pte2p)
{
dsb();
#ifndef PMAP_PTE_NOCACHE
if (!cpuinfo.coherent_walk)
dcache_wb_pou((vm_offset_t)pte2p, sizeof(*pte2p));
#endif
}
static __inline void
pte2_sync_range(pt2_entry_t *pte2p, vm_size_t size)
{
dsb();
#ifndef PMAP_PTE_NOCACHE
if (!cpuinfo.coherent_walk)
dcache_wb_pou((vm_offset_t)pte2p, size);
#endif
}
static __inline void
pte2_store(pt2_entry_t *pte2p, pt2_entry_t pte2)
{
dmb();
*pte2p = pte2;
pte2_sync(pte2p);
}
static __inline void
pte2_clear(pt2_entry_t *pte2p)
{
pte2_store(pte2p, 0);
}
static __inline void
pte2_clear_bit(pt2_entry_t *pte2p, uint32_t bit)
{
*pte2p &= ~bit;
pte2_sync(pte2p);
}
static __inline boolean_t
pte2_is_dirty(pt2_entry_t pte2)
{
return ((pte2 & (PTE2_NM | PTE2_RO)) == 0);
}
static __inline boolean_t
pte2_is_global(pt2_entry_t pte2)
{
return ((pte2 & PTE2_NG) == 0);
}
static __inline boolean_t
pte2_is_valid(pt2_entry_t pte2)
{
return (pte2 & PTE2_V);
}
static __inline boolean_t
pte2_is_wired(pt2_entry_t pte2)
{
return (pte2 & PTE2_W);
}
static __inline pt2_entry_t
pte2_load(pt2_entry_t *pte2p)
{
pt2_entry_t pte2;
pte2 = *pte2p;
return (pte2);
}
static __inline pt2_entry_t
pte2_load_clear(pt2_entry_t *pte2p)
{
pt2_entry_t opte2;
opte2 = *pte2p;
*pte2p = 0;
pte2_sync(pte2p);
return (opte2);
}
static __inline void
pte2_set_bit(pt2_entry_t *pte2p, uint32_t bit)
{
*pte2p |= bit;
pte2_sync(pte2p);
}
static __inline void
pte2_set_wired(pt2_entry_t *pte2p, boolean_t wired)
{
/*
* Wired bit is transparent for page table walk,
* so pte2_sync() is not needed.
*/
if (wired)
*pte2p |= PTE2_W;
else
*pte2p &= ~PTE2_W;
}
static __inline vm_paddr_t
pte2_pa(pt2_entry_t pte2)
{
return ((vm_paddr_t)(pte2 & PTE2_FRAME));
}
static __inline u_int
pte2_attr(pt2_entry_t pte2)
{
return ((u_int)(pte2 & PTE2_ATTR_MASK));
}
/*
* Virtual interface for L2 page tables mapping management.
*/
static __inline u_int
pt2tab_index(vm_offset_t va)
{
return (va >> PT2TAB_SHIFT);
}
static __inline pt2_entry_t *
pt2tab_entry(pt2_entry_t *pt2tab, vm_offset_t va)
{
return (pt2tab + pt2tab_index(va));
}
static __inline void
pt2tab_store(pt2_entry_t *pte2p, pt2_entry_t pte2)
{
pte2_store(pte2p,pte2);
}
static __inline pt2_entry_t
pt2tab_load(pt2_entry_t *pte2p)
{
return (pte2_load(pte2p));
}
static __inline pt2_entry_t
pt2tab_load_clear(pt2_entry_t *pte2p)
{
return (pte2_load_clear(pte2p));
}
static __inline u_int
pt2map_index(vm_offset_t va)
{
return (va >> PT2MAP_SHIFT);
}
static __inline pt2_entry_t *
pt2map_entry(vm_offset_t va)
{
return (PT2MAP + pt2map_index(va));
}
/*
* Virtual interface for pmap structure & kernel shortcuts.
*/
static __inline pt1_entry_t *
pmap_pte1(pmap_t pmap, vm_offset_t va)
{
return (pte1_ptr(pmap->pm_pt1, va));
}
static __inline pt1_entry_t *
kern_pte1(vm_offset_t va)
{
return (pte1_ptr(kern_pt1, va));
}
static __inline pt2_entry_t *
pmap_pt2tab_entry(pmap_t pmap, vm_offset_t va)
{
return (pt2tab_entry(pmap->pm_pt2tab, va));
}
static __inline pt2_entry_t *
kern_pt2tab_entry(vm_offset_t va)
{
return (pt2tab_entry(kern_pt2tab, va));
}
static __inline vm_page_t
pmap_pt2_page(pmap_t pmap, vm_offset_t va)
{
pt2_entry_t pte2;
pte2 = pte2_load(pmap_pt2tab_entry(pmap, va));
return (PHYS_TO_VM_PAGE(pte2 & PTE2_FRAME));
}
static __inline vm_page_t
kern_pt2_page(vm_offset_t va)
{
pt2_entry_t pte2;
pte2 = pte2_load(kern_pt2tab_entry(va));
return (PHYS_TO_VM_PAGE(pte2 & PTE2_FRAME));
}
#endif /* _KERNEL */
#endif /* !_MACHINE_PMAP_VAR_H_ */
