tct.s

nuclues 内核源代码已经在arm7-9 上作了移植

;/*                                                                       */
;/*      TCC_Send_Signals                    Send signals to a task       */
;/*                                                                       */
;/* CALLS                                                                 */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* INPUTS                                                                */
;/*                                                                       */
;/*      task                                Task control block pointer   */
;/*                                                                       */
;/* OUTPUTS                                                               */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* HISTORY                                                               */
;/*                                                                       */
;/*         NAME            DATE                    REMARKS               */
;/*                                                                       */
;/*      W. Lamie        02-15-1994      Created initial version 1.0      */
;/*      D. Lamie        02-15-1994      Verified version 1.0             */
;/*                                                                       */
;/*************************************************************************/
;VOID  TCT_Build_Signal_Frame(TC_TCB *task)
;{
        EXPORT  TCT_Build_Signal_Frame
TCT_Build_Signal_Frame

;    /* Pickup the stack pointer.  */
;    REG_Stack_Ptr =  (BYTE_PTR) task -> tc_stack_pointer
;    
        LDR     a4,[a1,#&2c]                ; Pickup the current stack pointer

;    /* Reference the Signal shell.  */
;    REG_Function_Ptr =  (VOID *) TCC_Signal_Shell

;    /* Build a signal stack.  This signal stack frame facilitates an 
;       solicited return to the TCC_Signal_Shell function, which in turn 
;       invokes the appropriate signal handler.  The initial HISR stack frame 
;       has the following format:

;               (Lower Address) Stack Top ->    0       (Solicited stack type)
;                !!FOR THUMB ONLY!!             0/0x20  Saved state mask
;                                               v1      Saved v1
;                                               v2      Saved v2
;                                               v3      Saved v3
;                                               v4      Saved v4
;                                               v5      Saved v5
;                                               v6/sb   Saved v6/sl
;                                               v7/sl   Saved v7/sl
;                                               fp      Saved fp
;                                               ip      Saved ip
;               (Higher Address) Stack Bottom-> pc      Saved pc
;    */

        LDR     a3,Signal_Shell             ; Pickup address of shell entry
        [ THUMB
        BIC     a3,a3,#1                    ; Clear low bit
        ]

        SUB     a4,a4,#4                    ; Reserve a word

        STR     a3,[a4], #-4                ; Store entry address on stack
        ADD     a3,a4,#&4                   ; Compute initial sp
        STR     a3,[a4], #-4                ; Store initial ip
        STR     a3,[a4], #-4                ; Store initial fp
        LDR     a3,[a1,#&24]                ; Pickup the stack starting address
        STR     a3,[a4], #-4                ; Store initial v7/sl
        MOV     a3,#0                       ; Clear value for initial registers
        STR     v6,[a4], #-4                ; Store initial v6/sb
        STR     a3,[a4], #-4                ; Store initial v5
        STR     a3,[a4], #-4                ; Store initial v4
        STR     a3,[a4], #-4                ; Store initial v3
        STR     a3,[a4], #-4                ; Store initial v2
        STR     a3,[a4], #-4                ; Store initial v1
        [ THUMB
        MOV     a2,#&20                     ; Get initial state mask
        STR     a2,[a4], #-4                ; Store initial state mask  
        ]
        STR     a3,[a4, #0]                 ; Store solicited stack type on the
                                            ; top of the stack 

;    /* Save the new stack pointer into the task's control block.  */
;    task -> tc_stack_pointer =  (VOID *) (REG_Stack_Ptr - REG_Stack_Size)

        STR     a4,[a1, #&2C]               ; Save stack pointer

        BX      lr                          ; Return to caller
;}



;/*************************************************************************/
;/*                                                                       */
;/* FUNCTION                                                              */
;/*                                                                       */
;/*      TCT_Check_Stack                                                  */
;/*                                                                       */
;/* DESCRIPTION                                                           */
;/*                                                                       */
;/*      This function checks the current stack for overflow conditions.  */
;/*      Additionally, this function keeps track of the minimum amount    */
;/*      of stack space for the calling thread and returns the current    */
;/*      available stack space.                                           */
;/*                                                                       */
;/* CALLED BY                                                             */
;/*                                                                       */
;/*      TCC_Send_Signals                    Send signals to a task       */
;/*                                                                       */
;/* CALLS                                                                 */
;/*                                                                       */
;/*      ERC_System_Error                    System error handler         */
;/*                                                                       */
;/* INPUTS                                                                */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* OUTPUTS                                                               */
;/*                                                                       */
;/*      available bytes in stack                                         */
;/*                                                                       */
;/* HISTORY                                                               */
;/*                                                                       */
;/*         NAME            DATE                    REMARKS               */
;/*                                                                       */
;/*      W. Lamie        02-15-1994      Created initial version 1.0      */
;/*      D. Lamie        02-15-1994      Verified version 1.0             */
;/*                                                                       */
;/*************************************************************************/
;UNSIGNED  TCT_Check_Stack(void)
;{
        EXPORT  TCT_Check_Stack
TCT_Check_Stack

;TC_TCB         *thread
;UNSIGNED       remaining

;    /* Pickup the current task/HISR pointer.  */
;    thread =  (TC_TCB *) TCD_Current_Thread

        LDR     a1,Current_Thread           ; Pickup address of thread pointer
        LDR     a1,[a1,#0]                  ; Pickup thread pointer

;    /* Determine if there is a current thread.  */
;    if (thread)
;    {

        CMP     a1,#0                       ; Determine if a thread is active
        MOV     a4,#0                       ; Default remaining value
        BEQ     TCT_Skip_Stack_Check        ; If NU_NULL, skip stack checking

;        /* Determine if the stack pointers are out of range.  */
;        if ((thread -> tc_stack_pointer < thread -> tc_stack_start) ||
;            (thread -> tc_stack_pointer > thread -> tc_stack_end))

        LDR     a3,[a1,#&24]                ; Pickup start of stack area
        CMP     sp,a3                       ; Compare with current stack ptr
        BLT     TCT_Stack_Range_Error       ; If less, stack is out of range
        LDR     a2,[a1,#&28]                ; Pickup end of stack area
        CMP     sp,a2                       ; Compare with current stack ptr
        BLE     TCT_Stack_Range_Okay        ; If less, stack range is okay

;            /* Stack overflow condition exits.  */
;            ERC_System_Error(NU_STACK_OVERFLOW)

TCT_Stack_Range_Error

        STR     lr,[sp, #4]!                ; Store lr on the stack
        MOV     a1,#3                       ; Build NU_STACK_OVERFLOW code

        LDR     a4,=ERC_System_Error        ; Call system error handler.  Note:
        BX      a4                          ;   control is not returned!
                                            ;   Examine stack to find return
                                            ;   address of this routine.

TCT_Stack_Range_Okay

;        /* Calculate the amount of available space on the stack.  */
;        remaining =  (BYTE_PTR) thread -> tc_stack_pointer -
;                          (BYTE_PTR) thread -> tc_stack_start

        SUB     a4,sp,a3                    ; Calculate remaining stack size

;        /* Determine if there is enough memory on the stack to save all of the
;           registers.  */
;        if (remaining < 80)

        CMP     a4,#80                      ; Is there enough room for an 
                                            ; interrupt frame?
        BCS     TCT_No_Stack_Error          ; If so, no stack overflow yet

;            /* Stack overflow condition is about to happen.  */
;            ERC_System_Error(NU_STACK_OVERFLOW)

        STR     lr,[sp, #4]!                ; Store lr on the stack
        MOV     a1,#3                       ; Build NU_STACK_OVERFLOW code


        LDR     a4,=ERC_System_Error        ; Call system error handler.  Note:
        BX      a4                          ;   control is not returned!
                                            ;   Examine stack to find return
                                            ;   address of this routine.


TCT_No_Stack_Error

;        /* Determine if this is a new minimum amount of stack space.  */
;        if (remaining < thread -> tc_stack_minimum)

        LDR     a3,[a1,#&34]
        CMP     a4,a3
        STRCC   a4,[a1,#&34]

;            /* Save the new stack minimum.  */
;            thread -> tc_stack_minimum =  remaining
;    }
;    else

;        /* Set the remaining bytes to 0.  */
;        remaining =  0

;    /* Return the remaining number of bytes on the stack.  */
;    return(remaining)

TCT_Skip_Stack_Check
        MOV     a1,a4                       ; Return remaining bytes

        BX      lr                          ; Return to caller
;}



;/*************************************************************************/
;/*                                                                       */
;/* FUNCTION                                                              */
;/*                                                                       */
;/*      TCC_Schedule                                                     */
;/*                                                                       */
;/* DESCRIPTION                                                           */
;/*                                                                       */
;/*      This function waits for a thread to become ready.  Once a thread */
;/*      is ready, this function initiates a transfer of control to that  */
;/*      thread.                                                          */
;/*                                                                       */
;/* CALLED BY                                                             */
;/*                                                                       */
;/*      INC_Initialize                      Main initialization routine  */
;/*                                                                       */
;/* CALLS                                                                 */
;/*                                                                       */
;/*      TCT_Control_To_Thread               Transfer control to a thread */
;/*                                                                       */
;/* INPUTS                                                                */