[GitHub/mt8127/android_kernel_alcatel_ttab.git] / arch / m68k / fpsp040 / skeleton.S

|
|	skeleton.sa 3.2 4/26/91
|
|	This file contains code that is system dependent and will
|	need to be modified to install the FPSP.
|
|	Each entry point for exception 'xxxx' begins with a 'jmp fpsp_xxxx'.
|	Put any target system specific handling that must be done immediately
|	before the jump instruction.  If there no handling necessary, then
|	the 'fpsp_xxxx' handler entry point should be placed in the exception
|	table so that the 'jmp' can be eliminated. If the FPSP determines that the
|	exception is one that must be reported then there will be a
|	return from the package by a 'jmp real_xxxx'.  At that point
|	the machine state will be identical to the state before
|	the FPSP was entered.  In particular, whatever condition
|	that caused the exception will still be pending when the FPSP
|	package returns.  Thus, there will be system specific code
|	to handle the exception.
|
|	If the exception was completely handled by the package, then
|	the return will be via a 'jmp fpsp_done'.  Unless there is
|	OS specific work to be done (such as handling a context switch or
|	interrupt) the user program can be resumed via 'rte'.
|
|	In the following skeleton code, some typical 'real_xxxx' handling
|	code is shown.  This code may need to be moved to an appropriate
|	place in the target system, or rewritten.
|

|		Copyright (C) Motorola, Inc. 1990
|			All Rights Reserved
|
|	THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
|	The copyright notice above does not evidence any
|	actual or intended publication of such source code.

|
|	Modified for Linux-1.3.x by Jes Sorensen (jds@kom.auc.dk)
|

#include <linux/linkage.h>
#include <asm/entry.h>
#include <asm/asm-offsets.h>

|SKELETON	idnt    2,1 | Motorola 040 Floating Point Software Package

	|section 15
|
|	The following counters are used for standalone testing
|

	|section 8

#include "fpsp.h"

	|xref	b1238_fix

|
|	Divide by Zero exception
|
|	All dz exceptions are 'real', hence no fpsp_dz entry point.
|
	.global	dz
	.global	real_dz
dz:
real_dz:
	link		%a6,#-LOCAL_SIZE
	fsave		-(%sp)
	bclrb		#E1,E_BYTE(%a6)
	frestore	(%sp)+
	unlk		%a6

	SAVE_ALL_INT
	GET_CURRENT(%d0)
	movel	%sp,%sp@-		| stack frame pointer argument
	bsrl	trap_c
	addql	#4,%sp
	bral	ret_from_exception

|
|	Inexact exception
|
|	All inexact exceptions are real, but the 'real' handler
|	will probably want to clear the pending exception.
|	The provided code will clear the E3 exception (if pending),
|	otherwise clear the E1 exception.  The frestore is not really
|	necessary for E1 exceptions.
|
| Code following the 'inex' label is to handle bug #1232.  In this
| bug, if an E1 snan, ovfl, or unfl occurred, and the process was
| swapped out before taking the exception, the exception taken on
| return was inex, rather than the correct exception.  The snan, ovfl,
| and unfl exception to be taken must not have been enabled.  The
| fix is to check for E1, and the existence of one of snan, ovfl,
| or unfl bits set in the fpsr.  If any of these are set, branch
| to the appropriate  handler for the exception in the fpsr.  Note
| that this fix is only for d43b parts, and is skipped if the
| version number is not $40.
|
|
	.global	real_inex
	.global	inex
inex:
	link		%a6,#-LOCAL_SIZE
	fsave		-(%sp)
	cmpib		#VER_40,(%sp)		|test version number
	bnes		not_fmt40
	fmovel		%fpsr,-(%sp)
	btstb		#E1,E_BYTE(%a6)		|test for E1 set
	beqs		not_b1232
	btstb		#snan_bit,2(%sp) |test for snan
	beq		inex_ckofl
	addl		#4,%sp
	frestore	(%sp)+
	unlk		%a6
	bra		snan
inex_ckofl:
	btstb		#ovfl_bit,2(%sp) |test for ovfl
	beq		inex_ckufl
	addl		#4,%sp
	frestore	(%sp)+
	unlk		%a6
	bra		ovfl
