[apple/xnu.git] / osfmk / ppc / mappings.h

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * Copyright (c) 1999-2003 Apple Computer, Inc.  All Rights Reserved.
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/*
 *		Header files for the hardware virtual memory mapping stuff 
 */
#ifndef	_PPC_MAPPINGS_H_
#define	_PPC_MAPPINGS_H_

#include <cpus.h>

#include <mach/mach_types.h>
#include <mach/vm_types.h>
#include <mach/machine/vm_types.h>
#include <mach/vm_prot.h>
#include <mach/vm_statistics.h>
#include <kern/assert.h>
#include <kern/cpu_number.h>
#include <kern/lock.h>
#include <kern/queue.h>
#include <ppc/proc_reg.h>

/*
 * Don't change these structures unless you change the assembly code
 */

/*
 *	This control block serves as anchor for all virtual mappings of the same physical
 *	page, i.e., aliases.  There is a table for each bank (mem_region).  All tables
 *	must reside in V=R storage and within the first 2GB of memory. Also, the
 *	mappings to which it points must be on at least a 64-byte boundary. These 
 *	requirements allow a total of 2 bits for status and flags, and allow all address
 *	calculations to be 32-bit.
 */

#pragma pack(4)							/* Make sure the structure stays as we defined it */
typedef struct phys_entry {
	addr64_t	ppLink;				/* Physical pointer to aliased mappings and flags */
#define		ppLock		0x8000000000000000LL	/* Lock for alias chain */
#define		ppN			0x4000000000000000LL	/* Not executable */
#define		ppFlags		0x000000000000003FLL	/* Status and flags */
#define		ppI			0x0000000000000020LL	/* Cache inhibited */
#define		ppIb		58						/* Cache inhibited */
#define		ppG			0x0000000000000010LL	/* Guarded */
#define		ppGb		59						/* Guarded */
#define		ppR			0x0000000000000008LL	/* Referenced */
#define		ppRb		60						/* Referenced */
#define		ppC			0x0000000000000004LL	/* Changed */
#define		ppCb		61						/* Changed */
#define		ppPP		0x0000000000000003LL	/* Protection */
#define		ppPPb		62						/* Protection begin */
#define		ppPPe		63						/* Protection end */
} phys_entry;
#pragma pack()

/* Memory may be non-contiguous. This data structure contains info
 * for mapping this non-contiguous space into the contiguous
 * physical->virtual mapping tables. An array of this type is
 * provided to the pmap system at bootstrap by ppc_vm_init.
 *
 */

#pragma pack(4)							/* Make sure the structure stays as we defined it */
typedef struct mem_region {
	phys_entry			*mrPhysTab;	/* Base of region table */
	ppnum_t				mrStart;	/* Start of region */
	ppnum_t				mrEnd;		/* Last page in region */
	ppnum_t				mrAStart;	/* Next page in region to allocate */
	ppnum_t				mrAEnd;		/* Last page in region to allocate */
} mem_region_t;
#pragma pack()

#define mrSize sizeof(mem_region_t)
#define PMAP_MEM_REGION_MAX 26

extern mem_region_t pmap_mem_regions[PMAP_MEM_REGION_MAX + 1];
extern int          pmap_mem_regions_count;

/* Prototypes */


#pragma pack(4)							/* Make sure the structure stays as we defined it */
typedef struct PCA {					/* PTEG Control Area */
	union flgs {
		unsigned int	PCAallo;		/* Allocation controls */
		struct PCAalflgs {				/* Keep these in order!!! */
			unsigned char	PCAfree;	/* Indicates the slot is free */
			unsigned char	PCAsteal;	/* Steal scan start position */
			unsigned char	PCAauto;	/* Indicates that the PTE was autogenned */
			unsigned char	PCAmisc;	/* Misc. flags */
#define PCAlock 1						/* This locks up the associated PTEG */
#define PCAlockb 31
		} PCAalflgs;
	} flgs;
} PCA;
#pragma pack()

/* Mappings currently come in two sizes: 64 and 128 bytes.  The only difference is the
 * number of skiplists (ie, mpLists): 64-byte mappings have 1-4 lists and 128-byte mappings
 * have from 5-12.  Only 1 in 256 mappings is large, so an average mapping is 64.25 bytes.
 * All mappings are 64-byte aligned.
 *
 * Special note on mpFIP and mpRIP:
 *	These flags are manipulated under various locks.  RIP is always set under an
 *	exclusive lock while FIP is shared.  The only worry is that there is a possibility that
 *	FIP could be attempted by more than 1 processor at a time.  Obviously, one will win.
 *	The other(s) bail all the way to user state and may refault (or not).  There are only
 *	a few things in mpFlags that are not static, mpFIP, mpRIP, mpRemovable, and mpBusy.
 *	
 *	We organize these so that mpFIP is in a byte with static data and mpRIP and mpRemovable
 *	is in another.  That means that we can use a store byte to update the guys without
 *	worrying about load and reserve. Note that mpFIP must be set atomically because it is
 *	under a share lock, but it may be clear with a simple store byte. So far as mpRIP
 *	goes, it is in the same byte as mpRemovable.  However, mpRemovable is set atomically
 *	but never cleared, and mpRIP will not ever be set until after mpRemovable. Note that
 *	mpRIP is never cleared either.
 *	
 */   
