#
# os.s
#
# This file contains:
#	- example "Call-Out"s required by both the ISP and FPSP.
#


#################################
# EXAMPLE CALL-OUTS 		#
# 				#
# _060_dmem_write()		#
# _060_dmem_read()		#
# _060_imem_read()		#
# _060_dmem_read_byte()		#
# _060_dmem_read_word()		#
# _060_dmem_read_long()		#
# _060_imem_read_word()		#
# _060_imem_read_long()		#
# _060_dmem_write_byte()	#
# _060_dmem_write_word()	#
# _060_dmem_write_long()	#
#				#
# _060_real_trace()		#
# _060_real_access()		#
#################################

# 
# Each IO routine checks to see if the memory write/read is to/from user
# or supervisor application space. The examples below use simple "move"
# instructions for supervisor mode applications and call _copyin()/_copyout()
# for user mode applications.
# When installing the 060SP, the _copyin()/_copyout() equivalents for a 
# given operating system should be substituted.
#
# The addresses within the 060SP are guaranteed to be on the stack.
# The result is that Unix processes are allowed to sleep as a consequence
# of a page fault during a _copyout.
#

#
# _060_dmem_write():
#
# Writes to data memory while in supervisor mode.
#
# INPUTS:
#	a0 - supervisor source address	
#	a1 - user destination address
#	d0 - number of bytes to write	
# 	0x4(%a6),bit5 - 1 = supervisor mode, 0 = user mode
# OUTPUTS:
#	d1 - 0 = success, !0 = failure
#
	global		_060_dmem_write
_060_dmem_write:
	btst		&0x5,0x4(%a6)		# check for supervisor state
	beq.b		user_write
super_write:
	mov.b		(%a0)+,(%a1)+		# copy 1 byte
	subq.l		&0x1,%d0		# decr byte counter
	bne.b		super_write		# quit if ctr = 0
	clr.l		%d1			# return success
	rts
user_write:
	mov.l		%d0,-(%sp)		# pass: counter
	mov.l		%a1,-(%sp)		# pass: user dst
	mov.l		%a0,-(%sp)		# pass: supervisor src
	bsr.l		_copyout		# write byte to user mem
	mov.l		%d0,%d1			# return success
	add.l		&0xc, %sp		# clear 3 lw params
	rts

#
# _060_imem_read(), _060_dmem_read():
#
# Reads from data/instruction memory while in supervisor mode.
#
# INPUTS:
#	a0 - user source address
#	a1 - supervisor destination address
#	d0 - number of bytes to read
# 	0x4(%a6),bit5 - 1 = supervisor mode, 0 = user mode
# OUTPUTS:
#	d1 - 0 = success, !0 = failure
#
	global 		_060_imem_read
	global		_060_dmem_read
_060_imem_read:
_060_dmem_read:
	btst		&0x5,0x4(%a6)		# check for supervisor state
	beq.b		user_read
super_read:
	mov.b		(%a0)+,(%a1)+		# copy 1 byte
	subq.l		&0x1,%d0		# decr byte counter
	bne.b		super_read		# quit if ctr = 0
	clr.l		%d1			# return success
	rts
user_read:
	mov.l		%d0,-(%sp)		# pass: counter
	mov.l		%a1,-(%sp)		# pass: super dst
	mov.l		%a0,-(%sp)		# pass: user src
	bsr.l		_copyin			# read byte from user mem
	mov.l		%d0,%d1			# return success
	add.l		&0xc,%sp		# clear 3 lw params
	rts

#
# _060_dmem_read_byte():
# 
# Read a data byte from user memory.
#
# INPUTS:
#	a0 - user source address
# 	0x4(%a6),bit5 - 1 = supervisor mode, 0 = user mode
# OUTPUTS:
#	d0 - data byte in d0
#	d1 - 0 = success, !0 = failure
#
	global 		_060_dmem_read_byte
_060_dmem_read_byte:
	btst		&0x5,0x4(%a6)		# check for supervisor state
	bne.b		dmrbs			# supervisor
dmrbu:	clr.l		-(%sp)			# clear space on stack for result
	mov.l		&0x1,-(%sp)		# pass: # bytes to copy
	pea		0x7(%sp)		# pass: dst addr (stack)
	mov.l		%a0,-(%sp)		# pass: src addr (user mem)
	bsr.l		_copyin			# "copy in" the data
	mov.l		%d0,%d1			# return success
	add.l		&0xc,%sp		# delete params
	mov.l		(%sp)+,%d0		# put answer in d0
	rts
dmrbs:	clr.l		%d0			# clear whole longword
	mov.b		(%a0),%d0		# fetch super byte
	clr.l		%d1			# return success
	rts

