Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

|~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

|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 

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

| 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