#pragma pack(4)							/* Make sure the structure stays as we defined it */
typedef struct mapping {
	unsigned int		mpFlags;		/* 0x000 - Various flags, lock bit. These are static except for lock */
#define	mpBusy				0xFF000000	/*         Busy count */
#define	mpPIndex			0x00FF0000	/*         Index into physical table (in words) */
#define	mpSpecial			0x00008000	/*         Special mapping - processor specific. */
#define	mpSpecialb			16			/*         Special mapping - processor specific. */
#define	mpFIP				0x00004000	/*         Fault in progress */
#define	mpFIPb				17			/*         Fault in progress */
#define	mpNest				0x00001000	/*         Mapping describes nested pmap */
#define	mpNestb				19			/*         Mapping describes nested pmap */
#define mpPerm				0x00000800	/*         Mapping is permanent */
#define mpPermb				20			/*         Mapping is permanent */
#define mpBlock				0x00000400	/*         Mapping is a block map - used for V=F or I/O */
#define mpBlockb			21			/*         Mapping is a block map - used for V=F or I/O */
#define mpRIP				0x00000080	/*         Remove in progress - DO NOT MOVE */
#define mpRIPb				24			/*         Remove in progress */
#define	mpRemovable			0x00000040	/*         Mapping is removable - DO NOT MOVE */
#define	mpRemovableb		25			/*         Mapping is removable */
#define mpRSVD1				0x00002330	/*         Reserved for future use */
#define mpLists				0x0000001F	/*         Number of skip lists mapping is on, max of 27 */
#define mpListsb			27			/*         Number of skip lists mapping is on, max of 27 */

	unsigned short		mpSpace;		/* 0x004 - Address space hash */
	unsigned short		mpBSize;		/* 0x006 - Block size - 1 in pages - max block size 256MB */
	unsigned int		mpPte;			/* 0x008 - Offset to PTEG in hash table. Offset to exact PTE if mpHValid set - NOTE: this MUST be 0 for block mappings */
#define mpHValid			0x00000001	/* PTE is entered in hash table */
#define mpHValidb			31			/* PTE is entered in hash table */
	ppnum_t				mpPAddr;		/* 0x00C - Physical page number */
	addr64_t			mpVAddr;		/* 0x010 - Starting virtual address */
#define mpHWFlags			0x0000000000000FFFULL	/* Reference/Change, WIMG, AC, N, protection flags from PTE */
#define mpPP				0x0000000000000007ULL	/* Protection flags */
#define mpPPb				61
#define mpKKN				0x0000000000000007ULL	/* Segment key and no execute flag (nested pmap) */
#define mpKKNb				61
#define mpWIMG				0x0000000000000078ULL	/* Attribute bits */
#define mpWIMGb				57
#define mpW					0x0000000000000040ULL
#define mpWb				57
#define mpI					0x0000000000000020ULL
#define mpIb				58
#define mpM					0x0000000000000010ULL
#define mpMb				59
#define mpG					0x0000000000000008ULL
#define mpGb				60
#define mpWIMGe				60
#define mpC					0x0000000000000080ULL	/* Change bit */
#define mpCb				56
#define mpR					0x0000000000000100ULL	/* Reference bit */
#define mpRb				55
	addr64_t			mpAlias;		/* 0x018 - Pointer to alias mappings of physical page */
#define mpNestReloc			mpAlias		/* 0x018 - Redefines mpAlias relocation value of vaddr to nested pmap value */
#define mpBlkRemCur			mpAlias		/* 0x018 - Next offset in block map to remove (this is 4 bytes) */
	addr64_t			mpList0;		/* 0x020 - Forward chain of mappings. This one is always used */
	addr64_t			mpList[3];		/* 0x028 - Forward chain of mappings. Next higher order */
/*										   0x040 - End of basic mapping */
#define	mpBasicSize			64
#define	mpBasicLists		4
/* note the dependence on kSkipListMaxLists, which must be <= #lists in a 256-byte mapping (ie, <=28) */
/*	addr64_t			mpList4[8];		   0x040 - First extended list entries */
/*										   0x080 - End of first extended mapping */
/*	addr64_t			mpList12[8];	   0x080 - Second extended list entries */
/*										   0x0C0 - End of second extended mapping */
/*	addr64_t			mpList20[8];	   0x0C0 - Third extended list entries */
/*										   0x100 - End of third extended mapping */

} mapping;
#pragma pack()

#define MAPPING_NULL	((struct mapping *) 0)

#define mapDirect 0x08
#define mapRWNA   0x00000000
#define mapRWRO   0x00000001
#define mapRWRW   0x00000002
#define mapRORO   0x00000003

/* All counts are in units of basic 64-byte mappings.  A 128-byte mapping is
 * just two adjacent 64-byte entries.
 */
#pragma pack(4)							/* Make sure the structure stays as we defined it */

typedef struct mappingflush {
	addr64_t			addr;			/* Start address to search mapping */
	unsigned int		spacenum;		/* Last space num to search pmap */
	unsigned int		mapfgas[1];		/* Pad to 64 bytes */
} mappingflush;