#
# _060_dmem_read_word():
# 
# Read a data word from user memory.
#
# INPUTS:
#	a0 - user source address
# 	0x4(%a6),bit5 - 1 = supervisor mode, 0 = user mode
# OUTPUTS:
#	d0 - data word in d0
#	d1 - 0 = success, !0 = failure
#
	global 		_060_dmem_read_word
_060_dmem_read_word:
	btst		&0x5,0x4(%a6)		# check for supervisor state
	bne.b		dmrws			# supervisor
dmrwu:	clr.l		-(%sp)			# clear space on stack for result
	mov.l		&0x2,-(%sp)		# pass: # bytes to copy
	pea		0x6(%sp)		# pass: dst addr (stack)
	mov.l		%a0,-(%sp)		# pass: src addr (user mem)
	bsr.l		_copyin			# "copy in" the data
	mov.l		%d0,%d1			# return success
	add.l		&0xc,%sp		# delete params
	mov.l		(%sp)+,%d0		# put answer in d0
	rts
dmrws:	clr.l		%d0			# clear whole longword
	mov.w		(%a0), %d0		# fetch super word
	clr.l		%d1			# return success
	rts

#
# _060_dmem_read_long():
# 

#
# INPUTS:
#	a0 - user source address
# 	0x4(%a6),bit5 - 1 = supervisor mode, 0 = user mode
# OUTPUTS:
#	d0 - data longword in d0
#	d1 - 0 = success, !0 = failure
#
	global 		_060_dmem_read_long
_060_dmem_read_long:
	btst		&0x5,0x4(%a6)		# check for supervisor state
	bne.b		dmrls			# supervisor
dmrlu:	subq.l		&0x4,%sp		# clear space on stack for result
	mov.l		&0x4,-(%sp)		# pass: # bytes to copy
	pea		0x4(%sp)		# pass: dst addr (stack)
	mov.l		%a0,-(%sp)		# pass: src addr (user mem)
	bsr.l		_copyin			# "copy in" the data
	mov.l		%d0,%d1			# return success
	add.l		&0xc,%sp		# delete params
	mov.l		(%sp)+,%d0		# put answer in d0
	rts
dmrls:	mov.l		(%a0),%d0		# fetch super longword
	clr.l		%d1			# return success
	rts

#
# _060_dmem_write_byte():
#
# Write a data byte to user memory.
#
# INPUTS:
#	a0 - user destination address
# 	d0 - data byte in d0
# 	0x4(%a6),bit5 - 1 = supervisor mode, 0 = user mode
# OUTPUTS:
#	d1 - 0 = success, !0 = failure
#
	global 		_060_dmem_write_byte
_060_dmem_write_byte:
	btst		&0x5,0x4(%a6)		# check for supervisor state
	bne.b		dmwbs			# supervisor
dmwbu:	mov.l		%d0,-(%sp)		# put src on stack
	mov.l		&0x1,-(%sp)		# pass: # bytes to copy
	mov.l		%a0,-(%sp)		# pass: dst addr (user mem)
	pea		0xb(%sp)		# pass: src addr (stack)
	bsr.l		_copyout		# "copy out" the data
	mov.l		%d0,%d1			# return success
	add.l		&0x10,%sp		# delete params + src
	rts
dmwbs:	mov.b		%d0,(%a0)		# store super byte
	clr.l		%d1			# return success
	rts

#
# _060_dmem_write_word():
#
# Write a data word to user memory.
#
# INPUTS:
#	a0 - user destination address
# 	d0 - data word in d0
# 	0x4(%a6),bit5 - 1 = supervisor mode, 0 = user mode
# OUTPUTS:
#	d1 - 0 = success, !0 = failure
#
	global 		_060_dmem_write_word
_060_dmem_write_word:
	btst		&0x5,0x4(%a6)		# check for supervisor state
	bne.b		dmwws			# supervisor
dmwwu:	mov.l		%d0,-(%sp)		# put src on stack
	mov.l		&0x2,-(%sp)		# pass: # bytes to copy
	mov.l		%a0,-(%sp)		# pass: dst addr (user mem)
	pea		0xa(%sp)		# pass: src addr (stack)
	bsr.l		_copyout		# "copy out" the data
	mov.l		%d0,%d1			# return success
	add.l		&0x10,%sp		# delete params + src
	rts
dmwws:	mov.w		%d0,(%a0)		# store super word
	clr.l		%d1			# return success
	rts

#
# _060_dmem_write_long():
#
# Write a data longword to user memory.
#
# INPUTS:
#	a0 - user destination address
# 	d0 - data longword in d0
# 	0x4(%a6),bit5 - 1 = supervisor mode, 0 = user mode
# OUTPUTS:
#	d1 - 0 = success, !0 = failure
#
	global 		_060_dmem_write_long
_060_dmem_write_long:
	btst		&0x5,0x4(%a6)		# check for supervisor state
	bne.b		dmwls			# supervisor
