[apple/xnu.git] / osfmk / ppc / savearea_asm.s

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This 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 OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
#include <assym.s>
#include <debug.h>
#include <cpus.h>
#include <db_machine_commands.h>
#include <mach_rt.h>
	
#include <mach_debug.h>
#include <ppc/asm.h>
#include <ppc/proc_reg.h>
#include <ppc/exception.h>
#include <ppc/Performance.h>
#include <ppc/exception.h>
#include <ppc/pmap_internals.h>
#include <mach/ppc/vm_param.h>
	
			.text

/*
 *			This routine will add a savearea block to the free list.
 *			Note really well: we can take NO exceptions of any kind,
 *			including a PTE miss once the savearea lock is held. That's
 *			a guaranteed deadlock.  That means we must disable for interrutions
 *			and turn all translation off.
 *
 *			Note that the savearea list should NEVER be empty
 */

ENTRY(save_queue,TAG_NO_FRAME_USED)


			mfsprg	r9,2						; Get the feature flags
			mr		r11,r3						; Save the block
			mtcrf	0x04,r9						; Set the features			
			mfmsr	r12							; Get the MSR
			lis		r10,HIGH_ADDR(EXT(saveanchor))	; Get the high part of the anchor
			andi.	r3,r12,0x7FCF				; Turn off all translation and rupts
			ori		r10,r10,LOW_ADDR(EXT(saveanchor))	; Bottom half of the anchor 

			bt		pfNoMSRirb,sqNoMSR			; No MSR...

			mtmsr	r3							; Translation and all off
			isync								; Toss prefetch
			b		sqNoMSRx
			
sqNoMSR:	li		r0,loadMSR					; Get the MSR setter SC
			sc									; Set it
sqNoMSRx:
			
#if 0
			rlwinm.	r3,r11,0,0,19				/* (TEST/DEBUG) */
			bne+	notraceit					/* (TEST/DEBUG) */
			BREAKPOINT_TRAP						/* (TEST/DEBUG) */
notraceit:										/* (TEST/DEBUG) */
#else
			rlwinm	r3,r11,0,0,19				/* Make sure it's clean and tidy */
#endif

sqlck:		lwarx	r9,0,r10					/* Grab the lock value */
			li		r8,1						/* Use part of the delay time */
			mr.		r9,r9						/* Is it locked? */
			bne-	sqlcks						/* Yeah, wait for it to clear... */
			stwcx.	r8,0,r10					/* Try to seize that there durn lock */
			beq+	sqlckd						/* Got it... */
			b		sqlck						/* Collision, try again... */
			
sqlcks:		lwz		r9,SVlock(r10)				/* Get that lock in here */
			mr.		r9,r9						/* Is it free yet? */
			beq+	sqlck						/* Yeah, try for it again... */
			b		sqlcks						/* Sniff away... */
			
sqlckd:		isync								/* Make sure translation is off */
			lwz		r7,SVfree(r10)				/* Get the free save area list anchor */
			lwz		r6,SVcount(r10)				/* Get the total count of saveareas */
			stw		r3,SVfree(r10)				/* Queue in the new one */
			addi	r6,r6,sac_cnt				/* Count the ones we are linking in */
			stw		r7,SACnext(r3)				/* Queue the old first one off of us */
			li		r8,0						/* Get a free lock value */
			stw		r6,SVcount(r10)				/* Save the new count */
			
			sync								/* Make sure everything is done */
			stw		r8,SVlock(r10)				/* Unlock the savearea chain */
			
			mtmsr	r12							/* Restore interrupts and translation */
			isync								/* Dump any speculations */

#if 0
			lis		r0,HIGH_ADDR(CutTrace)		/* (TEST/DEBUG) */
			li		r2,0x2201					; (TEST/DEBUG)
			oris	r0,r0,LOW_ADDR(CutTrace)	/* (TEST/DEBUG) */
			sc									/* (TEST/DEBUG) */
#endif

			blr									/* Leave... */


/*
 *			This routine will find and remove an empty savearea block from the free list.
 *			Note really well: we can take NO exceptions of any kind,
 *			including a PTE miss once the savearea lock is held. That's
 *			a guaranteed deadlock.  That means we must disable for interrutions
 *			and turn all translation off.
 *
 *			We pass back the virtual address of the one we just released
 *			or a zero if none to free.
 *
 *			Note that the savearea list should NEVER be empty
 */

ENTRY(save_dequeue,TAG_NO_FRAME_USED)


			mfsprg	r9,2						; Get the feature flags
			mfmsr	r12							/* Get the MSR */
			mtcrf	0x04,r9						; Set the features			
			lis		r10,HIGH_ADDR(EXT(saveanchor))	/* Get the high part of the anchor */
			andi.	r3,r12,0x7FCF				/* Turn off all translation and 'rupts */
			ori		r10,r10,LOW_ADDR(EXT(saveanchor))	/* Bottom half of the anchor */

			bt		pfNoMSRirb,sdNoMSR			; No MSR...

			mtmsr	r3							; Translation and all off
			isync								; Toss prefetch
			b		sdNoMSRx
			
sdNoMSR:	li		r0,loadMSR					; Get the MSR setter SC
			sc									; Set it
sdNoMSRx:

sdqlck:		lwarx	r9,0,r10					/* Grab the lock value */
			li		r8,1						/* Use part of the delay time */
			mr.		r9,r9						/* Is it locked? */
			bne-	sdqlcks						/* Yeah, wait for it to clear... */
			stwcx.	r8,0,r10					/* Try to seize that there durn lock */
			beq+	sdqlckd						/* Got it... */
			b		sdqlck						/* Collision, try again... */
			