typedef struct mappingctl {
	unsigned int		mapclock;		/* Mapping allocation lock */
	unsigned int		mapcrecurse;	/* Mapping allocation recursion control */
	struct mappingblok	*mapcnext;		/* First mapping block with free entries */
	struct mappingblok	*mapclast;		/* Last mapping block with free entries */
	struct mappingblok	*mapcrel;		/* List of deferred block releases */
	unsigned int		mapcfree;		/* Total free entries on list */
	unsigned int		mapcinuse;		/* Total entries in use */
	unsigned int		mapcreln;		/* Total blocks on pending release list */
	int					mapcholdoff;	/* Hold off clearing release list */
	unsigned int		mapcfreec;		/* Total calls to mapping free */
	unsigned int		mapcallocc;		/* Total calls to mapping alloc */
    unsigned int		mapcbig;		/* Count times a big mapping was requested of mapping_alloc */
    unsigned int		mapcbigfails;	/* Times caller asked for a big one but we gave 'em a small one */
	unsigned int		mapcmin;		/* Minimum free mappings to keep */
	unsigned int		mapcmaxalloc;	/* Maximum number of mappings allocated at one time */
	unsigned int		mapcgas[1];		/* Pad to 64 bytes */
	struct mappingflush	mapcflush;
} mappingctl;
#pragma pack()

/* MAPPERBLOK is the number of basic 64-byte mappings per block (ie, per page.) */
#define MAPPERBLOK 63
#define MAPALTHRSH (4*MAPPERBLOK)
#define MAPFRTHRSH (2 * ((MAPALTHRSH + MAPPERBLOK - 1) / MAPPERBLOK))
typedef struct mappingblok {
	unsigned int		mapblokfree[2];	/* Bit map of free mapping entrys */
	addr64_t			mapblokvrswap;	/* Virtual address XORed with physical address */
	unsigned int		mapblokflags;	/* Various flags */
#define mbPerm 0x80000000				/* Block is permanent */
	struct mappingblok	*nextblok;		/* Pointer to the next mapping block */
} mappingblok;

#define mapRemChunk 128

#define mapRetCode	0xF
#define mapRtOK		0
#define mapRtBadLk	1
#define mapRtPerm	2
#define mapRtNotFnd	3
#define mapRtBlock	4
#define mapRtNest	5
#define mapRtRemove	6
#define mapRtMapDup	7

extern mappingctl	mapCtl;				/* Mapping allocation control */

extern addr64_t 	mapping_remove(pmap_t pmap, addr64_t va);	/* Remove a single mapping for this VADDR */
extern mapping 		*mapping_find(pmap_t pmap, addr64_t va, addr64_t *nextva, int full);	/* Finds a mapping */
extern void 		mapping_free_init(vm_offset_t mbl, int perm, boolean_t locked);	/* Sets start and end of a block of mappings */
extern void 		mapping_adjust(void);						/* Adjust free mapping count */
extern void 		mapping_free_prime(void);					/* Primes the mapping block release list */
extern void 		mapping_prealloc(unsigned int);				/* Preallocate mappings for large use */
extern void 		mapping_relpre(void);						/* Releases preallocate request */
extern void 		mapping_init(void);							/* Do initial stuff */
extern mapping 	   *mapping_alloc(int lists);					/* Obtain a mapping */
extern void 		mapping_free(struct mapping *mp);			/* Release a mapping */
extern boolean_t 	mapping_tst_ref(ppnum_t pa);				/* Tests the reference bit of a physical page */
extern boolean_t 	mapping_tst_mod(ppnum_t pa);				/* Tests the change bit of a physical page */
extern void 		mapping_set_ref(ppnum_t pa);				/* Sets the reference bit of a physical page */
extern void 		mapping_clr_ref(ppnum_t pa);				/* Clears the reference bit of a physical page */
extern void 		mapping_set_mod(ppnum_t pa);				/* Sets the change bit of a physical page */
extern void 		mapping_clr_mod(ppnum_t pa);				/* Clears the change bit of a physical page */
extern void 		mapping_protect_phys(ppnum_t pa, vm_prot_t prot);	/* Change protection of all mappings to page */
extern int	 		mapping_protect(pmap_t pmap, addr64_t va, vm_prot_t prot, addr64_t *nextva);	/* Change protection of a single mapping to page */
extern addr64_t		mapping_make(pmap_t pmap, addr64_t va, ppnum_t pa, unsigned int flags, unsigned int size, vm_prot_t prot); /* Make a mapping */
/* Flags for mapping_make */
#define mmFlgBlock		0x80000000	/* This is a block map, use size for number of pages covered */
#define mmFlgUseAttr	0x40000000	/* Use specified attributes */
#define mmFlgPerm		0x20000000	/* Mapping is permanant */
#define mmFlgCInhib		0x00000002	/* Cahching inhibited - use if mapFlgUseAttr set or block */
#define mmFlgGuarded	0x00000001	/* Access guarded - use if mapFlgUseAttr set or block */
extern void 		mapping_purge(ppnum_t pa);		/* Remove all mappings for this physent */
extern addr64_t		mapping_p2v(pmap_t pmap, ppnum_t pa);	/* Finds first virtual mapping of a physical page in a space */
extern void			mapping_drop_busy(struct mapping *mapping);	/* Drops busy count on mapping */
extern phys_entry  *mapping_phys_lookup(ppnum_t pp, unsigned int *pindex);	/* Finds the physical entry for the page */
extern int			mapalc1(struct mappingblok *mb);			/* Finds and allcates a 1-bit mapping entry */
extern int			mapalc2(struct mappingblok *mb);			/* Finds and allcates a 2-bit mapping entry */
extern void			ignore_zero_fault(boolean_t type);			/* Sets up to ignore or honor any fault on page 0 access for the current thread */


