|~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  |MOTOROLA MICROPROCESSOR & MEMORY TECHNOLOGY GROUP
  |M68000 Hi-Performance Microprocessor Division
  |M68060 Software Package
  |Production Release P1.00 -- October 10, 1994
  |
  |M68060 Software Package Copyright © 1993, 1994 Motorola Inc.  All rights reserved.
  |
  |THE SOFTWARE is provided on an "AS IS" basis and without warranty.
  |To the maximum extent permitted by applicable law,
  |MOTOROLA DISCLAIMS ALL WARRANTIES WHETHER EXPRESS OR IMPLIED,
  |INCLUDING IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
  |and any warranty against infringement with regard to the SOFTWARE
  |(INCLUDING ANY MODIFIED VERSIONS THEREOF) and any accompanying written materials.
  |
  |To the maximum extent permitted by applicable law,
  |IN NO EVENT SHALL MOTOROLA BE LIABLE FOR ANY DAMAGES WHATSOEVER
  |(INCLUDING WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
  |BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR OTHER PECUNIARY LOSS)
  |ARISING OF THE USE OR INABILITY TO USE THE SOFTWARE.
  |Motorola assumes no responsibility for the maintenance and support of the SOFTWARE.
  |
  |You are hereby granted a copyright license to use, modify, and distribute the SOFTWARE
  |so long as this entire notice is retained without alteration in any modified and/or
  |redistributed versions, and that such modified versions are clearly identified as such.
  |No licenses are granted by implication, estoppel or otherwise under any patents
  |or trademarks of Motorola, Inc.
  |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  | os.s
  |
  | This file contains:
  |	- example "Call-Out"s required by both the ISP and FPSP.
  |
  
  #include <linux/linkage.h>
  
  |################################
  | 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.
  |
  | Linux/68k: The _060_[id]mem_{read,write}_{byte,word,long} functions
  | (i.e. all the known length <= 4) are implemented by single moves
  | statements instead of (more expensive) copy{in,out} calls, if
  | working in user space
  
  |
  | _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:
  	subq.l		#1,%d0
  	btst		#0x5,0x4(%a6)		| check for supervisor state
  	beqs		user_write
  super_write:
  	move.b		(%a0)+,(%a1)+		| copy 1 byte
  	dbra		%d0,super_write		| quit if --ctr < 0
  	clr.l		%d1			| return success
  	rts
  user_write:
  	move.b		(%a0)+,%d1		| copy 1 byte
  copyoutae:
  	movs.b		%d1,(%a1)+
  	dbra		%d0,user_write		| quit if --ctr < 0
  	clr.l		%d1			| return success
  	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:
  	subq.l		#1,%d0
  	btst		#0x5,0x4(%a6)		| check for supervisor state
  	beqs		user_read
  super_read:
  	move.b		(%a0)+,(%a1)+		| copy 1 byte
  	dbra		%d0,super_read		| quit if --ctr < 0
  	clr.l		%d1			| return success
  	rts
  user_read:
  copyinae:
  	movs.b		(%a0)+,%d1
  	move.b		%d1,(%a1)+		| copy 1 byte
  	dbra		%d0,user_read		| quit if --ctr < 0
  	clr.l		%d1			| return success
  	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:
  	clr.l		%d0			| clear whole longword
  	clr.l		%d1			| assume success
  	btst		#0x5,0x4(%a6)		| check for supervisor state
  	bnes		dmrbs			| supervisor
  dmrbuae:movs.b		(%a0),%d0		| fetch user byte
  	rts
  dmrbs:	move.b		(%a0),%d0		| fetch super byte
  	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
  |
  | _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_dmem_read_word
  	.global		_060_imem_read_word
  _060_dmem_read_word:
  _060_imem_read_word:
  	clr.l		%d1			| assume success
  	clr.l		%d0			| clear whole longword
  	btst		#0x5,0x4(%a6)		| check for supervisor state
  	bnes		dmrws			| supervisor
  dmrwuae:movs.w		(%a0), %d0		| fetch user word
  	rts
  dmrws:	move.w		(%a0), %d0		| fetch super word
  	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
  |
  | _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_dmem_read_long
  	.global		_060_imem_read_long
  _060_dmem_read_long:
  _060_imem_read_long:
  	clr.l		%d1			| assume success
  	btst		#0x5,0x4(%a6)		| check for supervisor state
  	bnes		dmrls			| supervisor
  dmrluae:movs.l		(%a0),%d0		| fetch user longword
  	rts
  dmrls:	move.l		(%a0),%d0		| fetch super longword
  	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:
  	clr.l		%d1			| assume success
  	btst		#0x5,0x4(%a6)		| check for supervisor state
  	bnes		dmwbs			| supervisor
  dmwbuae:movs.b		%d0,(%a0)		| store user byte
  	rts
  dmwbs:	move.b		%d0,(%a0)		| store super byte
  	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:
  	clr.l		%d1			| assume success
  	btst		#0x5,0x4(%a6)		| check for supervisor state
  	bnes		dmwws			| supervisor
  dmwwu:
  dmwwuae:movs.w		%d0,(%a0)		| store user word
  	bras		dmwwr
  dmwws:	move.w		%d0,(%a0)		| store super word
  dmwwr:	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:
  	clr.l		%d1			| assume success
  	btst		#0x5,0x4(%a6)		| check for supervisor state
  	bnes		dmwls			| supervisor
  dmwluae:movs.l		%d0,(%a0)		| store user longword
  	rts
  dmwls:	move.l		%d0,(%a0)		| store super longword
  	rts
  
  
  #if 0
  |###############################################
  
  |
  | 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.
  |
  | Linux/68k: These are basically non-inlined versions of
  | memcpy_{to,from}fs, but without long-transfer optimization
  | Note: Assumed that SFC/DFC are pointing correctly to user data
  | space... Should be right, or are there any exceptions?
  
  |
  | int _copyout(supervisor_addr, user_addr, nbytes)
  |
  	.global		_copyout
  _copyout:
  	move.l		4(%sp),%a0		| source
  	move.l		8(%sp),%a1		| destination
  	move.l		12(%sp),%d0		| count
  	subq.l		#1,%d0
  moreout:
  	move.b		(%a0)+,%d1		| fetch supervisor byte
  copyoutae:
  	movs.b		%d1,(%a1)+		| store user byte
  	dbra		%d0,moreout		| are we through yet?
  	moveq		#0,%d0			| return success
  	rts
  
  |
  | int _copyin(user_addr, supervisor_addr, nbytes)
  |
  	.global		_copyin
  _copyin:
  	move.l		4(%sp),%a0		| source
  	move.l		8(%sp),%a1		| destination
  	move.l		12(%sp),%d0		| count
      subq.l      #1,%d0
  morein:
  copyinae:
  	movs.b		(%a0)+,%d1		| fetch user byte
  	move.b		%d1,(%a1)+		| write supervisor byte
  	dbra		%d0,morein		| are we through yet?
  	moveq		#0,%d0			| return success
  	rts
  #endif
  
  |###########################################################################
  
  |
  | _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:
  	bral	trap
  
  |
  | _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:
  	bral	buserr
  
  
  
  | Execption handling for movs access to illegal memory
  	.section .fixup,#alloc,#execinstr
  	.even
  1:	moveq		#-1,%d1
  	rts
  .section __ex_table,#alloc
  	.align 4
  	.long	dmrbuae,1b
  	.long	dmrwuae,1b
  	.long	dmrluae,1b
  	.long	dmwbuae,1b
  	.long	dmwwuae,1b
  	.long	dmwluae,1b
  	.long	copyoutae,1b
  	.long	copyinae,1b
  	.text