sdqlcks:	lwz		r9,SVlock(r10)				/* Get that lock in here */
			mr.		r9,r9						/* Is it free yet? */
			beq+	sdqlck						/* Yeah, try for it again... */
			b		sdqlcks						/* Sniff away... */
			

sdqlckd:	lwz		r3,SVfree(r10)				/* Get the free save area list anchor */
			la		r5,SVfree(r10)				/* Remember that the we're just starting out */
			lwz		r6,SVcount(r10)				/* Get the total count of saveareas for later */
			lis		r8,sac_empty>>16			/* Get the empty block indication */
			
sdqchk:		lwz		r4,SACalloc(r3)				/* Get the allocation flags */
			lwz		r9,SACflags(r3)				/* Get the flags */
			lwz		r7,SACnext(r3)				/* Point on to the next one */
			andis.	r9,r9,hi16(sac_perm)		/* Is this permanently allocated? */
			cmplw	cr1,r4,r8					/* Does this look empty? */
			bne-	sdqperm						/* It's permanent, can't release... */
			beq-	cr1,sdqfnd					/* Yeah, empty... */

sdqperm:	la		r5,SACnext(r3)				/* Remember the last guy */
			mr.		r3,r7						/* Any more left? */
			bne+	sdqchk						/* Yeah... */
			b		sdqunlk						/* Nope, just go unlock and leave... */
			
sdqfnd:		subi	r6,r6,sac_cnt				/* Back off the number of saveareas in here */
			stw		r7,0(r5)					/* Dequeue our guy */
			lwz		r9,SACvrswap(r3)			/* Get addressing conversion */
			stw		r6,SVcount(r10)				/* Back off the count for this block */
			xor		r3,r3,r9					/* Flip to virtual addressing */

sdqunlk:	li		r8,0						/* Get a free lock value */			
			sync								/* Make sure everything is done */
			stw		r8,SVlock(r10)				/* Unlock the savearea chain */
			
			mtmsr	r12							/* Restore interrupts and translation */
			isync								/* Dump any speculations */

#if 0
			lis		r0,HIGH_ADDR(CutTrace)		/* (TEST/DEBUG) */
			li		r2,0x2202					; (TEST/DEBUG)
			oris	r0,r0,LOW_ADDR(CutTrace)	/* (TEST/DEBUG) */
			sc									/* (TEST/DEBUG) */
#endif

			blr									/* Leave... */


/*
 *			This routine will obtain a savearea from the free list.
 *			Note really well: we can take NO exceptions of any kind,
 *			including a PTE miss once the savearea lock is held. That's
 *			a guaranteed deadlock.  That means we must disable for interrutions
 *			and turn all translation off.
 *
 *			We pass back the virtual address of the one we just obtained
 *			or a zero if none to allocate.
 *
 *			Note that the savearea list should NEVER be empty
 *			NOTE!!! NEVER USE R0, R2, or R12 IN HERE THAT WAY WE DON'T NEED A
 *			STACK FRAME IN FPU_SAVE, FPU_SWITCH, VEC_SAVE, OR VEC_SWITCH.
 */

ENTRY(save_get_phys,TAG_NO_FRAME_USED)
			
			cmplw	cr1,r1,r1					; Set CR1_eq to indicate we want physical address
			b		csaveget					; Join the common...

ENTRY(save_get,TAG_NO_FRAME_USED)
			
			cmplwi	cr1,r1,0					; Set CR1_ne to indicate we want virtual address

csaveget:	mfsprg	r9,2						; Get the feature flags
			mfmsr	r11							; Get the MSR 
			mtcrf	0x04,r9						; Set the features			
			lis		r10,HIGH_ADDR(EXT(saveanchor))	/* Get the high part of the anchor */
			andi.	r3,r11,0x7FCF				/* Turn off all translation and 'rupts */
			ori		r10,r10,LOW_ADDR(EXT(saveanchor))	/* Bottom half of the anchor */

			bt		pfNoMSRirb,sgNoMSR			; No MSR...

			mtmsr	r3							; Translation and all off
			isync								; Toss prefetch
			b		sgNoMSRx
			
sgNoMSR:	mr		r9,r0						; Save this
			li		r0,loadMSR					; Get the MSR setter SC
			sc									; Set it
			mr		r0,r9						; Restore it

sgNoMSRx:

sglck:		lwarx	r9,0,r10					/* Grab the lock value */
			li		r7,1						/* Use part of the delay time */
			mr.		r9,r9						/* Is it locked? */
			bne-	sglcks						/* Yeah, wait for it to clear... */
			stwcx.	r7,0,r10					/* Try to seize that there durn lock */
			beq+	sglckd						/* Got it... */
			b		sglck						/* Collision, try again... */
			
sglcks:		lwz		r9,SVlock(r10)				/* Get that lock in here */
			mr.		r9,r9						/* Is it free yet? */
			beq+	sglck						/* Yeah, try for it again... */
			b		sglcks						/* Sniff away... */
			
sglckd:		isync								/* Make sure translation is off */
			lwz		r8,SVfree(r10)				/* Get the head of the save area list */
			lwz		r9,SVinuse(r10)				/* Get the inuse field */

			lwz		r7,SACalloc(r8)				/* Pick up the allocation bits */
			lwz		r5,SACvrswap(r8)			/* Get real to virtual translation */
			mr.		r7,r7						/* Can we use the first one? */
			blt		use1st						/* Yeah... */
			
			andis.	r7,r7,0x8000				/* Show we used the second and remember if it was the last */
			addi	r3,r8,0x0800				/* Point to the first one */
			b		gotsave						/* We have the area now... */