extern mapping 		*hw_rem_map(pmap_t pmap, addr64_t va, addr64_t *next);	/* Remove a mapping from the system */
extern mapping 		*hw_purge_map(pmap_t pmap, addr64_t va, addr64_t *next);	/* Remove a regular mapping from the system */
extern mapping 		*hw_purge_space(struct phys_entry *pp, pmap_t pmap);	/* Remove the first mapping for a specific pmap from physentry */
extern mapping 		*hw_purge_phys(struct phys_entry *pp);		/* Remove the first mapping for a physentry */
extern mapping 		*hw_find_map(pmap_t pmap, addr64_t va, addr64_t *nextva);	/* Finds a mapping */
extern addr64_t		hw_add_map(pmap_t pmap, struct mapping *mp);	/* Add a mapping to a pmap */
extern int	 		hw_protect(pmap_t pmap, addr64_t va, vm_prot_t prot, addr64_t *nextva);	/* Change the protection of a virtual page */
extern unsigned int	hw_test_rc(pmap_t pmap, addr64_t va, boolean_t reset);	/* Test and optionally reset the RC bit of specific mapping */

extern unsigned int	hw_phys_walk(struct phys_entry *pp, unsigned int preop, unsigned int op, /* Perform function on all mappings on a physical page */
	unsigned int postop, unsigned int parm);	
#define hwpNoop		0	/* No operation */
#define hwpSPrtPhy	1	/* Sets protection in physent  */
#define hwpSPrtMap	2	/* Sets protection in mapping  */
#define hwpSAtrPhy	3	/* Sets attributes in physent  */
#define hwpSAtrMap	4	/* Sets attributes in mapping  */
#define hwpCRefPhy	5	/* Clears reference in physent  */
#define hwpCRefMap	6	/* Clears reference in mapping  */
#define hwpCCngPhy	7	/* Clears change in physent  */
#define hwpCCngMap	8	/* Clears change in mapping  */
#define hwpSRefPhy	9	/* Sets reference in physent  */
#define hwpSRefMap	10	/* Sets reference in mapping  */
#define hwpSCngPhy	11	/* Sets change in physent  */
#define hwpSCngMap	12	/* Sets change in mapping  */
#define hwpTRefPhy	13	/* Tests reference in physent  */
#define hwpTRefMap	14	/* Tests reference in mapping  */
#define hwpTCngPhy	15	/* Tests change in physent  */
#define hwpTCngMap	16	/* Tests change in mapping  */

extern boolean_t 	hw_tst_mod(struct phys_entry *pp);			/* Tests change bit */
extern void 		hw_set_mod(struct phys_entry *pp);			/* Set change bit */
extern void 		hw_clr_mod(struct phys_entry *pp);			/* Clear change bit */

extern boolean_t 	hw_tst_ref(struct phys_entry *pp);			/* Tests reference bit */
extern void 		hw_set_ref(struct phys_entry *pp);			/* Set reference bit */
extern void 		hw_clr_ref(struct phys_entry *pp);			/* Clear reference bit */

extern void 		hw_set_user_space(pmap_t pmap);				/* Indicate we need a space switch */
extern void 		hw_set_user_space_dis(pmap_t pmap);			/* Indicate we need a space switch (already disabled) */
extern void 		hw_setup_trans(void);						/* Setup hardware for translation */
extern void 		hw_start_trans(void);						/* Start translation for the first time */
extern void 		hw_map_seg(pmap_t pmap, addr64_t seg, addr64_t va);		/* Validate a segment */
extern void 		hw_blow_seg(addr64_t seg);					/* Invalidate a segment */
extern void 		invalidateSegs(pmap_t pmap);				/* Invalidate the segment cache */
extern struct phys_entry *pmap_find_physentry(ppnum_t pa);
extern void			mapLog(unsigned int laddr, unsigned int type, addr64_t va);
extern unsigned int	mapSkipListVerifyC(pmap_t pmap, unsigned long long *dumpa);
extern void			fillPage(ppnum_t pa, unsigned int fill);

extern unsigned int	mappingdeb0;								/* (TEST/DEBUG) */
extern unsigned int	incrVSID;									/* VSID increment value */

#endif /* _PPC_MAPPINGS_H_ */
Commit	Line	Data
1c79356b A	1	/*
	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
43866e37	6	* Copyright (c) 1999-2003 Apple Computer, Inc. All Rights Reserved.
1c79356b	7	*
43866e37 A	8	* This file contains Original Code and/or Modifications of Original Code
	9	* as defined in and that are subject to the Apple Public Source License
	10	* Version 2.0 (the 'License'). You may not use this file except in
	11	* compliance with the License. Please obtain a copy of the License at
	12	* http://www.opensource.apple.com/apsl/ and read it before using this
	13	* file.
	14	*
	15	* The Original Code and all software distributed under the License are
	16	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
1c79356b A	17	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
1c79356b A	18	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
43866e37 A	19	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	20	* Please see the License for the specific language governing rights and
	21	* limitations under the License.
1c79356b A	22	*
	23	* @APPLE_LICENSE_HEADER_END@
	24	*/
	25	/*
	26	* Header files for the hardware virtual memory mapping stuff
	27	*/
	28	#ifndef _PPC_MAPPINGS_H_
	29	#define _PPC_MAPPINGS_H_
	30