inex_ckufl:
	btstb		#unfl_bit,2(%sp) |test for unfl
	beq		not_b1232
	addl		#4,%sp
	frestore	(%sp)+
	unlk		%a6
	bra		unfl

|
| We do not have the bug 1232 case.  Clean up the stack and call
| real_inex.
|
not_b1232:
	addl		#4,%sp
	frestore	(%sp)+
	unlk		%a6

real_inex:

	link		%a6,#-LOCAL_SIZE
	fsave		-(%sp)
not_fmt40:
	bclrb		#E3,E_BYTE(%a6)		|clear and test E3 flag
	beqs		inex_cke1
|
| Clear dirty bit on dest resister in the frame before branching
| to b1238_fix.
|
	moveml		%d0/%d1,USER_DA(%a6)
	bfextu		CMDREG1B(%a6){#6:#3},%d0		|get dest reg no
	bclrb		%d0,FPR_DIRTY_BITS(%a6)	|clr dest dirty bit
	bsrl		b1238_fix		|test for bug1238 case
	moveml		USER_DA(%a6),%d0/%d1
	bras		inex_done
inex_cke1:
	bclrb		#E1,E_BYTE(%a6)
inex_done:
	frestore	(%sp)+
	unlk		%a6

	SAVE_ALL_INT
	GET_CURRENT(%d0)
	movel	%sp,%sp@-		| stack frame pointer argument
	bsrl	trap_c
	addql	#4,%sp
	bral	ret_from_exception

|
|	Overflow exception
|
	|xref	fpsp_ovfl
	.global	real_ovfl
	.global	ovfl
ovfl:
	jmp	fpsp_ovfl
real_ovfl:

	link		%a6,#-LOCAL_SIZE
	fsave		-(%sp)
	bclrb		#E3,E_BYTE(%a6)		|clear and test E3 flag
	bnes		ovfl_done
	bclrb		#E1,E_BYTE(%a6)
ovfl_done:
	frestore	(%sp)+
	unlk		%a6

	SAVE_ALL_INT
	GET_CURRENT(%d0)
	movel	%sp,%sp@-		| stack frame pointer argument
	bsrl	trap_c
	addql	#4,%sp
	bral	ret_from_exception

|
|	Underflow exception
|
	|xref	fpsp_unfl
	.global	real_unfl
	.global	unfl
unfl:
	jmp	fpsp_unfl
real_unfl:

	link		%a6,#-LOCAL_SIZE
	fsave		-(%sp)
	bclrb		#E3,E_BYTE(%a6)		|clear and test E3 flag
	bnes		unfl_done
	bclrb		#E1,E_BYTE(%a6)
unfl_done:
	frestore	(%sp)+
	unlk		%a6

	SAVE_ALL_INT
	GET_CURRENT(%d0)
	movel	%sp,%sp@-		| stack frame pointer argument
	bsrl	trap_c
	addql	#4,%sp
	bral	ret_from_exception

|
|	Signalling NAN exception
|
	|xref	fpsp_snan
	.global	real_snan
	.global	snan
snan:
	jmp	fpsp_snan
real_snan:
	link		%a6,#-LOCAL_SIZE
	fsave		-(%sp)
	bclrb		#E1,E_BYTE(%a6)	|snan is always an E1 exception
	frestore	(%sp)+
	unlk		%a6

	SAVE_ALL_INT
	GET_CURRENT(%d0)
	movel	%sp,%sp@-		| stack frame pointer argument
	bsrl	trap_c
	addql	#4,%sp
	bral	ret_from_exception

|
|	Operand Error exception
|
	|xref	fpsp_operr
	.global	real_operr
	.global	operr
operr:
	jmp	fpsp_operr
real_operr:
	link		%a6,#-LOCAL_SIZE
	fsave		-(%sp)
	bclrb		#E1,E_BYTE(%a6)	|operr is always an E1 exception
	frestore	(%sp)+
	unlk		%a6

	SAVE_ALL_INT
	GET_CURRENT(%d0)
	movel	%sp,%sp@-		| stack frame pointer argument
	bsrl	trap_c
	addql	#4,%sp
	bral	ret_from_exception


|
|	BSUN exception
|
|	This sample handler simply clears the nan bit in the FPSR.
|
	|xref	fpsp_bsun
	.global	real_bsun
	.global	bsun
bsun:
	jmp	fpsp_bsun
real_bsun:
	link		%a6,#-LOCAL_SIZE
	fsave		-(%sp)
	bclrb		#E1,E_BYTE(%a6)	|bsun is always an E1 exception
	fmovel		%FPSR,-(%sp)
	bclrb		#nan_bit,(%sp)
	fmovel		(%sp)+,%FPSR
	frestore	(%sp)+
	unlk		%a6

	SAVE_ALL_INT
	GET_CURRENT(%d0)
	movel	%sp,%sp@-		| stack frame pointer argument
	bsrl	trap_c
	addql	#4,%sp
	bral	ret_from_exception

|
|	F-line exception
|
|	A 'real' F-line exception is one that the FPSP isn't supposed to
|	handle. E.g. an instruction with a co-processor ID that is not 1.
|
|
	|xref	fpsp_fline
	.global	real_fline
	.global	fline
fline:
	jmp	fpsp_fline
real_fline:

	SAVE_ALL_INT
	GET_CURRENT(%d0)
	movel	%sp,%sp@-		| stack frame pointer argument
	bsrl	trap_c
	addql	#4,%sp
	bral	ret_from_exception

|
|	Unsupported data type exception
|
	|xref	fpsp_unsupp
	.global	real_unsupp
	.global	unsupp
unsupp:
	jmp	fpsp_unsupp
real_unsupp:
	link		%a6,#-LOCAL_SIZE
	fsave		-(%sp)
	bclrb		#E1,E_BYTE(%a6)	|unsupp is always an E1 exception
	frestore	(%sp)+
	unlk		%a6

	SAVE_ALL_INT
	GET_CURRENT(%d0)
	movel	%sp,%sp@-		| stack frame pointer argument
	bsrl	trap_c
	addql	#4,%sp
	bral	ret_from_exception

|
|	Trace exception
|
	.global	real_trace
real_trace:
	|
	bral	trap

|
|	fpsp_fmt_error --- exit point for frame format error
|
|	The fpu stack frame does not match the frames existing
|	or planned at the time of this writing.  The fpsp is
|	unable to handle frame sizes not in the following
|	version:size pairs:
|
|	{4060, 4160} - busy frame
|	{4028, 4130} - unimp frame
|	{4000, 4100} - idle frame
|
|	This entry point simply holds an f-line illegal value.
|	Replace this with a call to your kernel panic code or
|	code to handle future revisions of the fpu.
|
	.global	fpsp_fmt_error
fpsp_fmt_error:

	.long	0xf27f0000	|f-line illegal

|
|	fpsp_done --- FPSP exit point
|
|	The exception has been handled by the package and we are ready
|	to return to user mode, but there may be OS specific code
|	to execute before we do.  If there is, do it now.
|
|

	.global	fpsp_done
fpsp_done:
	btst	#0x5,%sp@		| supervisor bit set in saved SR?
	beq	.Lnotkern
	rte
.Lnotkern:
	SAVE_ALL_INT
	GET_CURRENT(%d0)
	| deliver signals, reschedule etc..
	jra	ret_from_exception

|
|	mem_write --- write to user or supervisor address space
|
| Writes to memory while in supervisor mode.  copyout accomplishes
| this via a 'moves' instruction.  copyout is a UNIX SVR3 (and later) function.
| If you don't have copyout, use the local copy of the function below.
|
|	a0 - supervisor source address
|	a1 - user destination address
|	d0 - number of bytes to write (maximum count is 12)
|
| The supervisor source address is guaranteed to point into the supervisor
| stack.  The result is that a UNIX
| process is allowed to sleep as a consequence of a page fault during
| copyout.  The probability of a page fault is exceedingly small because
| the 68040 always reads the destination address and thus the page
| faults should have already been handled.
|
| If the EXC_SR shows that the exception was from supervisor space,
| then just do a dumb (and slow) memory move.  In a UNIX environment
| there shouldn't be any supervisor mode floating point exceptions.
|
	.global	mem_write
mem_write:
	btstb	#5,EXC_SR(%a6)	|check for supervisor state
	beqs	user_write
super_write:
	moveb	(%a0)+,(%a1)+
	subql	#1,%d0
	bnes	super_write
	rts
user_write:
	movel	%d1,-(%sp)	|preserve d1 just in case
	movel	%d0,-(%sp)
	movel	%a1,-(%sp)
	movel	%a0,-(%sp)
	jsr		copyout
	addw	#12,%sp
	movel	(%sp)+,%d1
	rts
|
|	mem_read --- read from user or supervisor address space
|
| Reads from memory while in supervisor mode.  copyin accomplishes
| this via a 'moves' instruction.  copyin is a UNIX SVR3 (and later) function.
| If you don't have copyin, use the local copy of the function below.
|
| The FPSP calls mem_read to read the original F-line instruction in order
| to extract the data register number when the 'Dn' addressing mode is
| used.
|
|Input:
|	a0 - user source address
|	a1 - supervisor destination address
|	d0 - number of bytes to read (maximum count is 12)
|
| Like mem_write, mem_read always reads with a supervisor
| destination address on the supervisor stack.  Also like mem_write,
| the EXC_SR is checked and a simple memory copy is done if reading
| from supervisor space is indicated.
|
	.global	mem_read
mem_read:
	btstb	#5,EXC_SR(%a6)	|check for supervisor state
	beqs	user_read
super_read:
	moveb	(%a0)+,(%a1)+
	subql	#1,%d0
	bnes	super_read
	rts
user_read:
	movel	%d1,-(%sp)	|preserve d1 just in case
	movel	%d0,-(%sp)
	movel	%a1,-(%sp)
	movel	%a0,-(%sp)
	jsr	copyin
	addw	#12,%sp
	movel	(%sp)+,%d1
	rts

|
| Use these routines if your kernel doesn't have copyout/copyin equivalents.
| Assumes that D0/D1/A0/A1 are scratch registers. copyout overwrites DFC,
| and copyin overwrites SFC.
|
copyout:
	movel	4(%sp),%a0	| source
	movel	8(%sp),%a1	| destination
	movel	12(%sp),%d0	| count
	subl	#1,%d0		| dec count by 1 for dbra
	movel	#1,%d1

|	DFC is already set
|	movec	%d1,%DFC		| set dfc for user data space
moreout:
	moveb	(%a0)+,%d1	| fetch supervisor byte
out_ea:
	movesb	%d1,(%a1)+	| write user byte
	dbf	%d0,moreout
	rts

copyin:
	movel	4(%sp),%a0	| source
	movel	8(%sp),%a1	| destination
	movel	12(%sp),%d0	| count
	subl	#1,%d0		| dec count by 1 for dbra
	movel	#1,%d1
|	SFC is already set
|	movec	%d1,%SFC		| set sfc for user space
morein:
in_ea:
	movesb	(%a0)+,%d1	| fetch user byte
	moveb	%d1,(%a1)+	| write supervisor byte
	dbf	%d0,morein
	rts

	.section .fixup,#alloc,#execinstr
	.even
1:
	jbra	fpsp040_die

	.section __ex_table,#alloc
	.align	4

	.long	in_ea,1b
	.long	out_ea,1b

	|end
Commit	Line	Data
1da177e4 LT	1	\|
	2	\| skeleton.sa 3.2 4/26/91
	3	\|
	4	\| This file contains code that is system dependent and will
	5	\| need to be modified to install the FPSP.
	6	\|
	7	\| Each entry point for exception 'xxxx' begins with a 'jmp fpsp_xxxx'.
	8	\| Put any target system specific handling that must be done immediately
	9	\| before the jump instruction. If there no handling necessary, then
	10	\| the 'fpsp_xxxx' handler entry point should be placed in the exception
	11	\| table so that the 'jmp' can be eliminated. If the FPSP determines that the
	12	\| exception is one that must be reported then there will be a
	13	\| return from the package by a 'jmp real_xxxx'. At that point
	14	\| the machine state will be identical to the state before
	15	\| the FPSP was entered. In particular, whatever condition
	16	\| that caused the exception will still be pending when the FPSP
	17	\| package returns. Thus, there will be system specific code
	18	\| to handle the exception.
	19	\|
	20	\| If the exception was completely handled by the package, then
	21	\| the return will be via a 'jmp fpsp_done'. Unless there is
	22	\| OS specific work to be done (such as handling a context switch or
	23	\| interrupt) the user program can be resumed via 'rte'.
	24	\|
	25	\| In the following skeleton code, some typical 'real_xxxx' handling
	26	\| code is shown. This code may need to be moved to an appropriate
	27	\| place in the target system, or rewritten.
	28	\|
	29
	30	\| Copyright (C) Motorola, Inc. 1990
	31	\| All Rights Reserved
	32	\|
	33	\| THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
	34	\| The copyright notice above does not evidence any
	35	\| actual or intended publication of such source code.
	36
	37	\|
	38	\| Modified for Linux-1.3.x by Jes Sorensen (jds@kom.auc.dk)
	39	\|
	40
	41	#include <linux/linkage.h>
	42	#include <asm/entry.h>
0013a854	43	#include <asm/asm-offsets.h>
1da177e4 LT	44
	45	\|SKELETON idnt 2,1 \| Motorola 040 Floating Point Software Package
	46
	47	\|section 15
	48	\|
	49	\| The following counters are used for standalone testing
	50	\|
	51
	52	\|section 8
	53
	54	#include "fpsp.h"
	55
	56	\|xref b1238_fix
	57
	58	\|
	59	\| Divide by Zero exception
	60	\|
	61	\| All dz exceptions are 'real', hence no fpsp_dz entry point.
	62	\|
	63	.global dz
	64	.global real_dz
	65	dz:
	66	real_dz:
	67	link %a6,#-LOCAL_SIZE
	68	fsave -(%sp)
	69	bclrb #E1,E_BYTE(%a6)
	70	frestore (%sp)+
	71	unlk %a6
	72
	73	SAVE_ALL_INT
	74	GET_CURRENT(%d0)
	75	movel %sp,%sp@- \| stack frame pointer argument
	76	bsrl trap_c
	77	addql #4,%sp
	78	bral ret_from_exception
	79
	80	\|
	81	\| Inexact exception
	82	\|
	83	\| All inexact exceptions are real, but the 'real' handler
	84	\| will probably want to clear the pending exception.
	85	\| The provided code will clear the E3 exception (if pending),
	86	\| otherwise clear the E1 exception. The frestore is not really
	87	\| necessary for E1 exceptions.
	88	\|
	89	\| Code following the 'inex' label is to handle bug #1232. In this
	90	\| bug, if an E1 snan, ovfl, or unfl occurred, and the process was
	91	\| swapped out before taking the exception, the exception taken on
	92	\| return was inex, rather than the correct exception. The snan, ovfl,
	93	\| and unfl exception to be taken must not have been enabled. The
	94	\| fix is to check for E1, and the existence of one of snan, ovfl,
	95	\| or unfl bits set in the fpsr. If any of these are set, branch
	96	\| to the appropriate handler for the exception in the fpsr. Note
	97	\| that this fix is only for d43b parts, and is skipped if the
	98	\| version number is not $40.
	99	\|
	100	\|
	101	.global real_inex
	102	.global inex
	103	inex:
	104	link %a6,#-LOCAL_SIZE
	105	fsave -(%sp)
	106	cmpib #VER_40,(%sp) \|test version number
	107	bnes not_fmt40
108	fmovel %fpsr,-(%sp)
109	btstb #E1,E_BYTE(%a6) \|test for E1 set
110	beqs not_b1232
111	btstb #snan_bit,2(%sp) \|test for snan
112	beq inex_ckofl
113	addl #4,%sp
114	frestore (%sp)+
115	unlk %a6
116	bra snan
117	inex_ckofl:
118	btstb #ovfl_bit,2(%sp) \|test for ovfl
119	beq inex_ckufl
120	addl #4,%sp
121	frestore (%sp)+
122	unlk %a6
123	bra ovfl
124	inex_ckufl:
125	btstb #unfl_bit,2(%sp) \|test for unfl
126	beq not_b1232
127	addl #4,%sp
128	frestore (%sp)+
129	unlk %a6
130	bra unfl
131
132	\|
133	\| We do not have the bug 1232 case. Clean up the stack and call
134	\| real_inex.
135	\|
136	not_b1232:
137	addl #4,%sp
138	frestore (%sp)+
139	unlk %a6
140
141	real_inex:
142
143	link %a6,#-LOCAL_SIZE
144	fsave -(%sp)
145	not_fmt40:
146	bclrb #E3,E_BYTE(%a6) \|clear and test E3 flag
147	beqs inex_cke1
148	\|
149	\| Clear dirty bit on dest resister in the frame before branching
150	\| to b1238_fix.
151	\|
152	moveml %d0/%d1,USER_DA(%a6)
153	bfextu CMDREG1B(%a6){#6:#3},%d0 \|get dest reg no
154	bclrb %d0,FPR_DIRTY_BITS(%a6) \|clr dest dirty bit
155	bsrl b1238_fix \|test for bug1238 case
156	moveml USER_DA(%a6),%d0/%d1
157	bras inex_done
158	inex_cke1:
159	bclrb #E1,E_BYTE(%a6)
160	inex_done:
161	frestore (%sp)+
162	unlk %a6
163
164	SAVE_ALL_INT
165	GET_CURRENT(%d0)
166	movel %sp,%sp@- \| stack frame pointer argument
167	bsrl trap_c
168	addql #4,%sp
169	bral ret_from_exception
170
171	\|
172	\| Overflow exception
173	\|
174	\|xref fpsp_ovfl
175	.global real_ovfl
176	.global ovfl
177	ovfl:
178	jmp fpsp_ovfl
179	real_ovfl:
180
181	link %a6,#-LOCAL_SIZE
182	fsave -(%sp)
183	bclrb #E3,E_BYTE(%a6) \|clear and test E3 flag
184	bnes ovfl_done
185	bclrb #E1,E_BYTE(%a6)
186	ovfl_done:
187	frestore (%sp)+
188	unlk %a6
189
190	SAVE_ALL_INT
191	GET_CURRENT(%d0)
192	movel %sp,%sp@- \| stack frame pointer argument
193	bsrl trap_c
194	addql #4,%sp
195	bral ret_from_exception
196
197	\|
198	\| Underflow exception
199	\|
200	\|xref fpsp_unfl
201	.global real_unfl
202	.global unfl
203	unfl:
204	jmp fpsp_unfl
205	real_unfl:
206
207	link %a6,#-LOCAL_SIZE
208	fsave -(%sp)
209	bclrb #E3,E_BYTE(%a6) \|clear and test E3 flag
210	bnes unfl_done
211	bclrb #E1,E_BYTE(%a6)
212	unfl_done:
213	frestore (%sp)+
214	unlk %a6
215
216	SAVE_ALL_INT
217	GET_CURRENT(%d0)
218	movel %sp,%sp@- \| stack frame pointer argument
219	bsrl trap_c
220	addql #4,%sp
221	bral ret_from_exception
222
223	\|
224	\| Signalling NAN exception
225	\|
226	\|xref fpsp_snan
227	.global real_snan
228	.global snan
229	snan:
230	jmp fpsp_snan
231	real_snan:
232	link %a6,#-LOCAL_SIZE
233	fsave -(%sp)
234	bclrb #E1,E_BYTE(%a6) \|snan is always an E1 exception
235	frestore (%sp)+
236	unlk %a6
237
238	SAVE_ALL_INT
239	GET_CURRENT(%d0)
240	movel %sp,%sp@- \| stack frame pointer argument
241	bsrl trap_c
242	addql #4,%sp
243	bral ret_from_exception
244
245	\|
246	\| Operand Error exception
247	\|
248	\|xref fpsp_operr
249	.global real_operr
250	.global operr
251	operr:
252	jmp fpsp_operr
253	real_operr:
254	link %a6,#-LOCAL_SIZE
255	fsave -(%sp)
256	bclrb #E1,E_BYTE(%a6) \|operr is always an E1 exception
257	frestore (%sp)+
258	unlk %a6
259
260	SAVE_ALL_INT
261	GET_CURRENT(%d0)
262	movel %sp,%sp@- \| stack frame pointer argument
263	bsrl trap_c
264	addql #4,%sp
265	bral ret_from_exception
266
267
268	\|
269	\| BSUN exception
270	\|
271	\| This sample handler simply clears the nan bit in the FPSR.
272	\|
273	\|xref fpsp_bsun
274	.global real_bsun
275	.global bsun
276	bsun:
277	jmp fpsp_bsun
278	real_bsun:
279	link %a6,#-LOCAL_SIZE
280	fsave -(%sp)
281	bclrb #E1,E_BYTE(%a6) \|bsun is always an E1 exception
282	fmovel %FPSR,-(%sp)
283	bclrb #nan_bit,(%sp)
284	fmovel (%sp)+,%FPSR
285	frestore (%sp)+
286	unlk %a6
287
288	SAVE_ALL_INT
289	GET_CURRENT(%d0)
290	movel %sp,%sp@- \| stack frame pointer argument
291	bsrl trap_c
292	addql #4,%sp
293	bral ret_from_exception
294
295	\|
296	\| F-line exception
297	\|
298	\| A 'real' F-line exception is one that the FPSP isn't supposed to
299	\| handle. E.g. an instruction with a co-processor ID that is not 1.
300	\|
301	\|
302	\|xref fpsp_fline
303	.global real_fline
304	.global fline
305	fline:
306	jmp fpsp_fline
307	real_fline:
308
309	SAVE_ALL_INT
310	GET_CURRENT(%d0)
311	movel %sp,%sp@- \| stack frame pointer argument
312	bsrl trap_c
313	addql #4,%sp
314	bral ret_from_exception
315
316	\|
317	\| Unsupported data type exception
318	\|
319	\|xref fpsp_unsupp
320	.global real_unsupp
321	.global unsupp
322	unsupp:
323	jmp fpsp_unsupp
324	real_unsupp:
325	link %a6,#-LOCAL_SIZE
326	fsave -(%sp)
327	bclrb #E1,E_BYTE(%a6) \|unsupp is always an E1 exception
328	frestore (%sp)+
329	unlk %a6
330
331	SAVE_ALL_INT
332	GET_CURRENT(%d0)
333	movel %sp,%sp@- \| stack frame pointer argument
334	bsrl trap_c
335	addql #4,%sp
336	bral ret_from_exception
337
338	\|
339	\| Trace exception
340	\|
341	.global real_trace
342	real_trace:
343	\|
344	bral trap
345
346	\|
347	\| fpsp_fmt_error --- exit point for frame format error
348	\|
349	\| The fpu stack frame does not match the frames existing
350	\| or planned at the time of this writing. The fpsp is
351	\| unable to handle frame sizes not in the following
352	\| version:size pairs:
353	\|
354	\| {4060, 4160} - busy frame
355	\| {4028, 4130} - unimp frame
356	\| {4000, 4100} - idle frame
357	\|
358	\| This entry point simply holds an f-line illegal value.
359	\| Replace this with a call to your kernel panic code or
360	\| code to handle future revisions of the fpu.
361	\|
362	.global fpsp_fmt_error
363	fpsp_fmt_error:
364
365	.long 0xf27f0000 \|f-line illegal
366
367	\|
368	\| fpsp_done --- FPSP exit point
369	\|
370	\| The exception has been handled by the package and we are ready
371	\| to return to user mode, but there may be OS specific code
372	\| to execute before we do. If there is, do it now.
373	\|
374	\|
375
376	.global fpsp_done
377	fpsp_done:
378	btst #0x5,%sp@ \| supervisor bit set in saved SR?
379	beq .Lnotkern
380	rte
381	.Lnotkern:
382	SAVE_ALL_INT
383	GET_CURRENT(%d0)
3b66a1ed RZ	384	\| deliver signals, reschedule etc..
3b66a1ed RZ	385	jra ret_from_exception
1da177e4 LT	386
	387	\|
	388	\| mem_write --- write to user or supervisor address space
	389	\|
	390	\| Writes to memory while in supervisor mode. copyout accomplishes
	391	\| this via a 'moves' instruction. copyout is a UNIX SVR3 (and later) function.
	392	\| If you don't have copyout, use the local copy of the function below.
	393	\|
	394	\| a0 - supervisor source address
	395	\| a1 - user destination address
	396	\| d0 - number of bytes to write (maximum count is 12)
	397	\|
	398	\| The supervisor source address is guaranteed to point into the supervisor
	399	\| stack. The result is that a UNIX
	400	\| process is allowed to sleep as a consequence of a page fault during
	401	\| copyout. The probability of a page fault is exceedingly small because
	402	\| the 68040 always reads the destination address and thus the page
	403	\| faults should have already been handled.
	404	\|
	405	\| If the EXC_SR shows that the exception was from supervisor space,
	406	\| then just do a dumb (and slow) memory move. In a UNIX environment
	407	\| there shouldn't be any supervisor mode floating point exceptions.
	408	\|
	409	.global mem_write
	410	mem_write:
	411	btstb #5,EXC_SR(%a6) \|check for supervisor state
	412	beqs user_write
	413	super_write:
	414	moveb (%a0)+,(%a1)+
	415	subql #1,%d0
	416	bnes super_write
	417	rts
	418	user_write:
	419	movel %d1,-(%sp) \|preserve d1 just in case
	420	movel %d0,-(%sp)
	421	movel %a1,-(%sp)
	422	movel %a0,-(%sp)
	423	jsr copyout
	424	addw #12,%sp
	425	movel (%sp)+,%d1
	426	rts
	427	\|
	428	\| mem_read --- read from user or supervisor address space
	429	\|
	430	\| Reads from memory while in supervisor mode. copyin accomplishes
	431	\| this via a 'moves' instruction. copyin is a UNIX SVR3 (and later) function.
	432	\| If you don't have copyin, use the local copy of the function below.
	433	\|
	434	\| The FPSP calls mem_read to read the original F-line instruction in order
	435	\| to extract the data register number when the 'Dn' addressing mode is
	436	\| used.
	437	\|
	438	\|Input:
	439	\| a0 - user source address
	440	\| a1 - supervisor destination address
	441	\| d0 - number of bytes to read (maximum count is 12)
	442	\|
	443	\| Like mem_write, mem_read always reads with a supervisor
	444	\| destination address on the supervisor stack. Also like mem_write,
	445	\| the EXC_SR is checked and a simple memory copy is done if reading
	446	\| from supervisor space is indicated.
	447	\|
	448	.global mem_read
	449	mem_read:
450	btstb #5,EXC_SR(%a6) \|check for supervisor state
451	beqs user_read
452	super_read:
453	moveb (%a0)+,(%a1)+
454	subql #1,%d0
455	bnes super_read
456	rts
457	user_read:
458	movel %d1,-(%sp) \|preserve d1 just in case
459	movel %d0,-(%sp)
460	movel %a1,-(%sp)
461	movel %a0,-(%sp)
462	jsr copyin
463	addw #12,%sp
464	movel (%sp)+,%d1
465	rts
466
467	\|
468	\| Use these routines if your kernel doesn't have copyout/copyin equivalents.
469	\| Assumes that D0/D1/A0/A1 are scratch registers. copyout overwrites DFC,
470	\| and copyin overwrites SFC.
471	\|
472	copyout:
473	movel 4(%sp),%a0 \| source
474	movel 8(%sp),%a1 \| destination
475	movel 12(%sp),%d0 \| count
476	subl #1,%d0 \| dec count by 1 for dbra
477	movel #1,%d1
478
479	\| DFC is already set
480	\| movec %d1,%DFC \| set dfc for user data space
481	moreout:
482	moveb (%a0)+,%d1 \| fetch supervisor byte
483	out_ea:
484	movesb %d1,(%a1)+ \| write user byte
485	dbf %d0,moreout
486	rts
487
488	copyin:
489	movel 4(%sp),%a0 \| source
490	movel 8(%sp),%a1 \| destination
491	movel 12(%sp),%d0 \| count
492	subl #1,%d0 \| dec count by 1 for dbra
493	movel #1,%d1
494	\| SFC is already set
495	\| movec %d1,%SFC \| set sfc for user space
496	morein:
497	in_ea:
498	movesb (%a0)+,%d1 \| fetch user byte
499	moveb %d1,(%a1)+ \| write supervisor byte
500	dbf %d0,morein
501	rts
502
503	.section .fixup,#alloc,#execinstr
504	.even
505	1:
506	jbra fpsp040_die
507
508	.section __ex_table,#alloc
509	.align 4
510
511	.long in_ea,1b
512	.long out_ea,1b
513
514	\|end