Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

|

|       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

|

|       For details on the license for this file, please see the

|       file, README, in this same directory.

|

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

|

#include 

#include 

#include 

|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