55e303ae A	31	#include <cpus.h>
	32
	33	#include <mach/mach_types.h>
	34	#include <mach/vm_types.h>
	35	#include <mach/machine/vm_types.h>
	36	#include <mach/vm_prot.h>
	37	#include <mach/vm_statistics.h>
	38	#include <kern/assert.h>
	39	#include <kern/cpu_number.h>
	40	#include <kern/lock.h>
	41	#include <kern/queue.h>
	42	#include <ppc/proc_reg.h>
	43
	44	/*
	45	* Don't change these structures unless you change the assembly code
	46	*/
	47
	48	/*
	49	* This control block serves as anchor for all virtual mappings of the same physical
	50	* page, i.e., aliases. There is a table for each bank (mem_region). All tables
	51	* must reside in V=R storage and within the first 2GB of memory. Also, the
	52	* mappings to which it points must be on at least a 64-byte boundary. These
	53	* requirements allow a total of 2 bits for status and flags, and allow all address
	54	* calculations to be 32-bit.
	55	*/
	56
	57	#pragma pack(4) /* Make sure the structure stays as we defined it */
	58	typedef struct phys_entry {
	59	addr64_t ppLink; /* Physical pointer to aliased mappings and flags */
	60	#define ppLock 0x8000000000000000LL /* Lock for alias chain */
	61	#define ppN 0x4000000000000000LL /* Not executable */
	62	#define ppFlags 0x000000000000003FLL /* Status and flags */
	63	#define ppI 0x0000000000000020LL /* Cache inhibited */
	64	#define ppIb 58 /* Cache inhibited */
	65	#define ppG 0x0000000000000010LL /* Guarded */
	66	#define ppGb 59 /* Guarded */
	67	#define ppR 0x0000000000000008LL /* Referenced */
	68	#define ppRb 60 /* Referenced */
	69	#define ppC 0x0000000000000004LL /* Changed */
	70	#define ppCb 61 /* Changed */
	71	#define ppPP 0x0000000000000003LL /* Protection */
	72	#define ppPPb 62 /* Protection begin */
	73	#define ppPPe 63 /* Protection end */
	74	} phys_entry;
	75	#pragma pack()
	76
	77	/* Memory may be non-contiguous. This data structure contains info
	78	* for mapping this non-contiguous space into the contiguous
	79	* physical->virtual mapping tables. An array of this type is
	80	* provided to the pmap system at bootstrap by ppc_vm_init.
	81	*
	82	*/
	83
	84	#pragma pack(4) /* Make sure the structure stays as we defined it */
	85	typedef struct mem_region {
	86	phys_entry mrPhysTab; / Base of region table */
	87	ppnum_t mrStart; /* Start of region */
	88	ppnum_t mrEnd; /* Last page in region */
	89	ppnum_t mrAStart; /* Next page in region to allocate */
	90	ppnum_t mrAEnd; /* Last page in region to allocate */
	91	} mem_region_t;
	92	#pragma pack()
	93
	94	#define mrSize sizeof(mem_region_t)
