2005-11-19 02:17:32 -07:00
|
|
|
#ifndef _ASM_POWERPC_MMU_H_
|
|
|
|
#define _ASM_POWERPC_MMU_H_
|
|
|
|
|
|
|
|
#ifndef CONFIG_PPC64
|
|
|
|
#include <asm-ppc/mmu.h>
|
|
|
|
#else
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
/*
|
|
|
|
* PowerPC memory management structures
|
|
|
|
*
|
|
|
|
* Dave Engebretsen & Mike Corrigan <{engebret|mikejc}@us.ibm.com>
|
|
|
|
* PPC64 rework.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version
|
|
|
|
* 2 of the License, or (at your option) any later version.
|
|
|
|
*/
|
|
|
|
|
[PATCH] powerpc: Consolidate asm compatibility macros
This patch consolidates macros used to generate assembly for
compatibility across different CPUs or configs. A new header,
asm-powerpc/asm-compat.h contains the main compatibility macros. It
uses some preprocessor magic to make the macros suitable both for use
in .S files, and in inline asm in .c files. Headers (bitops.h,
uaccess.h, atomic.h, bug.h) which had their own such compatibility
macros are changed to use asm-compat.h.
ppc_asm.h is now for use in .S files *only*, and a #error enforces
that. As such, we're a lot more careless about namespace pollution
here than in asm-compat.h.
While we're at it, this patch adds a call to the PPC405_ERR77 macro in
futex.h which should have had it already, but didn't.
Built and booted on pSeries, Maple and iSeries (ARCH=powerpc). Built
for 32-bit powermac (ARCH=powerpc) and Walnut (ARCH=ppc).
Signed-off-by: David Gibson <dwg@au1.ibm.com>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2005-11-09 18:56:55 -07:00
|
|
|
#include <asm/asm-compat.h>
|
2005-04-16 15:20:36 -07:00
|
|
|
#include <asm/page.h>
|
|
|
|
|
2005-05-05 16:15:13 -07:00
|
|
|
/*
|
|
|
|
* Segment table
|
|
|
|
*/
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
#define STE_ESID_V 0x80
|
|
|
|
#define STE_ESID_KS 0x20
|
|
|
|
#define STE_ESID_KP 0x10
|
|
|
|
#define STE_ESID_N 0x08
|
|
|
|
|
|
|
|
#define STE_VSID_SHIFT 12
|
|
|
|
|
2005-05-05 16:15:13 -07:00
|
|
|
/* Location of cpu0's segment table */
|
2005-08-18 21:52:31 -07:00
|
|
|
#define STAB0_PAGE 0x6
|
2005-09-19 20:47:41 -07:00
|
|
|
#define STAB0_PHYS_ADDR (STAB0_PAGE<<12)
|
2005-08-18 21:52:31 -07:00
|
|
|
|
|
|
|
#ifndef __ASSEMBLY__
|
|
|
|
extern char initial_stab[];
|
|
|
|
#endif /* ! __ASSEMBLY */
|
2005-05-05 16:15:13 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* SLB
|
|
|
|
*/
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2005-05-05 16:15:13 -07:00
|
|
|
#define SLB_NUM_BOLTED 3
|
|
|
|
#define SLB_CACHE_ENTRIES 8
|
|
|
|
|
|
|
|
/* Bits in the SLB ESID word */
|
|
|
|
#define SLB_ESID_V ASM_CONST(0x0000000008000000) /* valid */
|
|
|
|
|
|
|
|
/* Bits in the SLB VSID word */
|
|
|
|
#define SLB_VSID_SHIFT 12
|
2005-11-06 17:06:55 -07:00
|
|
|
#define SLB_VSID_B ASM_CONST(0xc000000000000000)
|
|
|
|
#define SLB_VSID_B_256M ASM_CONST(0x0000000000000000)
|
|
|
|
#define SLB_VSID_B_1T ASM_CONST(0x4000000000000000)
|
2005-05-05 16:15:13 -07:00
|
|
|
#define SLB_VSID_KS ASM_CONST(0x0000000000000800)
|
|
|
|
#define SLB_VSID_KP ASM_CONST(0x0000000000000400)
|
|
|
|
#define SLB_VSID_N ASM_CONST(0x0000000000000200) /* no-execute */
|
2005-11-06 17:06:55 -07:00
|
|
|
#define SLB_VSID_L ASM_CONST(0x0000000000000100)
|
2005-05-05 16:15:13 -07:00
|
|
|
#define SLB_VSID_C ASM_CONST(0x0000000000000080) /* class */
|
2005-11-06 17:06:55 -07:00
|
|
|
#define SLB_VSID_LP ASM_CONST(0x0000000000000030)
|
|
|
|
#define SLB_VSID_LP_00 ASM_CONST(0x0000000000000000)
|
|
|
|
#define SLB_VSID_LP_01 ASM_CONST(0x0000000000000010)
|
|
|
|
#define SLB_VSID_LP_10 ASM_CONST(0x0000000000000020)
|
|
|
|
#define SLB_VSID_LP_11 ASM_CONST(0x0000000000000030)
|
|
|
|
#define SLB_VSID_LLP (SLB_VSID_L|SLB_VSID_LP)
|
|
|
|
|
2005-09-05 21:59:47 -07:00
|
|
|
#define SLB_VSID_KERNEL (SLB_VSID_KP)
|
|
|
|
#define SLB_VSID_USER (SLB_VSID_KP|SLB_VSID_KS|SLB_VSID_C)
|
|
|
|
|
|
|
|
#define SLBIE_C (0x08000000)
|
2005-05-05 16:15:13 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Hash table
|
|
|
|
*/
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
#define HPTES_PER_GROUP 8
|
|
|
|
|
2005-07-13 01:11:42 -07:00
|
|
|
#define HPTE_V_AVPN_SHIFT 7
|
|
|
|
#define HPTE_V_AVPN ASM_CONST(0xffffffffffffff80)
|
|
|
|
#define HPTE_V_AVPN_VAL(x) (((x) & HPTE_V_AVPN) >> HPTE_V_AVPN_SHIFT)
|
2005-11-06 17:06:55 -07:00
|
|
|
#define HPTE_V_COMPARE(x,y) (!(((x) ^ (y)) & HPTE_V_AVPN))
|
2005-07-13 01:11:42 -07:00
|
|
|
#define HPTE_V_BOLTED ASM_CONST(0x0000000000000010)
|
|
|
|
#define HPTE_V_LOCK ASM_CONST(0x0000000000000008)
|
|
|
|
#define HPTE_V_LARGE ASM_CONST(0x0000000000000004)
|
|
|
|
#define HPTE_V_SECONDARY ASM_CONST(0x0000000000000002)
|
|
|
|
#define HPTE_V_VALID ASM_CONST(0x0000000000000001)
|
|
|
|
|
|
|
|
#define HPTE_R_PP0 ASM_CONST(0x8000000000000000)
|
|
|
|
#define HPTE_R_TS ASM_CONST(0x4000000000000000)
|
|
|
|
#define HPTE_R_RPN_SHIFT 12
|
|
|
|
#define HPTE_R_RPN ASM_CONST(0x3ffffffffffff000)
|
|
|
|
#define HPTE_R_FLAGS ASM_CONST(0x00000000000003ff)
|
|
|
|
#define HPTE_R_PP ASM_CONST(0x0000000000000003)
|
2005-11-06 17:06:55 -07:00
|
|
|
#define HPTE_R_N ASM_CONST(0x0000000000000004)
|
2005-07-13 01:11:42 -07:00
|
|
|
|
2005-05-05 16:15:13 -07:00
|
|
|
/* Values for PP (assumes Ks=0, Kp=1) */
|
|
|
|
/* pp0 will always be 0 for linux */
|
|
|
|
#define PP_RWXX 0 /* Supervisor read/write, User none */
|
|
|
|
#define PP_RWRX 1 /* Supervisor read/write, User read */
|
|
|
|
#define PP_RWRW 2 /* Supervisor read/write, User read/write */
|
|
|
|
#define PP_RXRX 3 /* Supervisor read, User read */
|
|
|
|
|
|
|
|
#ifndef __ASSEMBLY__
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
typedef struct {
|
2005-07-13 01:11:42 -07:00
|
|
|
unsigned long v;
|
|
|
|
unsigned long r;
|
|
|
|
} hpte_t;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2005-07-13 01:11:42 -07:00
|
|
|
extern hpte_t *htab_address;
|
|
|
|
extern unsigned long htab_hash_mask;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2005-11-06 17:06:55 -07:00
|
|
|
/*
|
|
|
|
* Page size definition
|
|
|
|
*
|
|
|
|
* shift : is the "PAGE_SHIFT" value for that page size
|
|
|
|
* sllp : is a bit mask with the value of SLB L || LP to be or'ed
|
|
|
|
* directly to a slbmte "vsid" value
|
|
|
|
* penc : is the HPTE encoding mask for the "LP" field:
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
struct mmu_psize_def
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
2005-11-06 17:06:55 -07:00
|
|
|
unsigned int shift; /* number of bits */
|
|
|
|
unsigned int penc; /* HPTE encoding */
|
|
|
|
unsigned int tlbiel; /* tlbiel supported for that page size */
|
|
|
|
unsigned long avpnm; /* bits to mask out in AVPN in the HPTE */
|
|
|
|
unsigned long sllp; /* SLB L||LP (exact mask to use in slbmte) */
|
|
|
|
};
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2005-11-06 17:06:55 -07:00
|
|
|
#endif /* __ASSEMBLY__ */
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2005-11-06 17:06:55 -07:00
|
|
|
/*
|
|
|
|
* The kernel use the constants below to index in the page sizes array.
|
|
|
|
* The use of fixed constants for this purpose is better for performances
|
|
|
|
* of the low level hash refill handlers.
|
|
|
|
*
|
|
|
|
* A non supported page size has a "shift" field set to 0
|
|
|
|
*
|
|
|
|
* Any new page size being implemented can get a new entry in here. Whether
|
|
|
|
* the kernel will use it or not is a different matter though. The actual page
|
|
|
|
* size used by hugetlbfs is not defined here and may be made variable
|
|
|
|
*/
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2005-11-06 17:06:55 -07:00
|
|
|
#define MMU_PAGE_4K 0 /* 4K */
|
|
|
|
#define MMU_PAGE_64K 1 /* 64K */
|
|
|
|
#define MMU_PAGE_64K_AP 2 /* 64K Admixed (in a 4K segment) */
|
|
|
|
#define MMU_PAGE_1M 3 /* 1M */
|
|
|
|
#define MMU_PAGE_16M 4 /* 16M */
|
|
|
|
#define MMU_PAGE_16G 5 /* 16G */
|
|
|
|
#define MMU_PAGE_COUNT 6
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2005-11-06 17:06:55 -07:00
|
|
|
#ifndef __ASSEMBLY__
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2005-11-06 17:06:55 -07:00
|
|
|
/*
|
|
|
|
* The current system page sizes
|
|
|
|
*/
|
|
|
|
extern struct mmu_psize_def mmu_psize_defs[MMU_PAGE_COUNT];
|
|
|
|
extern int mmu_linear_psize;
|
|
|
|
extern int mmu_virtual_psize;
|
2005-06-25 14:58:08 -07:00
|
|
|
|
2005-11-06 17:06:55 -07:00
|
|
|
#ifdef CONFIG_HUGETLB_PAGE
|
|
|
|
/*
|
|
|
|
* The page size index of the huge pages for use by hugetlbfs
|
|
|
|
*/
|
|
|
|
extern int mmu_huge_psize;
|
2005-06-25 14:58:08 -07:00
|
|
|
|
2005-11-06 17:06:55 -07:00
|
|
|
#endif /* CONFIG_HUGETLB_PAGE */
|
2005-06-25 14:58:08 -07:00
|
|
|
|
2005-11-06 17:06:55 -07:00
|
|
|
/*
|
|
|
|
* This function sets the AVPN and L fields of the HPTE appropriately
|
|
|
|
* for the page size
|
|
|
|
*/
|
|
|
|
static inline unsigned long hpte_encode_v(unsigned long va, int psize)
|
|
|
|
{
|
|
|
|
unsigned long v =
|
|
|
|
v = (va >> 23) & ~(mmu_psize_defs[psize].avpnm);
|
|
|
|
v <<= HPTE_V_AVPN_SHIFT;
|
|
|
|
if (psize != MMU_PAGE_4K)
|
|
|
|
v |= HPTE_V_LARGE;
|
|
|
|
return v;
|
|
|
|
}
|
2005-06-25 14:58:08 -07:00
|
|
|
|
2005-11-06 17:06:55 -07:00
|
|
|
/*
|
|
|
|
* This function sets the ARPN, and LP fields of the HPTE appropriately
|
|
|
|
* for the page size. We assume the pa is already "clean" that is properly
|
|
|
|
* aligned for the requested page size
|
|
|
|
*/
|
|
|
|
static inline unsigned long hpte_encode_r(unsigned long pa, int psize)
|
|
|
|
{
|
|
|
|
unsigned long r;
|
2005-06-25 14:58:08 -07:00
|
|
|
|
2005-11-06 17:06:55 -07:00
|
|
|
/* A 4K page needs no special encoding */
|
|
|
|
if (psize == MMU_PAGE_4K)
|
|
|
|
return pa & HPTE_R_RPN;
|
|
|
|
else {
|
|
|
|
unsigned int penc = mmu_psize_defs[psize].penc;
|
|
|
|
unsigned int shift = mmu_psize_defs[psize].shift;
|
|
|
|
return (pa & ~((1ul << shift) - 1)) | (penc << 12);
|
2005-06-25 14:58:08 -07:00
|
|
|
}
|
2005-11-06 17:06:55 -07:00
|
|
|
return r;
|
2005-06-25 14:58:08 -07:00
|
|
|
}
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
/*
|
2005-11-06 17:06:55 -07:00
|
|
|
* This hashes a virtual address for a 256Mb segment only for now
|
2005-04-16 15:20:36 -07:00
|
|
|
*/
|
2005-11-06 17:06:55 -07:00
|
|
|
|
|
|
|
static inline unsigned long hpt_hash(unsigned long va, unsigned int shift)
|
|
|
|
{
|
|
|
|
return ((va >> 28) & 0x7fffffffffUL) ^ ((va & 0x0fffffffUL) >> shift);
|
|
|
|
}
|
|
|
|
|
|
|
|
extern int __hash_page_4K(unsigned long ea, unsigned long access,
|
|
|
|
unsigned long vsid, pte_t *ptep, unsigned long trap,
|
|
|
|
unsigned int local);
|
|
|
|
extern int __hash_page_64K(unsigned long ea, unsigned long access,
|
|
|
|
unsigned long vsid, pte_t *ptep, unsigned long trap,
|
|
|
|
unsigned int local);
|
|
|
|
struct mm_struct;
|
|
|
|
extern int hash_huge_page(struct mm_struct *mm, unsigned long access,
|
2005-12-08 20:20:52 -07:00
|
|
|
unsigned long ea, unsigned long vsid, int local,
|
|
|
|
unsigned long trap);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
extern void htab_finish_init(void);
|
2005-11-06 17:06:55 -07:00
|
|
|
extern int htab_bolt_mapping(unsigned long vstart, unsigned long vend,
|
|
|
|
unsigned long pstart, unsigned long mode,
|
|
|
|
int psize);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2005-11-09 19:37:51 -07:00
|
|
|
extern void htab_initialize(void);
|
|
|
|
extern void htab_initialize_secondary(void);
|
2005-05-05 16:15:13 -07:00
|
|
|
extern void hpte_init_native(void);
|
|
|
|
extern void hpte_init_lpar(void);
|
|
|
|
extern void hpte_init_iSeries(void);
|
2005-11-09 21:53:40 -07:00
|
|
|
extern void mm_init_ppc64(void);
|
2005-05-05 16:15:13 -07:00
|
|
|
|
|
|
|
extern long pSeries_lpar_hpte_insert(unsigned long hpte_group,
|
|
|
|
unsigned long va, unsigned long prpn,
|
2005-11-06 17:06:55 -07:00
|
|
|
unsigned long rflags,
|
|
|
|
unsigned long vflags, int psize);
|
|
|
|
|
|
|
|
extern long native_hpte_insert(unsigned long hpte_group,
|
|
|
|
unsigned long va, unsigned long prpn,
|
|
|
|
unsigned long rflags,
|
|
|
|
unsigned long vflags, int psize);
|
2005-05-05 16:15:13 -07:00
|
|
|
|
2005-11-06 17:06:55 -07:00
|
|
|
extern long iSeries_hpte_insert(unsigned long hpte_group,
|
|
|
|
unsigned long va, unsigned long prpn,
|
|
|
|
unsigned long rflags,
|
|
|
|
unsigned long vflags, int psize);
|
2005-09-22 21:47:58 -07:00
|
|
|
|
2005-07-27 11:44:19 -07:00
|
|
|
extern void stabs_alloc(void);
|
2005-11-06 17:06:55 -07:00
|
|
|
extern void slb_initialize(void);
|
2005-11-09 19:37:51 -07:00
|
|
|
extern void stab_initialize(unsigned long stab);
|
2005-07-27 11:44:19 -07:00
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
#endif /* __ASSEMBLY__ */
|
|
|
|
|
|
|
|
/*
|
2005-05-05 16:15:13 -07:00
|
|
|
* VSID allocation
|
|
|
|
*
|
|
|
|
* We first generate a 36-bit "proto-VSID". For kernel addresses this
|
|
|
|
* is equal to the ESID, for user addresses it is:
|
|
|
|
* (context << 15) | (esid & 0x7fff)
|
|
|
|
*
|
|
|
|
* The two forms are distinguishable because the top bit is 0 for user
|
|
|
|
* addresses, whereas the top two bits are 1 for kernel addresses.
|
|
|
|
* Proto-VSIDs with the top two bits equal to 0b10 are reserved for
|
|
|
|
* now.
|
|
|
|
*
|
|
|
|
* The proto-VSIDs are then scrambled into real VSIDs with the
|
|
|
|
* multiplicative hash:
|
|
|
|
*
|
|
|
|
* VSID = (proto-VSID * VSID_MULTIPLIER) % VSID_MODULUS
|
|
|
|
* where VSID_MULTIPLIER = 268435399 = 0xFFFFFC7
|
|
|
|
* VSID_MODULUS = 2^36-1 = 0xFFFFFFFFF
|
|
|
|
*
|
|
|
|
* This scramble is only well defined for proto-VSIDs below
|
|
|
|
* 0xFFFFFFFFF, so both proto-VSID and actual VSID 0xFFFFFFFFF are
|
|
|
|
* reserved. VSID_MULTIPLIER is prime, so in particular it is
|
|
|
|
* co-prime to VSID_MODULUS, making this a 1:1 scrambling function.
|
|
|
|
* Because the modulus is 2^n-1 we can compute it efficiently without
|
|
|
|
* a divide or extra multiply (see below).
|
|
|
|
*
|
|
|
|
* This scheme has several advantages over older methods:
|
|
|
|
*
|
|
|
|
* - We have VSIDs allocated for every kernel address
|
|
|
|
* (i.e. everything above 0xC000000000000000), except the very top
|
|
|
|
* segment, which simplifies several things.
|
|
|
|
*
|
|
|
|
* - We allow for 15 significant bits of ESID and 20 bits of
|
|
|
|
* context for user addresses. i.e. 8T (43 bits) of address space for
|
|
|
|
* up to 1M contexts (although the page table structure and context
|
|
|
|
* allocation will need changes to take advantage of this).
|
|
|
|
*
|
|
|
|
* - The scramble function gives robust scattering in the hash
|
|
|
|
* table (at least based on some initial results). The previous
|
|
|
|
* method was more susceptible to pathological cases giving excessive
|
|
|
|
* hash collisions.
|
|
|
|
*/
|
|
|
|
/*
|
|
|
|
* WARNING - If you change these you must make sure the asm
|
|
|
|
* implementations in slb_allocate (slb_low.S), do_stab_bolted
|
|
|
|
* (head.S) and ASM_VSID_SCRAMBLE (below) are changed accordingly.
|
|
|
|
*
|
|
|
|
* You'll also need to change the precomputed VSID values in head.S
|
|
|
|
* which are used by the iSeries firmware.
|
2005-04-16 15:20:36 -07:00
|
|
|
*/
|
|
|
|
|
|
|
|
#define VSID_MULTIPLIER ASM_CONST(200730139) /* 28-bit prime */
|
|
|
|
#define VSID_BITS 36
|
|
|
|
#define VSID_MODULUS ((1UL<<VSID_BITS)-1)
|
|
|
|
|
2005-08-05 02:39:06 -07:00
|
|
|
#define CONTEXT_BITS 19
|
|
|
|
#define USER_ESID_BITS 16
|
|
|
|
|
|
|
|
#define USER_VSID_RANGE (1UL << (USER_ESID_BITS + SID_SHIFT))
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This macro generates asm code to compute the VSID scramble
|
|
|
|
* function. Used in slb_allocate() and do_stab_bolted. The function
|
|
|
|
* computed is: (protovsid*VSID_MULTIPLIER) % VSID_MODULUS
|
|
|
|
*
|
|
|
|
* rt = register continaing the proto-VSID and into which the
|
|
|
|
* VSID will be stored
|
|
|
|
* rx = scratch register (clobbered)
|
|
|
|
*
|
|
|
|
* - rt and rx must be different registers
|
|
|
|
* - The answer will end up in the low 36 bits of rt. The higher
|
|
|
|
* bits may contain other garbage, so you may need to mask the
|
|
|
|
* result.
|
|
|
|
*/
|
|
|
|
#define ASM_VSID_SCRAMBLE(rt, rx) \
|
|
|
|
lis rx,VSID_MULTIPLIER@h; \
|
|
|
|
ori rx,rx,VSID_MULTIPLIER@l; \
|
|
|
|
mulld rt,rt,rx; /* rt = rt * MULTIPLIER */ \
|
|
|
|
\
|
|
|
|
srdi rx,rt,VSID_BITS; \
|
|
|
|
clrldi rt,rt,(64-VSID_BITS); \
|
|
|
|
add rt,rt,rx; /* add high and low bits */ \
|
|
|
|
/* Now, r3 == VSID (mod 2^36-1), and lies between 0 and \
|
|
|
|
* 2^36-1+2^28-1. That in particular means that if r3 >= \
|
|
|
|
* 2^36-1, then r3+1 has the 2^36 bit set. So, if r3+1 has \
|
|
|
|
* the bit clear, r3 already has the answer we want, if it \
|
|
|
|
* doesn't, the answer is the low 36 bits of r3+1. So in all \
|
|
|
|
* cases the answer is the low 36 bits of (r3 + ((r3+1) >> 36))*/\
|
|
|
|
addi rx,rt,1; \
|
|
|
|
srdi rx,rx,VSID_BITS; /* extract 2^36 bit */ \
|
|
|
|
add rt,rt,rx
|
|
|
|
|
2005-05-05 16:15:13 -07:00
|
|
|
|
|
|
|
#ifndef __ASSEMBLY__
|
|
|
|
|
|
|
|
typedef unsigned long mm_context_id_t;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
mm_context_id_t id;
|
|
|
|
#ifdef CONFIG_HUGETLB_PAGE
|
2005-08-10 23:55:21 -07:00
|
|
|
u16 low_htlb_areas, high_htlb_areas;
|
2005-05-05 16:15:13 -07:00
|
|
|
#endif
|
|
|
|
} mm_context_t;
|
|
|
|
|
|
|
|
|
|
|
|
static inline unsigned long vsid_scramble(unsigned long protovsid)
|
|
|
|
{
|
|
|
|
#if 0
|
|
|
|
/* The code below is equivalent to this function for arguments
|
|
|
|
* < 2^VSID_BITS, which is all this should ever be called
|
|
|
|
* with. However gcc is not clever enough to compute the
|
|
|
|
* modulus (2^n-1) without a second multiply. */
|
|
|
|
return ((protovsid * VSID_MULTIPLIER) % VSID_MODULUS);
|
|
|
|
#else /* 1 */
|
|
|
|
unsigned long x;
|
|
|
|
|
|
|
|
x = protovsid * VSID_MULTIPLIER;
|
|
|
|
x = (x >> VSID_BITS) + (x & VSID_MODULUS);
|
|
|
|
return (x + ((x+1) >> VSID_BITS)) & VSID_MODULUS;
|
|
|
|
#endif /* 1 */
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This is only valid for addresses >= KERNELBASE */
|
|
|
|
static inline unsigned long get_kernel_vsid(unsigned long ea)
|
|
|
|
{
|
|
|
|
return vsid_scramble(ea >> SID_SHIFT);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This is only valid for user addresses (which are below 2^41) */
|
|
|
|
static inline unsigned long get_vsid(unsigned long context, unsigned long ea)
|
|
|
|
{
|
|
|
|
return vsid_scramble((context << USER_ESID_BITS)
|
|
|
|
| (ea >> SID_SHIFT));
|
|
|
|
}
|
|
|
|
|
2005-07-27 11:44:21 -07:00
|
|
|
#define VSID_SCRAMBLE(pvsid) (((pvsid) * VSID_MULTIPLIER) % VSID_MODULUS)
|
|
|
|
#define KERNEL_VSID(ea) VSID_SCRAMBLE(GET_ESID(ea))
|
|
|
|
|
2005-11-22 23:53:42 -07:00
|
|
|
/* Physical address used by some IO functions */
|
|
|
|
typedef unsigned long phys_addr_t;
|
|
|
|
|
|
|
|
|
2005-05-05 16:15:13 -07:00
|
|
|
#endif /* __ASSEMBLY */
|
|
|
|
|
2005-11-19 02:17:32 -07:00
|
|
|
#endif /* CONFIG_PPC64 */
|
|
|
|
#endif /* _ASM_POWERPC_MMU_H_ */
|