|~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|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:
	btst		#0x5,0x4(%a6)		| check for supervisor state
	beqs		user_write
super_write:
	move.b		(%a0)+,(%a1)+		| copy 1 byte
	subq.l		#0x1,%d0		| decr byte counter
	bnes		super_write		| quit if ctr = 0
	clr.l		%d1			| return success
	rts
user_write:
	move.l		%d0,-(%sp)		| pass: counter
	move.l		%a1,-(%sp)		| pass: user dst
	move.l		%a0,-(%sp)		| pass: supervisor src
	bsr.l		_copyout		| write byte to user mem
	move.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
	beqs		user_read
super_read:
	move.b		(%a0)+,(%a1)+		| copy 1 byte
	subq.l		#0x1,%d0		| decr byte counter
	bnes		super_read		| quit if ctr = 0
	clr.l		%d1			| return success
	rts
user_read:
	move.l		%d0,-(%sp)		| pass: counter
	move.l		%a1,-(%sp)		| pass: super dst
	move.l		%a0,-(%sp)		| pass: user src
	bsr.l		_copyin			| read byte from user mem
	move.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
	bnes		dmrbs			| supervisor
dmrbu:	clr.l		%d0			| clear whole longword
dmrbuae:movs.b		(%a0),%d0		| fetch user byte
	bras		dmrbr
dmrbs:	clr.l		%d0			| clear whole longword
	move.b		(%a0),%d0		| fetch super byte
dmrbr:	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
|
| _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:
	btst		#0x5,0x4(%a6)		| check for supervisor state
	bnes		dmrws			| supervisor
dmrwu:	clr.l		%d0			| clear whole longword
dmrwuae:movs.w		(%a0), %d0		| fetch user word
	bras		dmrwr
dmrws:	clr.l		%d0			| clear whole longword
	move.w		(%a0), %d0		| fetch super word
dmrwr:	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
|
| _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:
	btst		#0x5,0x4(%a6)		| check for supervisor state
	bnes		dmrls			| supervisor
dmrlu:
dmrluae:movs.l		(%a0),%d0		| fetch user longword
	bras		dmrlr
dmrls:	move.l		(%a0),%d0		| fetch super longword
dmrlr:	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
	bnes		dmwbs			| supervisor
dmwbu:
dmwbuae:movs.b		%d0,(%a0)		| store user byte
	bras		dmwbr
dmwbs:	move.b		%d0,(%a0)		| store super byte
dmwbr:	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
	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:
	btst		#0x5,0x4(%a6)		| check for supervisor state
	bnes		dmwls			| supervisor
dmwlu:
dmwluae:movs.l		%d0,(%a0)		| store user longword
	bra		dmwlr
dmwls:	move.l		%d0,(%a0)		| store super longword
dmwlr:	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.
|
| 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

|###########################################################################

|
| _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	SYMBOL_NAME(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	SYMBOL_NAME(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