95	#define PMAP_MEM_REGION_MAX 26
96
97	extern mem_region_t pmap_mem_regions[PMAP_MEM_REGION_MAX + 1];
98	extern int pmap_mem_regions_count;
99
100	/* Prototypes */
101
102
103	#pragma pack(4) /* Make sure the structure stays as we defined it */
1c79356b	104	typedef struct PCA { /* PTEG Control Area */
1c79356b A	105	union flgs {
	106	unsigned int PCAallo; /* Allocation controls */
	107	struct PCAalflgs { /* Keep these in order!!! */
	108	unsigned char PCAfree; /* Indicates the slot is free */
de355530	109	unsigned char PCAsteal; /* Steal scan start position */
55e303ae A	110	unsigned char PCAauto; /* Indicates that the PTE was autogenned */
	111	unsigned char PCAmisc; /* Misc. flags */
	112	#define PCAlock 1 /* This locks up the associated PTEG */
	113	#define PCAlockb 31
1c79356b A	114	} PCAalflgs;
1c79356b A	115	} flgs;
1c79356b	116	} PCA;
55e303ae	117	#pragma pack()
1c79356b	118
55e303ae A	119	/* Mappings currently come in two sizes: 64 and 128 bytes. The only difference is the
	120	* number of skiplists (ie, mpLists): 64-byte mappings have 1-4 lists and 128-byte mappings
	121	* have from 5-12. Only 1 in 256 mappings is large, so an average mapping is 64.25 bytes.
	122	* All mappings are 64-byte aligned.
de355530	123	*
55e303ae A	124	* Special note on mpFIP and mpRIP:
	125	* These flags are manipulated under various locks. RIP is always set under an
	126	* exclusive lock while FIP is shared. The only worry is that there is a possibility that
	127	* FIP could be attempted by more than 1 processor at a time. Obviously, one will win.
	128	* The other(s) bail all the way to user state and may refault (or not). There are only
	129	* a few things in mpFlags that are not static, mpFIP, mpRIP, mpRemovable, and mpBusy.
	130	*
	131	* We organize these so that mpFIP is in a byte with static data and mpRIP and mpRemovable
	132	* is in another. That means that we can use a store byte to update the guys without
	133	* worrying about load and reserve. Note that mpFIP must be set atomically because it is
	134	* under a share lock, but it may be clear with a simple store byte. So far as mpRIP
	135	* goes, it is in the same byte as mpRemovable. However, mpRemovable is set atomically
	136	* but never cleared, and mpRIP will not ever be set until after mpRemovable. Note that
	137	* mpRIP is never cleared either.
	138	*
	139	*/
	140	#pragma pack(4) /* Make sure the structure stays as we defined it */
	141	typedef struct mapping {
	142	unsigned int mpFlags; /* 0x000 - Various flags, lock bit. These are static except for lock */
	143	#define mpBusy 0xFF000000 /* Busy count */
	144	#define mpPIndex 0x00FF0000 /* Index into physical table (in words) */
	145	#define mpSpecial 0x00008000 /* Special mapping - processor specific. */
	146	#define mpSpecialb 16 /* Special mapping - processor specific. */
	147	#define mpFIP 0x00004000 /* Fault in progress */
	148	#define mpFIPb 17 /* Fault in progress */
	149	#define mpNest 0x00001000 /* Mapping describes nested pmap */
	150	#define mpNestb 19 /* Mapping describes nested pmap */
	151	#define mpPerm 0x00000800 /* Mapping is permanent */
	152	#define mpPermb 20 /* Mapping is permanent */
	153	#define mpBlock 0x00000400 /* Mapping is a block map - used for V=F or I/O */
	154	#define mpBlockb 21 /* Mapping is a block map - used for V=F or I/O */
	155	#define mpRIP 0x00000080 /* Remove in progress - DO NOT MOVE */
	156	#define mpRIPb 24 /* Remove in progress */
	157	#define mpRemovable 0x00000040 /* Mapping is removable - DO NOT MOVE */
	158	#define mpRemovableb 25 /* Mapping is removable */
	159	#define mpRSVD1 0x00002330 /* Reserved for future use */
	160	#define mpLists 0x0000001F /* Number of skip lists mapping is on, max of 27 */
	161	#define mpListsb 27 /* Number of skip lists mapping is on, max of 27 */
1c79356b	162
55e303ae A	163	unsigned short mpSpace; /* 0x004 - Address space hash */
	164	unsigned short mpBSize; /* 0x006 - Block size - 1 in pages - max block size 256MB */
	165	unsigned int mpPte; /* 0x008 - Offset to PTEG in hash table. Offset to exact PTE if mpHValid set - NOTE: this MUST be 0 for block mappings */
	166	#define mpHValid 0x00000001 /* PTE is entered in hash table */
	167	#define mpHValidb 31 /* PTE is entered in hash table */
	168	ppnum_t mpPAddr; /* 0x00C - Physical page number */
	169	addr64_t mpVAddr; /* 0x010 - Starting virtual address */
	170	#define mpHWFlags 0x0000000000000FFFULL /* Reference/Change, WIMG, AC, N, protection flags from PTE */
	171	#define mpPP 0x0000000000000007ULL /* Protection flags */
	172	#define mpPPb 61
	173	#define mpKKN 0x0000000000000007ULL /* Segment key and no execute flag (nested pmap) */
	174	#define mpKKNb 61
	175	#define mpWIMG 0x0000000000000078ULL /* Attribute bits */
	176	#define mpWIMGb 57
	177	#define mpW 0x0000000000000040ULL
	178	#define mpWb 57
	179	#define mpI 0x0000000000000020ULL
	180	#define mpIb 58
	181	#define mpM 0x0000000000000010ULL
	182	#define mpMb 59
	183	#define mpG 0x0000000000000008ULL
	184	#define mpGb 60
	185	#define mpWIMGe 60
	186	#define mpC 0x0000000000000080ULL /* Change bit */
	187	#define mpCb 56
	188	#define mpR 0x0000000000000100ULL /* Reference bit */
	189	#define mpRb 55
	190	addr64_t mpAlias; /* 0x018 - Pointer to alias mappings of physical page */
	191	#define mpNestReloc mpAlias /* 0x018 - Redefines mpAlias relocation value of vaddr to nested pmap value */
	192	#define mpBlkRemCur mpAlias /* 0x018 - Next offset in block map to remove (this is 4 bytes) */
	193	addr64_t mpList0; /* 0x020 - Forward chain of mappings. This one is always used */
	194	addr64_t mpList[3]; /* 0x028 - Forward chain of mappings. Next higher order */
	195	/* 0x040 - End of basic mapping */
	196	#define mpBasicSize 64
	197	#define mpBasicLists 4
	198	/* note the dependence on kSkipListMaxLists, which must be <= #lists in a 256-byte mapping (ie, <=28) */
	199	/* addr64_t mpList4[8]; 0x040 - First extended list entries */
	200	/* 0x080 - End of first extended mapping */
	201	/* addr64_t mpList12[8]; 0x080 - Second extended list entries */
	202	/* 0x0C0 - End of second extended mapping */
	203	/* addr64_t mpList20[8]; 0x0C0 - Third extended list entries */
	204	/* 0x100 - End of third extended mapping */
1c79356b	205
55e303ae A	206	} mapping;
55e303ae A	207	#pragma pack()
1c79356b A	208
	209	#define MAPPING_NULL ((struct mapping *) 0)
	210
0b4e3aa0 A	211	#define mapDirect 0x08
	212	#define mapRWNA 0x00000000
	213	#define mapRWRO 0x00000001
	214	#define mapRWRW 0x00000002
	215	#define mapRORO 0x00000003
	216
55e303ae A	217	/* All counts are in units of basic 64-byte mappings. A 128-byte mapping is
	218	* just two adjacent 64-byte entries.
	219	*/
	220	#pragma pack(4) /* Make sure the structure stays as we defined it */