use1st:		andis.	r7,r7,0x4000				/* Mark first gone and remember if empty */
			mr		r3,r8						/* Set the save area */
			
gotsave:	stw		r7,SACalloc(r8)				/* Put back the allocation bits */
			bne		nodqsave					/* There's still an empty slot, don't dequeue... */

			lwz		r4,SACnext(r8)				/* Get the next in line */
			stw		r4,SVfree(r10)				/* Dequeue our now empty save area block */
			
nodqsave:	lis		r6,HIGH_ADDR(SAVattach)		/* Show that it is attached for now */
			li		r4,0						/* Clear this for the lock */
			stw		r6,SAVflags(r3)				/* Set the flags to attached */
			addi	r9,r9,1						/* Bump up the inuse count */
			stw		r4,SAVprev(r3)				/* Make sure that backchain is clear */
			stw		r9,SVinuse(r10)				/* Set the inuse field */
			sync								/* Make sure all stores are done */
			stw		r4,SVlock(r10)				/* Unlock both save and trace areas */
			mtmsr	r11							/* Restore translation and exceptions */
			isync								/* Make sure about it */
	
#if 0
			mr		r11,r0						/* (TEST/DEBUG) */
			mr		r7,r2						/* (TEST/DEBUG) */
			lis		r0,HIGH_ADDR(CutTrace)		/* (TEST/DEBUG) */
			li		r2,0x2203					; (TEST/DEBUG)
			oris	r0,r0,LOW_ADDR(CutTrace)	/* (TEST/DEBUG) */
			sc									/* (TEST/DEBUG) */
			mr		r0,r11						/* (TEST/DEBUG) */
			mr		r2,r7						/* (TEST/DEBUG) */
#endif			
			
			li		r7,0						; NOTE WELL: we set R7 to zero for vector and float saving code in cswtch.s
			beqlr-	cr1							; Return now if we want the physical address
			xor		r3,r3,r5					/* Get the virtual address */
			blr									/* Leave... */
		

/*
 *			This routine will return a savearea to the free list.
 *			Note really well: we can take NO exceptions of any kind,
 *			including a PTE miss once the savearea lock is held. That's
 *			a guaranteed deadlock.  That means we must disable for interrutions
 *			and turn all translation off.
 *
 *			We take a virtual address.
 *
 */

ENTRY(save_ret,TAG_NO_FRAME_USED)

#if 0
			cmplwi	r3,0x1000					; (TEST/DEBUG)
			bgt+	notpage0					; (TEST/DEBUG)
			BREAKPOINT_TRAP						/* (TEST/DEBUG) */

notpage0:	rlwinm	r6,r3,0,0,19				/* (TEST/DEBUG) */
			rlwinm	r7,r3,21,31,31				/* (TEST/DEBUG) */
			lis		r8,0x8000					/* (TEST/DEBUG) */
			lwz		r6,SACalloc(r6)				/* (TEST/DEBUG) */
			srw		r8,r8,r7					/* (TEST/DEBUG) */
			and.	r8,r8,r6					/* (TEST/DEBUG) */
			beq+	nodoublefret				/* (TEST/DEBUG) */
			BREAKPOINT_TRAP						/* (TEST/DEBUG) */
			
nodoublefret:									/* (TEST/DEBUG) */		
#endif

			mfsprg	r9,2						; Get the feature flags
			lwz		r7,SAVflags(r3)				/* Get the flags */
			rlwinm	r6,r3,0,0,19				/* Round back down to the savearea page block */
			andis.	r7,r7,HIGH_ADDR(SAVinuse)	/* Still in use? */
			mfmsr	r12							/* Get the MSR */
			bnelr-								/* Still in use, just leave... */
			lwz		r5,SACvrswap(r6)			/* Get the conversion to real */
			mr		r8,r3						; Save the savearea address
			mtcrf	0x04,r9						; Set the features			
			lis		r10,HIGH_ADDR(EXT(saveanchor))	/* Get the high part of the anchor */
			andi.	r3,r12,0x7FCF				/* Turn off all translation and 'rupts */
			ori		r10,r10,LOW_ADDR(EXT(saveanchor))	/* Bottom half of the anchor */

			bt		pfNoMSRirb,srNoMSR			; No MSR...

			mtmsr	r3							; Translation and all off
			isync								; Toss prefetch
			b		srNoMSRx
			
srNoMSR:	li		r0,loadMSR					; Get the MSR setter SC
			sc									; Set it
srNoMSRx:

			mfsprg	r11,1						/* Get the active save area */
			xor		r3,r8,r5					/* Get the real address of the savearea */
			cmplw	r11,r3						/* Are we trying to toss the active one? */
			xor		r6,r6,r5					/* Make the savearea block real also */
			beq-	srbigtimepanic				/* This is a no-no... */

			rlwinm	r7,r3,21,31,31				/* Get position of savearea in block */
			lis		r8,0x8000					/* Build a bit mask and assume first savearea */
			srw		r8,r8,r7					/* Get bit position of do deallocate */
			
srlck:		lwarx	r11,0,r10					/* Grab the lock value */
			li		r7,1						/* Use part of the delay time */
			mr.		r11,r11						/* Is it locked? */
			bne-	srlcks						/* Yeah, wait for it to clear... */
			stwcx.	r7,0,r10					/* Try to seize that there durn lock */
			beq+	srlckd						/* Got it... */
			b		srlck						/* Collision, try again... */
			
srlcks:		lwz		r11,SVlock(r10)				/* Get that lock in here */
			mr.		r11,r11						/* Is it free yet? */
			beq+	srlck						/* Yeah, try for it again... */
			b		srlcks						/* Sniff away... */
					