dmwlu:	mov.l		%d0,-(%sp)		# put src on stack
	mov.l		&0x4,-(%sp)		# pass: # bytes to copy
	mov.l		%a0,-(%sp)		# pass: dst addr (user mem)
	pea		0x8(%sp)		# pass: src addr (stack)
	bsr.l		_copyout		# "copy out" the data
	mov.l		%d0,%d1			# return success
	add.l		&0x10,%sp		# delete params + src
	rts
dmwls:	mov.l		%d0,(%a0)		# store super longword
	clr.l		%d1			# return success
	rts

#
# _060_imem_read_word():
# 
# Read an instruction word from user memory.
#
# INPUTS:
#	a0 - user source address
# 	0x4(%a6),bit5 - 1 = supervisor mode, 0 = user mode
# OUTPUTS:
#	d0 - instruction word in d0
#	d1 - 0 = success, !0 = failure
#
	global 		_060_imem_read_word
_060_imem_read_word:
	btst		&0x5,0x4(%a6)		# check for supervisor state
	bne.b		imrws			# supervisor
imrwu:	clr.l		-(%sp)			# clear space on stack for result
	mov.l		&0x2,-(%sp)		# pass: # bytes to copy
	pea		0x6(%sp)		# pass: dst addr (stack)
	mov.l		%a0,-(%sp)		# pass: src addr (user mem)
	bsr.l		_copyin			# "copy in" the data
	mov.l		%d0,%d1			# return success
	add.l		&0xc,%sp		# delete params
	mov.l		(%sp)+,%d0		# put answer in d0
	rts
imrws:	mov.w		(%a0),%d0		# fetch super word
	clr.l		%d1			# return success
	rts

#
# _060_imem_read_long():
# 
# Read an instruction longword from user memory.
#
# INPUTS:
#	a0 - user source address
# 	0x4(%a6),bit5 - 1 = supervisor mode, 0 = user mode
# OUTPUTS:
#	d0 - instruction longword in d0
#	d1 - 0 = success, !0 = failure
#
	global 		_060_imem_read_long
_060_imem_read_long:
	btst		&0x5,0x4(%a6)		# check for supervisor state
	bne.b		imrls			# supervisor
imrlu:	subq.l		&0x4,%sp		# clear space on stack for result
	mov.l		&0x4,-(%sp)		# pass: # bytes to copy
	pea		0x4(%sp)		# pass: dst addr (stack)
	mov.l		%a0,-(%sp)		# pass: src addr (user mem)
	bsr.l		_copyin			# "copy in" the data
	mov.l		%d0,%d1			# return success
	add.l		&0xc,%sp		# delete params
	mov.l		(%sp)+,%d0		# put answer in d0
	rts
imrls:	mov.l		(%a0),%d0		# fetch super longword
	clr.l		%d1			# return success
	rts

################################################

#
# Use these routines if your kernel doesn't have _copyout/_copyin equivalents.
# Assumes that D0/D1/A0/A1 are scratch registers. The _copyin/_copyout
# below assume that the SFC/DFC have been set previously.
#

#
# int _copyout(supervisor_addr, user_addr, nbytes)
#
	global 		_copyout
_copyout:
	mov.l		4(%sp),%a0		# source
	mov.l		8(%sp),%a1		# destination
	mov.l		12(%sp),%d0		# count
moreout:
	mov.b		(%a0)+,%d1		# fetch supervisor byte
	movs.b		%d1,(%a1)+		# store user byte
	subq.l		&0x1,%d0		# are we through yet?
	bne.w		moreout			# no; so, continue
	rts

#
# int _copyin(user_addr, supervisor_addr, nbytes)
#
	global 		_copyin
_copyin:
	mov.l		4(%sp),%a0		# source
	mov.l		8(%sp),%a1		# destination
	mov.l		12(%sp),%d0		# count
morein:
	movs.b		(%a0)+,%d1		# fetch user byte
	mov.b		%d1,(%a1)+		# write supervisor byte
	subq.l		&0x1,%d0		# are we through yet?
	bne.w		morein			# no; so, continue
	rts

############################################################################

#
# _060_real_trace():
#
# This is the exit point for the 060FPSP when an instruction is being traced
# and there are no other higher priority exceptions pending for this instruction
# or they have already been processed.
#
# The sample code below simply executes an "rte".
#
	global		_060_real_trace
_060_real_trace:
	rte

#
# _060_real_access():
#
# This is the exit point for the 060FPSP when an access error exception
# is encountered. The routine below should point to the operating system
# handler for access error exceptions. The exception stack frame is an
# 8-word access error frame.
#
# The sample routine below simply executes an "rte" instruction which
# is most likely the incorrect thing to do and could put the system
# into an infinite loop.
#
	global		_060_real_access
_060_real_access:
	rte