9bccf70c A	221
9bccf70c A	222	typedef struct mappingflush {
55e303ae A	223	addr64_t addr; /* Start address to search mapping */
	224	unsigned int spacenum; /* Last space num to search pmap */
	225	unsigned int mapfgas[1]; /* Pad to 64 bytes */
9bccf70c A	226	} mappingflush;
9bccf70c A	227
1c79356b A	228	typedef struct mappingctl {
	229	unsigned int mapclock; /* Mapping allocation lock */
	230	unsigned int mapcrecurse; /* Mapping allocation recursion control */
	231	struct mappingblok mapcnext; / First mapping block with free entries */
	232	struct mappingblok mapclast; / Last mapping block with free entries */
	233	struct mappingblok mapcrel; / List of deferred block releases */
	234	unsigned int mapcfree; /* Total free entries on list */
	235	unsigned int mapcinuse; /* Total entries in use */
	236	unsigned int mapcreln; /* Total blocks on pending release list */
	237	int mapcholdoff; /* Hold off clearing release list */
	238	unsigned int mapcfreec; /* Total calls to mapping free */
	239	unsigned int mapcallocc; /* Total calls to mapping alloc */
55e303ae A	240	unsigned int mapcbig; /* Count times a big mapping was requested of mapping_alloc */
55e303ae A	241	unsigned int mapcbigfails; /* Times caller asked for a big one but we gave 'em a small one */
1c79356b A	242	unsigned int mapcmin; /* Minimum free mappings to keep */
1c79356b A	243	unsigned int mapcmaxalloc; /* Maximum number of mappings allocated at one time */
de355530	244	unsigned int mapcgas[1]; /* Pad to 64 bytes */
55e303ae	245	struct mappingflush mapcflush;
1c79356b	246	} mappingctl;
55e303ae	247	#pragma pack()
1c79356b	248
55e303ae A	249	/* MAPPERBLOK is the number of basic 64-byte mappings per block (ie, per page.) */
55e303ae A	250	#define MAPPERBLOK 63
1c79356b A	251	#define MAPALTHRSH (4*MAPPERBLOK)
	252	#define MAPFRTHRSH (2 * ((MAPALTHRSH + MAPPERBLOK - 1) / MAPPERBLOK))
	253	typedef struct mappingblok {
55e303ae A	254	unsigned int mapblokfree[2]; /* Bit map of free mapping entrys */
55e303ae A	255	addr64_t mapblokvrswap; /* Virtual address XORed with physical address */
1c79356b A	256	unsigned int mapblokflags; /* Various flags */
	257	#define mbPerm 0x80000000 /* Block is permanent */
	258	struct mappingblok nextblok; / Pointer to the next mapping block */
	259	} mappingblok;
	260
55e303ae A	261	#define mapRemChunk 128
	262
	263	#define mapRetCode 0xF
	264	#define mapRtOK 0
	265	#define mapRtBadLk 1
	266	#define mapRtPerm 2
	267	#define mapRtNotFnd 3
	268	#define mapRtBlock 4
	269	#define mapRtNest 5
	270	#define mapRtRemove 6
	271	#define mapRtMapDup 7
	272
1c79356b A	273	extern mappingctl mapCtl; /* Mapping allocation control */
1c79356b A	274
55e303ae A	275	extern addr64_t mapping_remove(pmap_t pmap, addr64_t va); /* Remove a single mapping for this VADDR */
55e303ae A	276	extern mapping mapping_find(pmap_t pmap, addr64_t va, addr64_t nextva, int full); /* Finds a mapping */
1c79356b A	277	extern void mapping_free_init(vm_offset_t mbl, int perm, boolean_t locked); /* Sets start and end of a block of mappings */
	278	extern void mapping_adjust(void); /* Adjust free mapping count */
	279	extern void mapping_free_prime(void); /* Primes the mapping block release list */
	280	extern void mapping_prealloc(unsigned int); /* Preallocate mappings for large use */
	281	extern void mapping_relpre(void); /* Releases preallocate request */
	282	extern void mapping_init(void); /* Do initial stuff */
55e303ae	283	extern mapping mapping_alloc(int lists); / Obtain a mapping */
1c79356b	284	extern void mapping_free(struct mapping mp); / Release a mapping */
55e303ae A	285	extern boolean_t mapping_tst_ref(ppnum_t pa); /* Tests the reference bit of a physical page */
	286	extern boolean_t mapping_tst_mod(ppnum_t pa); /* Tests the change bit of a physical page */
	287	extern void mapping_set_ref(ppnum_t pa); /* Sets the reference bit of a physical page */
	288	extern void mapping_clr_ref(ppnum_t pa); /* Clears the reference bit of a physical page */
	289	extern void mapping_set_mod(ppnum_t pa); /* Sets the change bit of a physical page */
	290	extern void mapping_clr_mod(ppnum_t pa); /* Clears the change bit of a physical page */
	291	extern void mapping_protect_phys(ppnum_t pa, vm_prot_t prot); /* Change protection of all mappings to page */
	292	extern int mapping_protect(pmap_t pmap, addr64_t va, vm_prot_t prot, addr64_t nextva); / Change protection of a single mapping to page */
	293	extern addr64_t mapping_make(pmap_t pmap, addr64_t va, ppnum_t pa, unsigned int flags, unsigned int size, vm_prot_t prot); /* Make a mapping */
	294	/* Flags for mapping_make */
	295	#define mmFlgBlock 0x80000000 /* This is a block map, use size for number of pages covered */
	296	#define mmFlgUseAttr 0x40000000 /* Use specified attributes */
	297	#define mmFlgPerm 0x20000000 /* Mapping is permanant */
	298	#define mmFlgCInhib 0x00000002 /* Cahching inhibited - use if mapFlgUseAttr set or block */
	299	#define mmFlgGuarded 0x00000001 /* Access guarded - use if mapFlgUseAttr set or block */
	300	extern void mapping_purge(ppnum_t pa); /* Remove all mappings for this physent */
	301	extern addr64_t mapping_p2v(pmap_t pmap, ppnum_t pa); /* Finds first virtual mapping of a physical page in a space */
	302	extern void mapping_drop_busy(struct mapping mapping); / Drops busy count on mapping */
	303	extern phys_entry mapping_phys_lookup(ppnum_t pp, unsigned int pindex); /* Finds the physical entry for the page */
	304	extern int mapalc1(struct mappingblok mb); / Finds and allcates a 1-bit mapping entry */
	305	extern int mapalc2(struct mappingblok mb); / Finds and allcates a 2-bit mapping entry */