srlckd:		isync								/* Toss preexecutions */
			lwz		r11,SACalloc(r6)			/* Get the allocation for this block */
			lwz		r7,SVinuse(r10)				/* Get the in use count */
			or		r11,r11,r8					/* Turn on our bit */
			subi	r7,r7,1						/* We released one, adjust count */
			cmplw	r11,r8						/* Is our's the only one free? */
			stw		r7,SVinuse(r10)				/* Save out count */
			stw		r11,SACalloc(r6)			/* Save it out */
			bne+	srtrest						/* Nope, then the block is already on the free list */

			lwz		r11,SVfree(r10)				/* Get the old head of the free list */
			stw		r6,SVfree(r10)				/* Point the head at us now */
			stw		r11,SACnext(r6)				/* Point us at the old last */
		
srtrest:	li		r8,0						/* Get set to clear the savearea lock */
			sync								/* Make sure it's all out there */
			stw		r8,SVlock(r10)				/* Unlock it */
			mtmsr	r12							/* Restore interruptions and translation */
			isync

#if 0
			lis		r0,HIGH_ADDR(CutTrace)		/* (TEST/DEBUG) */
			li		r2,0x2204					; (TEST/DEBUG)
			oris	r0,r0,LOW_ADDR(CutTrace)	/* (TEST/DEBUG) */
			sc									/* (TEST/DEBUG) */
#endif

			blr									/* Go away... */

srbigtimepanic:
			lis		r6,HIGH_ADDR(EXT(panic))	/* First half of panic call */
			lis		r3,HIGH_ADDR(EXT(srfreeactive))	/* First half of panic string */
			ori		r6,r6,LOW_ADDR(EXT(panic))	/* Second half of panic call */
			ori		r3,r3,LOW_ADDR(EXT(srfreeactive))	/* Second half of panic string */
			mtlr	r6							/* Get the address of the panic routine */
			mtmsr	r12							/* Restore interruptions and translation */
			isync
			blrl								/* Panic... */

			.data
EXT(srfreeactive):
			STRINGD	"save_ret: Attempting to release the active savearea!!!!\000"
			.text


/*
 *			struct savearea	*save_cpv(struct savearea *);	 Converts a physical savearea address to virtual
 */

			.align	5
			.globl	EXT(save_cpv)

LEXT(save_cpv)
			
			mfmsr	r10							; Get the current MSR
			rlwinm	r4,r3,0,0,19				; Round back to the start of the physical savearea block
			andi.	r9,r10,0x7FEF				; Turn off interrupts and data translation
			mtmsr	r9							; Disable DR and EE
			isync
			
			lwz		r4,SACvrswap(r4)			; Get the conversion to virtual
			mtmsr	r10							; Interrupts and DR back on
			isync
			xor		r3,r3,r4					; Convert to physical
			blr


/*
 *			This routine will return the virtual address of the first free savearea
 *			block and disable for interruptions.
 *			Note really well: this is only for debugging, don't expect it to always work!
 *
 *			We take a virtual address in R3 to save the original MSR, and 
 *			return the virtual address.
 *
 */

ENTRY(save_deb,TAG_NO_FRAME_USED)

			mfsprg	r9,2						; Get the feature flags
			mfmsr	r12							/* Get the MSR */
			lis		r10,HIGH_ADDR(EXT(saveanchor))	/* Get the high part of the anchor */
			mtcrf	0x04,r9						; Set the features			
			stw		r12,0(r3)					/* Save it */
			andi.	r3,r12,0x7FCF				/* Turn off all translation and 'rupts */
			ori		r10,r10,LOW_ADDR(EXT(saveanchor))	/* Bottom half of the anchor */

			bt		pfNoMSRirb,sdbNoMSR			; No MSR...

			mtmsr	r3							; Translation and all off
			isync								; Toss prefetch
			b		sdbNoMSRx
			
sdbNoMSR:	li		r0,loadMSR					; Get the MSR setter SC
			sc									; Set it
sdbNoMSRx:

			lwz		r3,SVfree(r10)				/* Get the physical first in list */
			andi.	r11,r12,0x7FFF				/* Clear only interruption */
			lwz		r5,SACvrswap(r3)			/* Get the conversion to virtual */
			mtmsr	r11							/* Restore DAT but not INT */
			xor		r3,r3,r5					/* Make it virtual */
			isync
			blr
Commit	Line	Data
1c79356b A	1	/*
	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* The contents of this file constitute Original Code as defined in and
	7	* are subject to the Apple Public Source License Version 1.1 (the
	8	* "License"). You may not use this file except in compliance with the
	9	* License. Please obtain a copy of the License at
	10	* http://www.apple.com/publicsource and read it before using this file.
	11	*
	12	* This Original Code and all software distributed under the License are
	13	* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	14	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	15	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	16	* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
	17	* License for the specific language governing rights and limitations
	18	* under the License.
	19	*
	20	* @APPLE_LICENSE_HEADER_END@
	21	*/
	22	#include <assym.s>
	23	#include <debug.h>
	24	#include <cpus.h>
	25	#include <db_machine_commands.h>
	26	#include <mach_rt.h>
	27
	28	#include <mach_debug.h>
	29	#include <ppc/asm.h>
	30	#include <ppc/proc_reg.h>
	31	#include <ppc/exception.h>
	32	#include <ppc/Performance.h>
	33	#include <ppc/exception.h>
	34	#include <ppc/pmap_internals.h>
	35	#include <mach/ppc/vm_param.h>
	36
	37	.text
	38
	39	/*
	40	* This routine will add a savearea block to the free list.
	41	* Note really well: we can take NO exceptions of any kind,
	42	* including a PTE miss once the savearea lock is held. That's
	43	* a guaranteed deadlock. That means we must disable for interrutions
	44	* and turn all translation off.
	45	*
	46	* Note that the savearea list should NEVER be empty
	47	*/
	48
	49	ENTRY(save_queue,TAG_NO_FRAME_USED)
	50
	51
150bd074 A	52	mfsprg r9,2 ; Get the feature flags
	53	mr r11,r3 ; Save the block
	54	mtcrf 0x04,r9 ; Set the features
	55	mfmsr r12 ; Get the MSR
	56	lis r10,HIGH_ADDR(EXT(saveanchor)) ; Get the high part of the anchor
	57	andi. r3,r12,0x7FCF ; Turn off all translation and rupts
	58	ori r10,r10,LOW_ADDR(EXT(saveanchor)) ; Bottom half of the anchor
	59
	60	bt pfNoMSRirb,sqNoMSR ; No MSR...
	61
	62	mtmsr r3 ; Translation and all off
	63	isync ; Toss prefetch
	64	b sqNoMSRx
	65
	66	sqNoMSR: li r0,loadMSR ; Get the MSR setter SC
	67	sc ; Set it
	68	sqNoMSRx:
1c79356b A	69
1c79356b A	70	#if 0
150bd074	71	rlwinm. r3,r11,0,0,19 /* (TEST/DEBUG) */
1c79356b A	72	bne+ notraceit /* (TEST/DEBUG) */
	73	BREAKPOINT_TRAP /* (TEST/DEBUG) */
	74	notraceit: /* (TEST/DEBUG) */
	75	#else
150bd074	76	rlwinm r3,r11,0,0,19 /* Make sure it's clean and tidy */
1c79356b A	77	#endif
1c79356b A	78
1c79356b A	79	sqlck: lwarx r9,0,r10 /* Grab the lock value */
	80	li r8,1 /* Use part of the delay time */
	81	mr. r9,r9 /* Is it locked? */
	82	bne- sqlcks /* Yeah, wait for it to clear... */
	83	stwcx. r8,0,r10 /* Try to seize that there durn lock */
	84	beq+ sqlckd /* Got it... */
	85	b sqlck /* Collision, try again... */
	86
	87	sqlcks: lwz r9,SVlock(r10) /* Get that lock in here */
	88	mr. r9,r9 /* Is it free yet? */
	89	beq+ sqlck /* Yeah, try for it again... */
	90	b sqlcks /* Sniff away... */
	91
	92	sqlckd: isync /* Make sure translation is off */
	93	lwz r7,SVfree(r10) /* Get the free save area list anchor */
	94	lwz r6,SVcount(r10) /* Get the total count of saveareas */
	95	stw r3,SVfree(r10) /* Queue in the new one */
	96	addi r6,r6,sac_cnt /* Count the ones we are linking in */
	97	stw r7,SACnext(r3) /* Queue the old first one off of us */
	98	li r8,0 /* Get a free lock value */
	99	stw r6,SVcount(r10) /* Save the new count */
	100
	101	sync /* Make sure everything is done */
	102	stw r8,SVlock(r10) /* Unlock the savearea chain */
	103
	104	mtmsr r12 /* Restore interrupts and translation */
	105	isync /* Dump any speculations */
	106
	107	#if 0
	108	lis r0,HIGH_ADDR(CutTrace) /* (TEST/DEBUG) */
	109	li r2,0x2201 ; (TEST/DEBUG)
	110	oris r0,r0,LOW_ADDR(CutTrace) /* (TEST/DEBUG) */
	111	sc /* (TEST/DEBUG) */
	112	#endif
	113
	114	blr /* Leave... */
	115
	116
	117	/*
	118	* This routine will find and remove an empty savearea block from the free list.
	119	* Note really well: we can take NO exceptions of any kind,
	120	* including a PTE miss once the savearea lock is held. That's
	121	* a guaranteed deadlock. That means we must disable for interrutions
	122	* and turn all translation off.
	123	*
	124	* We pass back the virtual address of the one we just released
	125	* or a zero if none to free.
	126	*
	127	* Note that the savearea list should NEVER be empty
	128	*/
	129
	130	ENTRY(save_dequeue,TAG_NO_FRAME_USED)
	131
	132
150bd074	133	mfsprg r9,2 ; Get the feature flags
1c79356b	134	mfmsr r12 /* Get the MSR */
150bd074	135	mtcrf 0x04,r9 ; Set the features
1c79356b	136	lis r10,HIGH_ADDR(EXT(saveanchor)) /* Get the high part of the anchor */
150bd074	137	andi. r3,r12,0x7FCF /* Turn off all translation and 'rupts */
1c79356b	138	ori r10,r10,LOW_ADDR(EXT(saveanchor)) /* Bottom half of the anchor */
1c79356b	139
150bd074 A	140	bt pfNoMSRirb,sdNoMSR ; No MSR...
	141
	142	mtmsr r3 ; Translation and all off
	143	isync ; Toss prefetch
	144	b sdNoMSRx
	145
	146	sdNoMSR: li r0,loadMSR ; Get the MSR setter SC
	147	sc ; Set it
	148	sdNoMSRx:
1c79356b A	149
	150	sdqlck: lwarx r9,0,r10 /* Grab the lock value */
	151	li r8,1 /* Use part of the delay time */
	152	mr. r9,r9 /* Is it locked? */
	153	bne- sdqlcks /* Yeah, wait for it to clear... */
	154	stwcx. r8,0,r10 /* Try to seize that there durn lock */
	155	beq+ sdqlckd /* Got it... */
	156	b sdqlck /* Collision, try again... */
	157
	158	sdqlcks: lwz r9,SVlock(r10) /* Get that lock in here */
	159	mr. r9,r9 /* Is it free yet? */
	160	beq+ sdqlck /* Yeah, try for it again... */
	161	b sdqlcks /* Sniff away... */
	162
	163
	164	sdqlckd: lwz r3,SVfree(r10) /* Get the free save area list anchor */
	165	la r5,SVfree(r10) /* Remember that the we're just starting out */
	166	lwz r6,SVcount(r10) /* Get the total count of saveareas for later */
	167	lis r8,sac_empty>>16 /* Get the empty block indication */
	168
	169	sdqchk: lwz r4,SACalloc(r3) /* Get the allocation flags */
	170	lwz r9,SACflags(r3) /* Get the flags */
	171	lwz r7,SACnext(r3) /* Point on to the next one */
	172	andis. r9,r9,hi16(sac_perm) /* Is this permanently allocated? */
	173	cmplw cr1,r4,r8 /* Does this look empty? */
	174	bne- sdqperm /* It's permanent, can't release... */
	175	beq- cr1,sdqfnd /* Yeah, empty... */
	176
	177	sdqperm: la r5,SACnext(r3) /* Remember the last guy */
	178	mr. r3,r7 /* Any more left? */
	179	bne+ sdqchk /* Yeah... */
	180	b sdqunlk /* Nope, just go unlock and leave... */
	181
	182	sdqfnd: subi r6,r6,sac_cnt /* Back off the number of saveareas in here */
	183	stw r7,0(r5) /* Dequeue our guy */
	184	lwz r9,SACvrswap(r3) /* Get addressing conversion */
	185	stw r6,SVcount(r10) /* Back off the count for this block */
	186	xor r3,r3,r9 /* Flip to virtual addressing */
	187
	188	sdqunlk: li r8,0 /* Get a free lock value */
	189	sync /* Make sure everything is done */
	190	stw r8,SVlock(r10) /* Unlock the savearea chain */
	191
	192	mtmsr r12 /* Restore interrupts and translation */
	193	isync /* Dump any speculations */
	194
	195	#if 0
	196	lis r0,HIGH_ADDR(CutTrace) /* (TEST/DEBUG) */
	197	li r2,0x2202 ; (TEST/DEBUG)
	198	oris r0,r0,LOW_ADDR(CutTrace) /* (TEST/DEBUG) */
	199	sc /* (TEST/DEBUG) */
	200	#endif
	201
	202	blr /* Leave... */
	203
	204
	205
	206	/*
	207	* This routine will obtain a savearea from the free list.
	208	* Note really well: we can take NO exceptions of any kind,
	209	* including a PTE miss once the savearea lock is held. That's
	210	* a guaranteed deadlock. That means we must disable for interrutions
	211	* and turn all translation off.
	212	*
213	* We pass back the virtual address of the one we just obtained
214	* or a zero if none to allocate.
215	*
216	* Note that the savearea list should NEVER be empty
217	* NOTE!!! NEVER USE R0, R2, or R12 IN HERE THAT WAY WE DON'T NEED A
218	* STACK FRAME IN FPU_SAVE, FPU_SWITCH, VEC_SAVE, OR VEC_SWITCH.
219	*/
220
221	ENTRY(save_get_phys,TAG_NO_FRAME_USED)
222
223	cmplw cr1,r1,r1 ; Set CR1_eq to indicate we want physical address
224	b csaveget ; Join the common...
225
226	ENTRY(save_get,TAG_NO_FRAME_USED)
227
228	cmplwi cr1,r1,0 ; Set CR1_ne to indicate we want virtual address
229
150bd074 A	230	csaveget: mfsprg r9,2 ; Get the feature flags
	231	mfmsr r11 ; Get the MSR
	232	mtcrf 0x04,r9 ; Set the features
1c79356b	233	lis r10,HIGH_ADDR(EXT(saveanchor)) /* Get the high part of the anchor */
150bd074	234	andi. r3,r11,0x7FCF /* Turn off all translation and 'rupts */
1c79356b	235	ori r10,r10,LOW_ADDR(EXT(saveanchor)) /* Bottom half of the anchor */
150bd074 A	236
	237	bt pfNoMSRirb,sgNoMSR ; No MSR...
	238
	239	mtmsr r3 ; Translation and all off
	240	isync ; Toss prefetch
	241	b sgNoMSRx
1c79356b	242
150bd074 A	243	sgNoMSR: mr r9,r0 ; Save this
	244	li r0,loadMSR ; Get the MSR setter SC
	245	sc ; Set it
	246	mr r0,r9 ; Restore it
	247
	248	sgNoMSRx:
1c79356b A	249
	250	sglck: lwarx r9,0,r10 /* Grab the lock value */
	251	li r7,1 /* Use part of the delay time */
	252	mr. r9,r9 /* Is it locked? */
	253	bne- sglcks /* Yeah, wait for it to clear... */
	254	stwcx. r7,0,r10 /* Try to seize that there durn lock */
	255	beq+ sglckd /* Got it... */
	256	b sglck /* Collision, try again... */
	257
	258	sglcks: lwz r9,SVlock(r10) /* Get that lock in here */
	259	mr. r9,r9 /* Is it free yet? */
	260	beq+ sglck /* Yeah, try for it again... */
	261	b sglcks /* Sniff away... */
	262
	263	sglckd: isync /* Make sure translation is off */
	264	lwz r8,SVfree(r10) /* Get the head of the save area list */
	265	lwz r9,SVinuse(r10) /* Get the inuse field */
	266
	267	lwz r7,SACalloc(r8) /* Pick up the allocation bits */
	268	lwz r5,SACvrswap(r8) /* Get real to virtual translation */
	269	mr. r7,r7 /* Can we use the first one? */
	270	blt use1st /* Yeah... */
	271
	272	andis. r7,r7,0x8000 /* Show we used the second and remember if it was the last */
	273	addi r3,r8,0x0800 /* Point to the first one */
	274	b gotsave /* We have the area now... */
	275
	276	use1st: andis. r7,r7,0x4000 /* Mark first gone and remember if empty */
	277	mr r3,r8 /* Set the save area */
	278
	279	gotsave: stw r7,SACalloc(r8) /* Put back the allocation bits */
	280	bne nodqsave /* There's still an empty slot, don't dequeue... */
	281
	282	lwz r4,SACnext(r8) /* Get the next in line */
	283	stw r4,SVfree(r10) /* Dequeue our now empty save area block */
	284
	285	nodqsave: lis r6,HIGH_ADDR(SAVattach) /* Show that it is attached for now */
	286	li r4,0 /* Clear this for the lock */
	287	stw r6,SAVflags(r3) /* Set the flags to attached */
	288	addi r9,r9,1 /* Bump up the inuse count */
	289	stw r4,SAVprev(r3) /* Make sure that backchain is clear */
	290	stw r9,SVinuse(r10) /* Set the inuse field */
	291	sync /* Make sure all stores are done */
	292	stw r4,SVlock(r10) /* Unlock both save and trace areas */
	293	mtmsr r11 /* Restore translation and exceptions */
	294	isync /* Make sure about it */
	295
	296	#if 0
	297	mr r11,r0 /* (TEST/DEBUG) */
	298	mr r7,r2 /* (TEST/DEBUG) */
	299	lis r0,HIGH_ADDR(CutTrace) /* (TEST/DEBUG) */
	300	li r2,0x2203 ; (TEST/DEBUG)
	301	oris r0,r0,LOW_ADDR(CutTrace) /* (TEST/DEBUG) */
	302	sc /* (TEST/DEBUG) */
	303	mr r0,r11 /* (TEST/DEBUG) */
	304	mr r2,r7 /* (TEST/DEBUG) */
	305	#endif
	306
	307	li r7,0 ; NOTE WELL: we set R7 to zero for vector and float saving code in cswtch.s
	308	beqlr- cr1 ; Return now if we want the physical address
	309	xor r3,r3,r5 /* Get the virtual address */
	310	blr /* Leave... */
	311
	312
313	/*
314	* This routine will return a savearea to the free list.
315	* Note really well: we can take NO exceptions of any kind,
316	* including a PTE miss once the savearea lock is held. That's
317	* a guaranteed deadlock. That means we must disable for interrutions
318	* and turn all translation off.
319	*
320	* We take a virtual address.
321	*
322	*/
323
324	ENTRY(save_ret,TAG_NO_FRAME_USED)
325
326	#if 0
327	cmplwi r3,0x1000 ; (TEST/DEBUG)
328	bgt+ notpage0 ; (TEST/DEBUG)
329	BREAKPOINT_TRAP /* (TEST/DEBUG) */
330
331	notpage0: rlwinm r6,r3,0,0,19 /* (TEST/DEBUG) */
332	rlwinm r7,r3,21,31,31 /* (TEST/DEBUG) */
333	lis r8,0x8000 /* (TEST/DEBUG) */
334	lwz r6,SACalloc(r6) /* (TEST/DEBUG) */
335	srw r8,r8,r7 /* (TEST/DEBUG) */
336	and. r8,r8,r6 /* (TEST/DEBUG) */
337	beq+ nodoublefret /* (TEST/DEBUG) */
338	BREAKPOINT_TRAP /* (TEST/DEBUG) */
339
340	nodoublefret: /* (TEST/DEBUG) */
341	#endif
342
150bd074	343	mfsprg r9,2 ; Get the feature flags
1c79356b A	344	lwz r7,SAVflags(r3) /* Get the flags */
	345	rlwinm r6,r3,0,0,19 /* Round back down to the savearea page block */
	346	andis. r7,r7,HIGH_ADDR(SAVinuse) /* Still in use? */
	347	mfmsr r12 /* Get the MSR */
	348	bnelr- /* Still in use, just leave... */
	349	lwz r5,SACvrswap(r6) /* Get the conversion to real */
150bd074 A	350	mr r8,r3 ; Save the savearea address
150bd074 A	351	mtcrf 0x04,r9 ; Set the features
1c79356b	352	lis r10,HIGH_ADDR(EXT(saveanchor)) /* Get the high part of the anchor */
150bd074	353	andi. r3,r12,0x7FCF /* Turn off all translation and 'rupts */
1c79356b	354	ori r10,r10,LOW_ADDR(EXT(saveanchor)) /* Bottom half of the anchor */
150bd074 A	355
	356	bt pfNoMSRirb,srNoMSR ; No MSR...
	357
	358	mtmsr r3 ; Translation and all off
	359	isync ; Toss prefetch
	360	b srNoMSRx
	361
	362	srNoMSR: li r0,loadMSR ; Get the MSR setter SC
	363	sc ; Set it
	364	srNoMSRx:
1c79356b A	365
1c79356b A	366	mfsprg r11,1 /* Get the active save area */
150bd074	367	xor r3,r8,r5 /* Get the real address of the savearea */
1c79356b A	368	cmplw r11,r3 /* Are we trying to toss the active one? */
	369	xor r6,r6,r5 /* Make the savearea block real also */
	370	beq- srbigtimepanic /* This is a no-no... */
	371
	372	rlwinm r7,r3,21,31,31 /* Get position of savearea in block */
	373	lis r8,0x8000 /* Build a bit mask and assume first savearea */
	374	srw r8,r8,r7 /* Get bit position of do deallocate */
	375