1c79356b A	306	extern void ignore_zero_fault(boolean_t type); /* Sets up to ignore or honor any fault on page 0 access for the current thread */
	307
	308
55e303ae A	309	extern mapping hw_rem_map(pmap_t pmap, addr64_t va, addr64_t next); /* Remove a mapping from the system */
	310	extern mapping hw_purge_map(pmap_t pmap, addr64_t va, addr64_t next); /* Remove a regular mapping from the system */
	311	extern mapping hw_purge_space(struct phys_entry pp, pmap_t pmap); /* Remove the first mapping for a specific pmap from physentry */
	312	extern mapping hw_purge_phys(struct phys_entry pp); /* Remove the first mapping for a physentry */
	313	extern mapping hw_find_map(pmap_t pmap, addr64_t va, addr64_t nextva); /* Finds a mapping */
	314	extern addr64_t hw_add_map(pmap_t pmap, struct mapping mp); / Add a mapping to a pmap */
	315	extern int hw_protect(pmap_t pmap, addr64_t va, vm_prot_t prot, addr64_t nextva); / Change the protection of a virtual page */
	316	extern unsigned int hw_test_rc(pmap_t pmap, addr64_t va, boolean_t reset); /* Test and optionally reset the RC bit of specific mapping */
	317
	318	extern unsigned int hw_phys_walk(struct phys_entry pp, unsigned int preop, unsigned int op, / Perform function on all mappings on a physical page */
	319	unsigned int postop, unsigned int parm);
	320	#define hwpNoop 0 /* No operation */
	321	#define hwpSPrtPhy 1 /* Sets protection in physent */
	322	#define hwpSPrtMap 2 /* Sets protection in mapping */
	323	#define hwpSAtrPhy 3 /* Sets attributes in physent */
	324	#define hwpSAtrMap 4 /* Sets attributes in mapping */
	325	#define hwpCRefPhy 5 /* Clears reference in physent */
	326	#define hwpCRefMap 6 /* Clears reference in mapping */
	327	#define hwpCCngPhy 7 /* Clears change in physent */
	328	#define hwpCCngMap 8 /* Clears change in mapping */
	329	#define hwpSRefPhy 9 /* Sets reference in physent */
	330	#define hwpSRefMap 10 /* Sets reference in mapping */
	331	#define hwpSCngPhy 11 /* Sets change in physent */
	332	#define hwpSCngMap 12 /* Sets change in mapping */
	333	#define hwpTRefPhy 13 /* Tests reference in physent */
	334	#define hwpTRefMap 14 /* Tests reference in mapping */
	335	#define hwpTCngPhy 15 /* Tests change in physent */
	336	#define hwpTCngMap 16 /* Tests change in mapping */
1c79356b A	337
	338	extern boolean_t hw_tst_mod(struct phys_entry pp); / Tests change bit */
	339	extern void hw_set_mod(struct phys_entry pp); / Set change bit */
	340	extern void hw_clr_mod(struct phys_entry pp); / Clear change bit */
	341
	342	extern boolean_t hw_tst_ref(struct phys_entry pp); / Tests reference bit */
	343	extern void hw_set_ref(struct phys_entry pp); / Set reference bit */
	344	extern void hw_clr_ref(struct phys_entry pp); / Clear reference bit */
	345
1c79356b A	346	extern void hw_set_user_space(pmap_t pmap); /* Indicate we need a space switch */
1c79356b A	347	extern void hw_set_user_space_dis(pmap_t pmap); /* Indicate we need a space switch (already disabled) */
55e303ae A	348	extern void hw_setup_trans(void); /* Setup hardware for translation */
	349	extern void hw_start_trans(void); /* Start translation for the first time */
	350	extern void hw_map_seg(pmap_t pmap, addr64_t seg, addr64_t va); /* Validate a segment */
	351	extern void hw_blow_seg(addr64_t seg); /* Invalidate a segment */
	352	extern void invalidateSegs(pmap_t pmap); /* Invalidate the segment cache */
	353	extern struct phys_entry *pmap_find_physentry(ppnum_t pa);
	354	extern void mapLog(unsigned int laddr, unsigned int type, addr64_t va);
	355	extern unsigned int mapSkipListVerifyC(pmap_t pmap, unsigned long long *dumpa);
	356	extern void fillPage(ppnum_t pa, unsigned int fill);
1c79356b A	357
	358	extern unsigned int mappingdeb0; /* (TEST/DEBUG) */
	359	extern unsigned int incrVSID; /* VSID increment value */
	360
	361	#endif /* _PPC_MAPPINGS_H_ */
	362