1c79356b A	376	srlck: lwarx r11,0,r10 /* Grab the lock value */
	377	li r7,1 /* Use part of the delay time */
	378	mr. r11,r11 /* Is it locked? */
	379	bne- srlcks /* Yeah, wait for it to clear... */
	380	stwcx. r7,0,r10 /* Try to seize that there durn lock */
	381	beq+ srlckd /* Got it... */
	382	b srlck /* Collision, try again... */
	383
	384	srlcks: lwz r11,SVlock(r10) /* Get that lock in here */
	385	mr. r11,r11 /* Is it free yet? */
	386	beq+ srlck /* Yeah, try for it again... */
	387	b srlcks /* Sniff away... */
	388
	389	srlckd: isync /* Toss preexecutions */
	390	lwz r11,SACalloc(r6) /* Get the allocation for this block */
	391	lwz r7,SVinuse(r10) /* Get the in use count */
	392	or r11,r11,r8 /* Turn on our bit */
	393	subi r7,r7,1 /* We released one, adjust count */
	394	cmplw r11,r8 /* Is our's the only one free? */
	395	stw r7,SVinuse(r10) /* Save out count */
	396	stw r11,SACalloc(r6) /* Save it out */
	397	bne+ srtrest /* Nope, then the block is already on the free list */
	398
	399	lwz r11,SVfree(r10) /* Get the old head of the free list */
	400	stw r6,SVfree(r10) /* Point the head at us now */
	401	stw r11,SACnext(r6) /* Point us at the old last */
	402
	403	srtrest: li r8,0 /* Get set to clear the savearea lock */
	404	sync /* Make sure it's all out there */
	405	stw r8,SVlock(r10) /* Unlock it */
	406	mtmsr r12 /* Restore interruptions and translation */
	407	isync
	408
	409	#if 0
	410	lis r0,HIGH_ADDR(CutTrace) /* (TEST/DEBUG) */
	411	li r2,0x2204 ; (TEST/DEBUG)
	412	oris r0,r0,LOW_ADDR(CutTrace) /* (TEST/DEBUG) */
	413	sc /* (TEST/DEBUG) */
	414	#endif
	415
	416	blr /* Go away... */
	417
	418	srbigtimepanic:
	419	lis r6,HIGH_ADDR(EXT(panic)) /* First half of panic call */
	420	lis r3,HIGH_ADDR(EXT(srfreeactive)) /* First half of panic string */
	421	ori r6,r6,LOW_ADDR(EXT(panic)) /* Second half of panic call */
	422	ori r3,r3,LOW_ADDR(EXT(srfreeactive)) /* Second half of panic string */
	423	mtlr r6 /* Get the address of the panic routine */
	424	mtmsr r12 /* Restore interruptions and translation */
	425	isync
	426	blrl /* Panic... */
	427
	428	.data
	429	EXT(srfreeactive):
	430	STRINGD "save_ret: Attempting to release the active savearea!!!!\000"
	431	.text
	432
	433
	434	/*
	435	* struct savearea save_cpv(struct savearea ); Converts a physical savearea address to virtual
	436	*/
	437
	438	.align 5
	439	.globl EXT(save_cpv)
440
441	LEXT(save_cpv)
442
443	mfmsr r10 ; Get the current MSR
444	rlwinm r4,r3,0,0,19 ; Round back to the start of the physical savearea block
445	andi. r9,r10,0x7FEF ; Turn off interrupts and data translation
446	mtmsr r9 ; Disable DR and EE
447	isync
448
449	lwz r4,SACvrswap(r4) ; Get the conversion to virtual
450	mtmsr r10 ; Interrupts and DR back on
451	isync
452	xor r3,r3,r4 ; Convert to physical
453	blr
454
455
456	/*
457	* This routine will return the virtual address of the first free savearea
458	* block and disable for interruptions.
459	* Note really well: this is only for debugging, don't expect it to always work!
460	*
150bd074	461	* We take a virtual address in R3 to save the original MSR, and
1c79356b A	462	* return the virtual address.
	463	*
	464	*/
	465
	466	ENTRY(save_deb,TAG_NO_FRAME_USED)
	467
150bd074	468	mfsprg r9,2 ; Get the feature flags
1c79356b A	469	mfmsr r12 /* Get the MSR */
1c79356b A	470	lis r10,HIGH_ADDR(EXT(saveanchor)) /* Get the high part of the anchor */
150bd074	471	mtcrf 0x04,r9 ; Set the features
1c79356b	472	stw r12,0(r3) /* Save it */
150bd074	473	andi. r3,r12,0x7FCF /* Turn off all translation and 'rupts */
1c79356b	474	ori r10,r10,LOW_ADDR(EXT(saveanchor)) /* Bottom half of the anchor */
150bd074 A	475
	476	bt pfNoMSRirb,sdbNoMSR ; No MSR...
	477
	478	mtmsr r3 ; Translation and all off
	479	isync ; Toss prefetch
	480	b sdbNoMSRx
	481
	482	sdbNoMSR: li r0,loadMSR ; Get the MSR setter SC
	483	sc ; Set it
	484	sdbNoMSRx:
	485
1c79356b A	486	lwz r3,SVfree(r10) /* Get the physical first in list */
	487	andi. r11,r12,0x7FFF /* Clear only interruption */
	488	lwz r5,SACvrswap(r3) /* Get the conversion to virtual */
	489	mtmsr r11 /* Restore DAT but not INT */
	490	xor r3,r3,r5 /* Make it virtual */
	491	isync
	492	blr
	493
	494
	495
	496
	497