view src/cs/os/nucleus/tct.s @ 581:a0a45c5eb3ef

gsmcomp.c: bumping trace partition size to 220 like in gprscomp.c This change is safe in terms of RAM usage because all of these partition pools have already been moved from XRAM to IRAM earlier, and our IRAM usage in VO configs is currently quite low - the one near the limit is XRAM on C11x.
author Mychaela Falconia <falcon@freecalypso.org>
date Tue, 29 Jan 2019 03:52:49 +0000
parents 945cf7f506b2
children
line wrap: on
line source

;/*************************************************************************/
;/*                                                                       */
;/*        Copyright (c) 1993-1994 Accelerated Technology, Inc.           */
;/*                                                                       */
;/* PROPRIETARY RIGHTS of Accelerated Technology are involved in the      */
;/* subject matter of this material.  All manufacturing, reproduction,    */
;/* use, and sales rights pertaining to this subject matter are governed  */
;/* by the license agreement.  The recipient of this software implicitly  */
;/* accepts the terms of the license.                                     */
;/*                                                                       */
;/*************************************************************************/
;
;/*************************************************************************/
;/*                                                                       */
;/* FILE NAME                                            VERSION          */
;/*                                                                       */
;/*      tct.s                                       PLUS/THUMB/T 1.2     */
;/*                                                                       */
;/* COMPONENT                                                             */
;/*                                                                       */
;/*      TC - Thread Control                                              */
;/*                                                                       */
;/* DESCRIPTION                                                           */
;/*                                                                       */
;/*      This file contains the target processor dependent routines for   */
;/*      performing target-dependent scheduling functions.                */
;/*                                                                       */
;/* AUTHOR                                                                */
;/*                                                                       */
;/*      Barry Sellew, Accelerated Technology, Inc.                       */
;/*                                                                       */
;/* DATA STRUCTURES                                                       */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* FUNCTIONS                                                             */
;/*                                                                       */
;/*      TCT_Control_Interrupts              Enable / disable interrupts  */
;/*                                          by changing                  */
;/*                                          TCD_Interrupt_Level          */
;/*      TCT_Local_Control_Interrupts        Enable/disable interrupts    */
;/*                                          by not changing              */
;/*                                          TCD_Interrupt_Level          */
;/*      TCT_Restore_Interrupts              Restores interrupts to the   */
;/*                                          level in TCD_Interrupt_Level */
;/*      TCT_Build_Task_Stack                Build initial task stack     */
;/*      TCT_Build_HISR_Stack                Build initial HISR stack     */
;/*      TCT_Build_Signal_Frame              Build signal handler frame   */
;/*      TCT_Check_Stack                     Check current stack          */
;/*      TCT_Schedule                        Schedule the next thread     */
;/*      TCT_Control_To_Thread               Transfer control to a thread */
;/*      TCT_Control_To_System               Transfer control from thread */
;/*      TCT_Signal_Exit                     Exit from signal handler     */
;/*      TCT_Current_Thread                  Returns a pointer to current */
;/*                                            thread                     */
;/*      TCT_Set_Execute_Task                Sets TCD_Execute_Task under  */
;/*                                            protection from interrupts */
;/*      TCT_Protect                         Protect critical section     */
;/*      TCT_Unprotect                       Unprotect critical section   */
;/*      TCT_Unprotect_Specific              Release specific protection  */
;/*      TCT_Set_Current_Protect             Set the thread's current     */
;/*                                            protection field           */
;/*      TCT_Protect_Switch                  Switch to protected thread   */
;/*      TCT_Schedule_Protected              Schedule the protected thread*/
;/*      TCT_Interrupt_Context_Save          Save interrupted context     */
;/*      TCT_Interrupt_Context_Restore       Restore interrupted context  */
;/*      TCT_Activate_HISR                   Activate a HISR              */
;/*      TCT_HISR_Shell                      HISR execution shell         */
;/*                                                                       */
;/* DEPENDENCIES                                                          */
;/*                                                                       */
;/*      cs_extr.h                           Common Service functions     */
;/*      tc_extr.h                           Thread Control functions     */
;/*                                                                       */
;/* HISTORY                                                               */
;/*                                                                       */
;/*         NAME            DATE                    REMARKS               */
;/*                                                                       */
;/*      B. Sellew       01-19-1996      Created initial version 1.0      */
;/*	 B. Sellew	 01-22-1996	 Verified version 1.0		  */
;/*	 B. Sellew	 04-19-1996	 Added saving and restoring of    */
;/*					   v5, v6, and ip, resulting in   */
;/*					   version 1.2 (spr103)		  */
;/*	 P. Roussel (TI) 07-21-1999	 Modified TCT_Schedule for GSM    */
;/*					 small sleep implementation    	  */
;/*                                                                       */
;/*************************************************************************/
;#define         NU_SOURCE_FILE
;
;#include        "cs_extr.h"                 /* Common service functions  */
;#include        "tc_extr.h"                 /* Thread control functions  */
;
;/* Define constants used in low-level initialization.  */
;
;
LOCKOUT         .equ     00C0h              ; Interrupt lockout value
LOCK_MSK        .equ     00C0h              ; Interrupt lockout mask value
MODE_MASK       .equ     001Fh              ; Processor Mode Mask
SUP_MODE        .equ     0013h              ; Supervisor Mode (SVC)
IRQ_MODE        .equ     0012h              ; Interrupt Mode (IRQ)
FIQ_MODE        .equ     0011h              ; Fast Interrupt Mode (FIQ)
;
;
;
;/* Define a variable for saving the system stack limit in.  This value is
;   intialized in INT.S and is in effect whenever the system stack is in 
;   use.  */
;
;VOID    *TCT_System_Limit;
;
;/* Define internal variables so the C compiler can provide meaningful 
;   code with offsets into data structures.  Typically, this section is
;   removed after this file is compiled down to assembly language.  */
;   
;BYTE_PTR        REG_Stack_Base;
;BYTE_PTR        REG_Stack_End;
;BYTE_PTR        REG_Stack_Ptr;
;UNSIGNED        REG_Stack_Size;
;TC_TCB         *REG_Thread_Ptr;
;TC_HCB         *REG_HISR_Ptr;
;TC_PROTECT     *REG_Protect_Ptr;
;VOID           *REG_Function_Ptr;
;
        .def   _TCT_System_Limit
        .bss   _TCT_System_Limit, 4, 4
;
;
        .text
;
;/* Define external inner-component global data references.  */
;
;extern TC_TCB          *TCD_Execute_Task;
;extern TC_HCB          *TCD_Execute_HISR;
;extern VOID            *TCD_Current_Thread;
;extern VOID            *TCD_System_Stack;
;extern INT              TCD_Interrupt_Count;
;extern TC_HCB          *TCD_Active_HISR_Heads[TC_HISR_PRIORITIES];
;extern TC_HCB          *TCD_Active_HISR_Tails[TC_HISR_PRIORITIES];
;extern INT              TCD_Interrupt_Level;
;extern UNSIGNED         TMD_Time_Slice;
;extern INT              TMD_Time_Slice_State;
;
        .ref    _TCD_Execute_Task
        .ref    _TCD_Execute_HISR
        .ref    _TCD_Current_Thread
        .ref    _TCD_System_Stack
        .ref    _TCD_Interrupt_Count
        .ref    _TCD_Active_HISR_Heads
        .ref    _TCD_Active_HISR_Tails
        .ref    _TCD_Interrupt_Level
        .ref    _TMD_Time_Slice
        .ref    _TMD_Time_Slice_State
;
;
;/* Define external function references.  */
;VOID    TCC_Task_Shell(VOID);
;VOID    TCC_Signal_Shell(VOID);
;VOID    TCT_HISR_Shell(VOID);
;VOID    ERC_System_Error(INT error);
;
        .ref    $TCC_Task_Shell
        .ref    $TCC_Signal_Shell
        .ref    $ERC_System_Error
	.ref	IND_CALL
;
;/* Define internal function references.  */
;VOID  TCT_Schedule_Protected(VOID *thread);
;
        .def    _TCT_Schedule_Protected
;
;
;/*************************************************************************/
;/*                                                                       */
;/* FUNCTION                                                              */
;/*                                                                       */
;/* TCT_Control_Interrupts                                                */
;/*                                                                       */
;/* DESCRIPTION                                                           */
;/*                                                                       */
;/*      This function enables and disables interrupts as specified by    */
;/*      the caller.  Interrupts disabled by this call are left disabled  */
;/*      until the another call is made to enable them.                   */
;/*                                                                       */
;/* AUTHOR                                                                */
;/*                                                                       */
;/*      Barry Sellew, Accelerated Technology, Inc.                       */
;/*                                                                       */
;/* CALLED BY                                                             */
;/*                                                                       */
;/*      Application                                                      */
;/*                                                                       */
;/* CALLS                                                                 */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* INPUTS                                                                */
;/*                                                                       */
;/*      new_level                           New interrupt enable level   */
;/*                                                                       */
;/* OUTPUTS                                                               */
;/*                                                                       */
;/*      old_level                           Previous interrupt enable    */
;/*                                            level                      */
;/*                                                                       */
;/* HISTORY                                                               */
;/*                                                                       */
;/*         NAME            DATE                    REMARKS               */
;/*                                                                       */
;/*      B. Sellew       01-19-1996      Created initial version 1.0      */
;/*	 B. Sellew	 01-22-1996	 Verified version 1.0		  */
;/*                                                                       */
;/*************************************************************************/
;INT TCT_Control_Interrupts (INT new_level)
;{
	.def	$TCT_Control_Interrupts
$TCT_Control_Interrupts			    ; Dual-state interworking veneer
	.state16
	BX	pc
	NOP
	.state32
	B	_TCT_Control_Interrupts
;
        .def    _TCT_Control_Interrupts
_TCT_Control_Interrupts
;
;INT     old_level;                          /* Old interrupt level       */
;
;    /* lock out all interrupts before any checking or changing */
;
;    /* Obtain the current interrupt lockout posture.  */
;    old_level =  TCD_Interrupt_Level;
;       
;    /* Setup new interrupt lockout posture.  */
;    TCD_Interrupt_Level =  new_level;
;        
;    /* renable interrupts for the specified lockout */
;
;    /* Return old interrupt lockout level.  */
;    return(old_level);
;
        MRS     a3,CPSR                     ; Pickup current CPSR
        ORR     a3,a3,#LOCKOUT              ; Build lockout CPSR
        MSR     CPSR,a3                     ; Lockout interrupts temporarily
        LDR     a2,Int_Level	            ; Pickup interrupt level
        LDR     a4,[a2, #0]                 ; Pickup current interrupt lockout
        BIC     a3,a3,#LOCK_MSK             ; Clear lockout mask
        ORR     a3,a3,a1                    ; Build new CPSR with appropriate
                                            ;   interrupts locked out
        STR     a1,[a2,#0]                  ; Save current lockout 
        MSR     CPSR,a3                     ; Setup new CPSR lockout bits
        MOV     a1,a4                       ; Return previous lockout
        BX      lr                          ; Return to caller
;}    
;
;
;
;/*************************************************************************/
;/*                                                                       */
;/* FUNCTION                                                              */
;/*                                                                       */
;/* TCT_Local_Control_Interrupts                                          */
;/*                                                                       */
;/* DESCRIPTION                                                           */
;/*                                                                       */
;/*      This function enables and disables interrupts as specified by    */
;/*      the caller.                                                      */
;/*                                                                       */
;/* AUTHOR                                                                */
;/*                                                                       */
;/*      Barry Sellew, Accelerated Technology, Inc.                       */
;/*                                                                       */
;/* CALLED BY                                                             */
;/*                                                                       */
;/*      Application                                                      */
;/*                                                                       */
;/* CALLS                                                                 */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* INPUTS                                                                */
;/*                                                                       */
;/*      new_level                           New interrupt enable level   */
;/*                                                                       */
;/* OUTPUTS                                                               */
;/*                                                                       */
;/*      old_level                           Previous interrupt enable    */
;/*                                            level                      */
;/*                                                                       */
;/* HISTORY                                                               */
;/*                                                                       */
;/*         NAME            DATE                    REMARKS               */
;/*                                                                       */
;/*      B. Sellew       01-19-1996      Created initial version 1.0      */
;/*	 B. Sellew	 01-22-1996	 Verified version 1.0		  */
;/*                                                                       */
;/*************************************************************************/
;INT TCT_Local_Control_Interrupts (INT new_level)
;{
	.def	$TCT_Local_Control_Interrupts
$TCT_Local_Control_Interrupts		    ; Dual-state interworking veneer
	.state16
	BX	pc
	NOP
	.state32
	B	_TCT_Local_Control_Interrupts
;
        .def    _TCT_Local_Control_Interrupts
_TCT_Local_Control_Interrupts
;
;INT     old_level;                          /* Old interrupt level       */
;
;    /* read in the old level */
;    old_level = current interrupt level of processor;
;
        MRS     a3,CPSR                     ; Pickup current CPSR
        MOV     a4,a3                       ; save the old level
;
;    /* clear out the old level and set the new level */
;    current interrupt level of processor &= ~LOCKOUT;
;    current interrupt level of processor |= new_level;
;
        BIC     a3,a3,#LOCK_MSK             ; Clear all current interrupts
        ORR     a3,a3,a1                    ; Build new CPSR with new
                                            ;   interrupt level
        MSR     CPSR,a3                     ; Setup new CPSR interrupt bits
;
;    /* Return old interrupt lockout level.  */
;    return(old_level);
;
        MOV     a1,a4                       ; Return previous lockout
        BX      lr                          ; Return to caller
;}    
;
;
;
;/*************************************************************************/
;/*                                                                       */
;/* FUNCTION                                                              */
;/*                                                                       */
;/*  TCT_Restore_Interrupts                                               */
;/*                                                                       */
;/* DESCRIPTION                                                           */
;/*                                                                       */
;/*      This function restores interrupts to that specified in the global*/
;/*      TCD_Interrupt_Level variable.                                    */
;/*                                                                       */
;/* AUTHOR                                                                */
;/*                                                                       */
;/*      Barry Sellew, Accelerated Technology, Inc.                       */
;/*                                                                       */
;/* CALLED BY                                                             */
;/*                                                                       */
;/*      Application                                                      */
;/*                                                                       */
;/* CALLS                                                                 */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* INPUTS                                                                */
;/*                                                                       */
;/*      None.                                                            */
;/*                                                                       */
;/* OUTPUTS                                                               */
;/*                                                                       */
;/*      None.                                                            */
;/*                                                                       */
;/* HISTORY                                                               */
;/*                                                                       */
;/*         NAME            DATE                    REMARKS               */
;/*                                                                       */
;/*      B. Sellew       01-19-1996      Created initial version 1.0      */
;/*	 B. Sellew	 01-22-1996	 Verified version 1.0		  */
;/*                                                                       */
;/*************************************************************************/
;VOID TCT_Restore_Interrupts  (VOID)
;{
	.def	$TCT_Restore_Interrupts
$TCT_Restore_Interrupts			    ; Dual-state interworking veneer
	.state16
	BX	pc
	NOP
	.state32
	B	_TCT_Restore_Interrupts
;
        .def    _TCT_Restore_Interrupts
_TCT_Restore_Interrupts
;
;    /* lock out all interrupts before any checking or changing */
;
;    /* Obtain the current interrupt lockout posture.  */
;       
;    /* reload the level base on the TCD_Interrupt_Level variable */
;        
;
        MRS     a2,CPSR                     ; Pickup current CPSR
        MOV     a3,a2                       ; save the CPSR value
        ORR     a2,a2,#LOCKOUT              ; Build lockout CPSR
        MSR     CPSR,a2                     ; Lockout interrupts temporarily
        BIC     a3,a3,#LOCK_MSK             ; Clear current interrupt levels
        LDR     a2,Int_Level	            ; Load address of TCD_Interrupt_Level
        LDR     a1,[a2, #0]                 ; Pickup current interrupt lockout
        ORR     a3,a3,a1                    ; Build new CPSR with appropriate
                                            ;   interrupts locked out
        MSR     CPSR,a3                     ; Setup new CPSR lockout bits
        BX      lr                          ; Return to caller
;}    
;
;
;
;/*************************************************************************/
;/*                                                                       */
;/* FUNCTION                                                              */
;/*                                                                       */
;/*      TCT_Build_Task_Stack                                             */
;/*                                                                       */
;/* DESCRIPTION                                                           */
;/*                                                                       */
;/*      This function builds an initial stack frame for a task.  The     */
;/*      initial stack contains information concerning initial values of  */
;/*      registers and the task's point of entry.  Furthermore, the       */
;/*      initial stack frame is in the same form as an interrupt stack    */
;/*      frame.                                                           */
;/*                                                                       */
;/* AUTHOR                                                                */
;/*                                                                       */
;/*      Barry Sellew, Accelerated Technology, Inc.                       */
;/*                                                                       */
;/* CALLED BY                                                             */
;/*                                                                       */
;/*      TCC_Create_Task                     Create a new task            */
;/*      TCC_Reset_Task                      Reset the specified task     */
;/*                                                                       */
;/* CALLS                                                                 */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* INPUTS                                                                */
;/*                                                                       */
;/*      task                                Task control block pointer   */
;/*                                                                       */
;/* OUTPUTS                                                               */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* HISTORY                                                               */
;/*                                                                       */
;/*         NAME            DATE                    REMARKS               */
;/*                                                                       */
;/*      B. Sellew       01-19-1996      Created initial version 1.0      */
;/*	 B. Sellew	 01-22-1996	 Verified version 1.0		  */
;/*                                                                       */
;/*************************************************************************/
;VOID  TCT_Build_Task_Stack(TC_TCB *task)
;{
	.def	$TCT_Build_Task_Stack
$TCT_Build_Task_Stack			    ; Dual-state interworking veneer
	.state16
	BX	pc
	NOP
	.state32
	B	_TCT_Build_Task_Stack
;
        .def    _TCT_Build_Task_Stack
_TCT_Build_Task_Stack
;
;    /* Pickup the stack base.  */
;    REG_Stack_Base =  (BYTE_PTR) task -> tc_stack_start;
;    
        LDR     a3,[a1,#24h]                ; Pickup the stack starting address
;
;    /* Pickup the stack size.  */
;    REG_Stack_Size =  task -> tc_stack_size;
;    
        LDR     a2,[a1,#30h]                ; Pickup the stack size in bytes
;
;    /* Calculate the stack ending address.  */
;    REG_Stack_End =  REG_Stack_Base + REG_Stack_Size - 1;
;
        ADD     a4,a2,a3                    ; Compute the beginning of stack
        BIC     a4,a4,#3                    ; Insure word alignment
        SUB     a4,a4,#4                    ; Reserve a word
;
;    /* Save the stack ending address.  */
;    task -> tc_stack_end =  REG_Stack_End;
;    
        STR     a4,[a1,#28h]                ; Save the stack ending address
;
;    /* Reference the task shell.  */
;    REG_Function_Ptr =  (VOID *) TCC_Task_Shell;
;
;    /* Build an initial stack.  This initial stack frame facilitates an 
;       interrupt return to the TCC_Task_Shell function, which in turn 
;       invokes the application task.  The initial stack frame has the 
;       following format:
;
;               (Lower Address) Stack Top ->    1       (Interrupt stack type)
;                                               CPSR    Saved CPSR
;                                               a1      Saved a1
;                                               a2      Saved a2
;                                               a3      Saved a3
;                                               a4      Saved a4
;                                               v1      Saved v1
;                                               v2      Saved v2
;                                               v3      Saved v3
;                                               v4      Saved v4
;						v5	Saved v5
;						v6	Saved v6
;                                               v7      Saved v7
;                                               v8      Saved v8
;						ip	Saved ip
;                                               sp      Saved sp
;                                               lr      Saved lr
;               (Higher Address) Stack Bottom-> pc      Saved pc
;    */
;
        LDR     a3,Task_Shell		    ; Pickup address of shell entry
        STR     a3,[a4], #-4                ; Store entry address on stack
        MOV     a3,#0                       ; Clear value for initial registers
        STR     a3,[a4], #-4                ; Store initial lr
        ADD     a3,a4,#8h                   ; Compute initial sp
        STR     a3,[a4], #-4                ; Store initial sp (Stack Bottom)
	STR	ip,[a4], #-4		    ; Store ip
        STR     a3,[a4], #-4                ; Store initial v8
        LDR     a3,[a1,#24h]                ; Pickup the stack starting address
        STR     a3,[a4], #-4                ; Store initial v7
        MOV     a3,#0                       ; Clear value for initial registers
	STR	v6,[a4], #-4		    ; Store v6
	STR	v5,[a4], #-4		    ; Store 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
        STR     a3,[a4], #-4                ; Store initial a4
        STR     a3,[a4], #-4                ; Store initial a3
        STR     a3,[a4], #-4                ; Store initial a2
        STR     a3,[a4], #-4                ; Store initial a1
        MSR     CPSR_FLG,a3                 ; Clear the flags
        MRS     a3,CPSR                     ; Pickup the CPSR
        BIC     a3,a3,#LOCK_MSK             ; Clear initial interrupt lockout
	ORR	a3,a3,#20h		    ; Set to Thumb state
        STR     a3,[a4], #-4                ; Store CPSR on the initial stack
        MOV     a3,#1                       ; Build interrupt stack type (1)
        STR     a3,[a4, #0]                 ; Store stack type on the top 
;    
;    /* Save the minimum amount of remaining stack memory.  */
;    task -> tc_stack_minimum =  REG_Stack_Size - 72;
;    
        MOV     a3,#72                      ; Size of interrupt stack frame
        SUB     a2,a2,a3                    ; Compute minimum available bytes
        STR     a2,[a1, #34h]               ; Save in minimum stack area
;
;    /* Save the new stack pointer into the task's control block.  */
;    task -> tc_stack_pointer =  (VOID *) Stack_Top;
;
        STR     a4,[a1, #2Ch]               ; Save stack pointer
        BX      lr
;}
;
;
;
;/*************************************************************************/
;/*                                                                       */
;/* FUNCTION                                                              */
;/*                                                                       */
;/*      TCT_Build_HISR_Stack                                             */
;/*                                                                       */
;/* DESCRIPTION                                                           */
;/*                                                                       */
;/*      This function builds an HISR stack frame that allows quick       */
;/*      scheduling of the HISR.                                          */
;/*                                                                       */
;/* AUTHOR                                                                */
;/*                                                                       */
;/*      Barry Sellew, Accelerated Technology, Inc.                       */
;/*                                                                       */
;/* CALLED BY                                                             */
;/*                                                                       */
;/*      TCC_Create_HISR                     Create HISR function         */
;/*                                                                       */
;/* CALLS                                                                 */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* INPUTS                                                                */
;/*                                                                       */
;/*      hisr                                HISR control block pointer   */
;/*                                                                       */
;/* OUTPUTS                                                               */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* HISTORY                                                               */
;/*                                                                       */
;/*         NAME            DATE                    REMARKS               */
;/*                                                                       */
;/*      B. Sellew       01-19-1996      Created initial version 1.0      */
;/*	 B. Sellew	 01-22-1996	 Verified version 1.0		  */
;/*                                                                       */
;/*************************************************************************/
;VOID  TCT_Build_HISR_Stack(TC_HCB *hisr)
;{
	.def	$TCT_Build_HISR_Stack
$TCT_Build_HISR_Stack			    ; Dual-state interworking veneer
	.state16
	BX	pc
	NOP
	.state32
	B	_TCT_Build_HISR_Stack
;
        .def    _TCT_Build_HISR_Stack
_TCT_Build_HISR_Stack
;
;    /* Pickup the stack base.  */
;    REG_Stack_Base =  (BYTE_PTR) hisr -> tc_stack_start;
;    
        LDR     a3,[a1,#24h]                ; Pickup the stack starting address
;
;    /* Pickup the stack size.  */
;    REG_Stack_Size =  hisr -> tc_stack_size;
;    
        LDR     a2,[a1,#30h]                ; Pickup the stack size in bytes
;
;    /* Calculate the stack ending address.  */
;    REG_Stack_End =  REG_Stack_Base + REG_Stack_Size;
;    
        ADD     a4,a2,a3                    ; Compute the beginning of stack
        BIC     a4,a4,#3                    ; Insure word alignment
        SUB     a4,a4,#4                    ; Reserve a word
;
;    /* Save the stack ending address.  */
;    hisr -> tc_stack_end =  REG_Stack_End;
;    
        STR     a4,[a1,#28h]                ; Save the stack ending address
;
;    /* Reference the HISR shell.  */
;    REG_Function_Ptr =  (VOID *) TCT_HISR_Shell;
;
;    /* Build an initial stack.  This initial stack frame facilitates an 
;       solicited return to the TCT_HISR_Shell function, which in turn 
;       invokes the appropriate HISR.  The initial HISR stack frame has the 
;       following format:
;
;               (Lower Address) Stack Top ->    0       (Solicited stack type)
;						0/0x20  Saved state mask
;                                               v1      Saved v1
;                                               v2      Saved v2
;                                               v3      Saved v3
;                                               v4      Saved v4
;						v5	Saved v5
;						v6	Saved v6
;                                               v7   	Saved v7
;                                               v8      Saved v8
;						ip	Saved ip
;               (Higher Address) Stack Bottom-> pc      Saved pc
;    */
;
        LDR     a3,HISR_Shell		    ; Pickup address of shell entry
        STR     a3,[a4], #-4                ; Store entry address on stack
        ADD     a3,a4,#4h                   ; Compute initial sp
	STR	ip,[a4], #-4		    ; Store ip
        STR     a3,[a4], #-4                ; Store initial v8
        LDR     a3,[a1,#24h]                ; Pickup the stack starting address
        STR     a3,[a4], #-4                ; Store initial v7
        MOV     a3,#0                       ; Clear value for initial registers
	STR	v6,[a4], #-4		    ; Store v6
	STR	v5,[a4], #-4		    ; Store 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
	STR	a3,[a4], #-4		    ; Store initial state mask
        STR     a3,[a4, #0]                 ; Store solicited stack type on the
                                            ;   top of the stack 
;
;    /* Save the minimum amount of remaining stack memory.  */
;    hisr -> tc_stack_minimum =  REG_Stack_Size - 44;
;        
        MOV     a3,#44                      ; Size of solicited stack frame
        SUB     a2,a2,a3                    ; Compute minimum available bytes
        STR     a2,[a1, #34h]               ; Save in minimum stack area
;
;    /* Save the new stack pointer into the task's control block.  */
;    hisr -> tc_stack_pointer =  (VOID *) Stack_Top;
;
        STR     a4,[a1, #2Ch]               ; Save stack pointer
        BX      lr                          ; Return to caller
;}
;
;
;
;/*************************************************************************/
;/*                                                                       */
;/* FUNCTION                                                              */
;/*                                                                       */
;/*      TCT_Build_Signal_Frame                                           */
;/*                                                                       */
;/* DESCRIPTION                                                           */
;/*                                                                       */
;/*      This function builds a frame on top of the task's stack to       */
;/*      cause the task's signal handler to execute the next time         */
;/*      the task is executed.                                            */
;/*                                                                       */
;/* AUTHOR                                                                */
;/*                                                                       */
;/*      Barry Sellew, Accelerated Technology, Inc.                       */
;/*                                                                       */
;/* CALLED BY                                                             */
;/*                                                                       */
;/*      TCC_Send_Signals                    Send signals to a task       */
;/*                                                                       */
;/* CALLS                                                                 */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* INPUTS                                                                */
;/*                                                                       */
;/*      task                                Task control block pointer   */
;/*                                                                       */
;/* OUTPUTS                                                               */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* HISTORY                                                               */
;/*                                                                       */
;/*         NAME            DATE                    REMARKS               */
;/*                                                                       */
;/*      B. Sellew       01-19-1996      Created initial version 1.0      */
;/*	 B. Sellew	 01-22-1996	 Verified version 1.0		  */
;/*                                                                       */
;/*************************************************************************/
;VOID  TCT_Build_Signal_Frame(TC_TCB *task)
;{
	.def	$TCT_Build_Signal_Frame
$TCT_Build_Signal_Frame			    ; Dual-state interworking veneer
	.state16
	BX	pc
	NOP
	.state32
	B	_TCT_Build_Signal_Frame
;
        .def    _TCT_Build_Signal_Frame
_TCT_Build_Signal_Frame
;
;    /* Pickup the stack pointer.  */
;    REG_Stack_Ptr =  (BYTE_PTR) task -> tc_stack_pointer;
;    
        LDR     a4,[a1,#2ch]                ; 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)
;						0/0x20  Saved state mask
;                                               v1      Saved v1
;                                               v2      Saved v2
;                                               v3      Saved v3
;                                               v4      Saved v4
;						v5	Saved v5
;						v6	Saved v6
;                                               v7   	Saved v7
;                                               v8      Saved v8
;						ip	Saved ip
;               (Higher Address) Stack Bottom-> pc      Saved pc
;    */
;
        LDR     a3,Signal_Shell		    ; Pickup address of shell entry
        STR     a3,[a4], #-4                ; Store entry address on stack
        ADD     a3,a4,#4h                   ; Compute initial sp
	STR	ip,[a4], #-4		    ; Store ip
        STR     a3,[a4], #-4                ; Store initial v8
        LDR     a3,[a1,#24h]                ; Pickup the stack starting address
        STR     a3,[a4], #-4                ; Store initial v7
        MOV     a3,#0                       ; Clear value for initial registers
	STR	v6,[a4], #-4		    ; Store v6
	STR	v5,[a4], #-4		    ; Store 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
	MOV	a2,#20h			    ; Get initial state mask
	STR	a2,[a4, #0]		    ; 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, #2Ch]               ; 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.                                           */
;/*                                                                       */
;/* AUTHOR                                                                */
;/*                                                                       */
;/*      Barry Sellew, Accelerated Technology, Inc.                       */
;/*                                                                       */
;/* 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               */
;/*                                                                       */
;/*      B. Sellew       01-19-1996      Created initial version 1.0      */
;/*	 B. Sellew	 01-22-1996	 Verified version 1.0		  */
;/*                                                                       */
;/*************************************************************************/
;UNSIGNED  TCT_Check_Stack(void)
;{
	.def	$TCT_Check_Stack
$TCT_Check_Stack			    ; Dual-state interworking veneer
	.state16
	BX	pc
	NOP
	.state32
	B	_TCT_Check_Stack
;
        .def    _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,#24h]                ; 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,#28h]                ; 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,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,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,#34h]
        CMP     a4,a3
        STRCC   a4,[a1,#34h]
;
;            /* 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.                                                          */
;/*                                                                       */
;/* AUTHOR                                                                */
;/*                                                                       */
;/*      Barry Sellew, Accelerated Technology, Inc.                       */
;/*                                                                       */
;/* CALLED BY                                                             */
;/*                                                                       */
;/*      INC_Initialize                      Main initialization routine  */
;/*                                                                       */
;/* CALLS                                                                 */
;/*                                                                       */
;/*      TCT_Control_To_Thread               Transfer control to a thread */
;/*      INT_Small_Sleep		     GSM small sleep              */
;/* INPUTS                                                                */
;/*                                                                       */
;/*      TCD_Execute_Task                    Pointer to task to execute   */
;/*                                                                       */
;/* OUTPUTS                                                               */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* HISTORY                                                               */
;/*                                                                       */
;/*         NAME            DATE                    REMARKS               */
;/*                                                                       */
;/*      B. Sellew       01-19-1996      Created initial version 1.0      */
;/*	 B. Sellew	 01-22-1996	 Verified version 1.0		  */
;/*	 P. Roussel (TI) 07-21-1999	 Call GSM small sleep 		  */
;/*                                                                       */
;/*************************************************************************/
;VOID  TCT_Schedule(void)
;{
	.def	$TCT_Schedule
$TCT_Schedule				    ; Dual-state interworking veneer
	.state16
	BX	pc
	NOP
	.state32
	B	_TCT_Schedule
;
        .def    _TCT_Schedule
_TCT_Schedule
;
;    /* Restore interrupts according to the value contained in 
;       TCD_Interrupt_Level.  */
;
        LDR     a2,Int_Level	            ; Build address of interrupt level
        MRS     a1,CPSR                     ; Pickup current CPSR
        LDR     a3,[a2, #0]                 ; Pickup current interrupt lockout
        BIC     a1,a1,#LOCK_MSK             ; Clear the interrupt lockout bits
        ORR     a1,a1,a3                    ; Build new interrupt lockout CPSR
        MSR     CPSR,a1                     ; Setup new CPSR 
        LDR     a3,Execute_HISR		    ; Pickup TCD_Execute_HISR address
        LDR     a4,Execute_Task		    ; Pickup TCD_Execute_Task address
;
;    /* Wait until a thread (task or HISR) is available to execute.  */
;    do
;    {
	.def	TCT_Schedule_Loop
TCT_Schedule_Loop
;
;    } while ((!TCD_Execute_HISR) && (!TCD_Execute_Task));
;
        LDR     a1,[a3, #0]                 ; Pickup highest priority HISR ptr
        CMP     a1,#0                       ; Is there a HISR active?
        BNE     TCT_Schedule_Thread         ; Found an HISR
        LDR     a1,[a4, #0]                 ; Pickup highest priority Task ptr
        CMP     a1,#0                       ; Is there a task active?

        .ref    INT_Small_Sleep
        BEQ     INT_Small_Sleep		    ; No, enter the GSM Small Sleep mode
	
;
;    /* Yes, either a task or an HISR is ready to execute.  Lockout 
;       interrupts while the thread is transferred to.  */
;
TCT_Schedule_Thread
        MRS     a2,CPSR                     ; Pickup CPSR again
        ORR     a2,a2,#LOCKOUT              ; Build interrupt lockout value
        MSR     CPSR,a2                     ; Lockout interrupts
;    
;    /* Transfer control to the thread by falling through to the following
;       routine.  */
;}
;
;
;
;/*************************************************************************/
;/*                                                                       */
;/* FUNCTION                                                              */
;/*                                                                       */
;/*      TCT_Control_To_Thread                                            */
;/*                                                                       */
;/* DESCRIPTION                                                           */
;/*                                                                       */
;/*      This function transfers control to the specified thread.  Each   */
;/*      time control is transferred to a thread, its scheduled counter   */
;/*      is incremented.  Additionally, time-slicing for task threads is  */
;/*      enabled in this routine.  The TCD_Current_Thread pointer is      */
;/*      setup by this function.                                          */
;/*                                                                       */
;/* AUTHOR                                                                */
;/*                                                                       */
;/*      Barry Sellew, Accelerated Technology, Inc.                       */
;/*                                                                       */
;/* CALLED BY                                                             */
;/*                                                                       */
;/*      TCT_Schedule                        Indirectly called            */
;/*      TCT_Protect                         Protection task switch       */
;/*                                                                       */
;/* CALLS                                                                 */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* INPUTS                                                                */
;/*                                                                       */
;/*      thread                              Thread control block pointer */
;/*                                                                       */
;/* OUTPUTS                                                               */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* HISTORY                                                               */
;/*                                                                       */
;/*         NAME            DATE                    REMARKS               */
;/*                                                                       */
;/*      B. Sellew       01-19-1996      Created initial version 1.0      */
;/*	 B. Sellew	 01-22-1996	 Verified version 1.0		  */
;/*                                                                       */
;/*************************************************************************/
;VOID  TCT_Control_To_Thread(TC_TCB *thread)
;{
;
_TCT_Control_To_Thread
;
;    /* Setup the current thread pointer.  */
;    TCD_Current_Thread =  (VOID *) thread;
;
        LDR     a2,Current_Thread	    ; Pickup current thread ptr address
        LDR     a3,[a1, #1ch]               ; Pickup scheduled count
        STR     a1,[a2, #0]                 ; Setup current thread pointer
; TI CODE : Call the Function that log the Current Thread.

  .if OP_L1_STANDALONE = 0
    .if TI_NUC_MONITOR = 1
  		.global _ti_nuc_monitor_Thread_log
		STMFD	sp!,{r0-r5}
		BL		_ti_nuc_monitor_Thread_log		; Call the Thread Log function.
		LDMFD	sp!,{r0-r5}
    .endif
  .endif
;
;    /* Increment the thread scheduled counter.  */
;    thread -> tc_scheduled++;
;
        LDR     a4,[a1, #20h]               ; Pickup time slice value
        ADD     a3,a3,#1                    ; Increment the scheduled count
        STR     a3,[a1, #1ch]               ; Store new scheduled count
;
;    /* Check for time slice option.  */
;    if (thread -> tc_cur_time_slice)
;    {
        CMP     a4,#0                       ; Is there a time slice?
        BEQ     TCT_No_Start_TS_1           ; If 0, there is no time slice
;
;        /* Start a time slice.  */
;        TMD_Time_Slice =        thread -> tc_cur_time_slice;
;        TMD_Time_Slice_State =  0;
;
        LDR     a3,Time_Slice		    ; Pickup address of TMD_Time_Slice
        LDR     a2,Slice_State		    ; Pickup address of 
                                            ;   TMD_Time_Slice_State
        STR     a4,[a3,#0]                  ; Setup the time slice
        MOV     a3,#0                       ; Build active state flag
        STR     a3,[a2,#0]                  ; Set the active flag
;    }
TCT_No_Start_TS_1
;
;    /* Pickup the stack pointer and resume the thread.  */
;    REG_Stack_Ptr =  thread -> tc_stack_pointer;
;
        LDR     sp,[a1, #2ch]               ; Switch to thread's stack pointer
;         
;     /* Pop off the saved information associated with the thread. After we
;        determine which type of stack is present.  A 1 on the top of the 
;        stack indicates an interrupt stack, while a 0 on the top of the
;        stack indicates a solicited type of stack.  */
;        
;     /* Remember that the interrupt level that is restored must represent
;        the interrupt level in TCD_Interrupt_Level.  */
;
        LDR     a2,[sp], #4                 ; Pop off the stack type 
        CMP     a2,#1                       ; See if it is an interrupt stack
        BEQ     TCT_Interrupt_Resume        ; If so, an interrupt resume of
                                            ;   thread is required
        LDR     a2,Int_Level		    ; Pickup address of interrupt 
                                            ;   lockout
        MRS     a1,CPSR                     ; Pickup current CPSR
        BIC     a1,a1,#LOCK_MSK             ; Clear lockout mask
        LDR     a3,[a2, #0]                 ; Pickup interrupt lockout mask
        ORR     a1,a1,a3                    ; Build new interrupt lockout mask
	LDR	a3,[sp], #4		    ; Pop off the state mask
	ORR	a1,a1,a3		    ; Set appropriate state
	MSR	SPSR,a1			    ; Place in the SPSR
        LDMIA   sp!,{v1-ip,pc}^       	    ; A solicited return is required.  
;
TCT_Interrupt_Resume
        LDR     a1,[sp],#4                  ; Pop off the CPSR
        LDR     a2,Int_Level		    ; Pickup address of interrupt 
                                            ;   lockout
        BIC     a1,a1,#LOCK_MSK             ; Clear lockout mask
        LDR     a3,[a2, #0]                 ; Pickup interrupt lockout mask
        ORR     a1,a1,a3                    ; Build new interrupt lockout mask
	MSR	SPSR,a1			    ; Place it into the SPSR
        LDMIA   sp,{a1-pc}^     	    ; Recover all registers and resume
        	 	                    ;   at point of interrupt
;}
;
;
;
;/*************************************************************************/
;/*                                                                       */
;/* FUNCTION                                                              */
;/*                                                                       */
;/*      TCT_Control_To_System                                            */
;/*                                                                       */
;/* DESCRIPTION                                                           */
;/*                                                                       */
;/*      This function returns control from a thread to the system.  Note */
;/*      that this service is called in a solicited manner, i.e. it is    */
;/*      not called from an interrupt thread.  Registers required by the  */
;/*      compiler to be preserved across function boundaries are saved by */
;/*      this routine.  Note that this is usually a sub-set of the total  */
;/*      number of available registers.                                   */
;/*                                                                       */
;/* AUTHOR                                                                */
;/*                                                                       */
;/*      Barry Sellew, Accelerated Technology, Inc.                       */
;/*                                                                       */
;/* CALLED BY                                                             */
;/*                                                                       */
;/*      Other Components                                                 */
;/*                                                                       */
;/* CALLS                                                                 */
;/*                                                                       */
;/*      TCT_Schedule                        Schedule the next thread     */
;/*                                                                       */
;/* INPUTS                                                                */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* OUTPUTS                                                               */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* HISTORY                                                               */
;/*                                                                       */
;/*         NAME            DATE                    REMARKS               */
;/*                                                                       */
;/*      B. Sellew       01-19-1996      Created initial version 1.0      */
;/*	 B. Sellew	 01-22-1996	 Verified version 1.0		  */
;/*                                                                       */
;/*************************************************************************/
;VOID  TCT_Control_To_System(void)
;{
	.def	$TCT_Control_To_System
$TCT_Control_To_System			    ; Dual-state interworking veneer
	.state16
	BX	pc
	NOP
	.state32
	B	_TCT_Control_To_System
;
        .def    _TCT_Control_To_System
_TCT_Control_To_System
;
;    /* Lockout interrupts.  */
;
        MRS     a1,CPSR                     ; Pickup current CPSR
        ORR     a1,a1,#LOCKOUT              ; Build interrupt lockout value
        MSR     CPSR,a1                     ; Lockout interrupts
;    
;    /* Save a minimal context of the thread.  */
;
        STMDB   sp!,{v1-ip,lr}        	    ; Save minimal context of thread on
                                            ;   the current stack
	MOV	a3,lr			    ; Determine what state the
	MOV	a3,a3,LSL #31   	    ;   caller was in and build an
	MOV	a3,a3,LSR #26		    ;   appropriate state mask
	STR	a3,[sp, #-4]!		    ; Place it on the stack
        MOV     a3,#0                       ; Build solicited stack type value
                                            ;   and NU_NULL value
        STR     a3,[sp, #-4]!               ; Place it on the top of the stack
;
;    /* Setup a pointer to the thread control block.  */
;    REG_Thread_Ptr =  (TC_TCB *) TCD_Current_Thread;
;
        LDR     a2,Current_Thread	    ; Pickup current thread ptr address
        LDR     a1,[a2, #0]                 ; Pickup current thread pointer
;
;    /* Clear the current thread control block pointer.  */
;    TCD_Current_Thread =  NU_NULL;
;    
        LDR     a4,Slice_State		    ; Pickup time slice state address
        STR     a3,[a2, #0]                 ; Set current thread pointer to 
                                            ;   NU_NULL
;
;    /* Check to see if a time slice is active.  If so, copy the original time
;       slice into the current time slice field of the task's control block. */
;    if (TMD_Time_Slice_State == 0)
;    {
        LDR     a2,[a4, #0]                 ; Pickup time slice state flag
        CMP     a2,#0                       ; Compare with active value
        BNE     TCT_No_Stop_TS_1            ; If non-active, don't disable
;
;
;        /* Insure that the next time the task runs it gets a fresh time 
;           slice.  */
;       REG_Thread_Ptr -> tc_cur_time_slice =  REG_Thread_Ptr -> tc_time_slice;
;
        LDR     a2,[a1, #40h]               ; Pickup original time slice
;
;        /* Clear any active time slice by setting the state to NOT_ACTIVE.  */
;        TMD_Time_Slice_State =  1;
;
        MOV     a3,#1                       ; Build disable value
        STR     a3,[a4, #0]                 ; Disable time slice
        STR     a2,[a1, #20h]               ; Reset current time slice
;    }
TCT_No_Stop_TS_1
;
;    /* Save off the current stack pointer in the control block.  */
;    REG_Thread_Ptr -> tc_stack_pointer =  (VOID *) REG_Stack_Ptr;
;
        STR     sp,[a1, #2ch]               ; Save the thread's stack pointer
;
;    /* Clear the task's current protection.  */
;    (REG_Thread_Ptr -> tc_current_protect) -> tc_tcb_pointer =  NU_NULL;
;    REG_Thread_Ptr -> tc_current_protect =  NU_NULL;
;
        LDR     a2,[a1, #38h]               ; Pickup current thread pointer
        MOV     a3,#0                       ; Build NU_NULL value
        STR     a3,[a1, #38h]               ; Clear the protect pointer field
        STR     a3,[a2, #0]                 ; Release the actual protection
;
;    /* Switch to the system stack.  */
;    REG_Stack_Ptr =  TCD_System_Stack;
;
        LDR     a2,System_Stack		    ; Pickup address of stack pointer
        LDR     a3,System_Limit		    ; Pickup address of stack limit ptr
        LDR     sp,[a2, #0]                 ; Switch to system stack
        LDR     v7,[a3, #0]                 ; Setup system stack limit
;
;    /* Finished, return to the scheduling loop.  */
;
        B       _TCT_Schedule               ; Return to scheduling loop
;}
;
;
;
;/*************************************************************************/
;/*                                                                       */
;/* FUNCTION                                                              */
;/*                                                                       */
;/*      TCT_Signal_Exit                                                  */
;/*                                                                       */
;/* DESCRIPTION                                                           */
;/*                                                                       */
;/*      This function exits from a signal handler.  The primary purpose  */
;/*      of this function is to clear the scheduler protection and switch */
;/*      the stack pointer back to the normal task's stack pointer.       */
;/*                                                                       */
;/* AUTHOR                                                                */
;/*                                                                       */
;/*      Barry Sellew, Accelerated Technology, Inc.                       */
;/*                                                                       */
;/* CALLED BY                                                             */
;/*                                                                       */
;/*      TCC_Signal_Shell                    Signal handling shell func   */
;/*                                                                       */
;/* CALLS                                                                 */
;/*                                                                       */
;/*      TCT_Schedule                        Scheduler                    */
;/*                                                                       */
;/* INPUTS                                                                */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* OUTPUTS                                                               */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* HISTORY                                                               */
;/*                                                                       */
;/*         NAME            DATE                    REMARKS               */
;/*                                                                       */
;/*      B. Sellew       01-19-1996      Created initial version 1.0      */
;/*	 B. Sellew	 01-22-1996	 Verified version 1.0		  */
;/*                                                                       */
;/*************************************************************************/
;VOID  TCT_Signal_Exit(void)
;{
	.def	$TCT_Signal_Exit
$TCT_Signal_Exit			    ; Dual-state interworking veneer
	.state16
	BX	pc
	NOP
	.state32
	B	_TCT_Signal_Exit
;
        .def    _TCT_Signal_Exit
_TCT_Signal_Exit
;
;    /* Lockout interrupts.  */
;
        MRS     a4,CPSR                     ; Pickup current CPSR
        ORR     a4,a4,#LOCKOUT              ; Build lockout value
        MSR     CPSR,a4                     ; Lockout interrupts
;
;    /* Setup a pointer to the thread control block.  */
;    REG_Thread_Ptr =  (TC_TCB *) TCD_Current_Thread;
;
        LDR     a2,Current_Thread	    ; Pickup address of thread pointer
        MOV     a3,#0                       ; Build NU_NULL value
        LDR     a1,[a2,#0]                  ; Pickup current thread pointer
;
;    /* Clear the current thread control block.  */
;    TCD_Current_Thread =  NU_NULL;
;
        LDR     a4,Slice_State		    ; Pickup time slice state address
        STR     a3,[a2, #0]                 ; Clear current thread pointer
;
;    /* Check to see if a time slice is active.  If so, copy the original time
;       slice into the current time slice field of the task's control block. */
;    if (TMD_Time_Slice_State == 0)
;    {
;
        LDR     a2,[a4, #0]                 ; Pickup time slice state flag
        CMP     a2,#0                       ; Compare with active value
        BNE     TCT_No_Stop_TS_2            ; If non-active, don't disable
;
;        /* Insure that the next time the task runs it gets a fresh time 
;           slice.  */
;       REG_Thread_Ptr -> tc_cur_time_slice =  REG_Thread_Ptr -> tc_time_slice;
;
        LDR     a2,[a1, #40h]               ; Pickup original time slice
;
;        /* Clear any active time slice by setting the state to NOT_ACTIVE.  */
;        TMD_Time_Slice_State =  1;
;
        MOV     a3,#1                       ; Build disable value
        STR     a3,[a4, #0]                 ; Disable time slice
        STR     a2,[a1, #20h]               ; Reset current time slice
;    }
TCT_No_Stop_TS_2
;
;    /* Switch back to the saved stack.  The saved stack pointer was saved
;       before the signal frame was built.  */
;    REG_Thread_Ptr -> tc_stack_pointer =  
;                                REG_Thread_Ptr -> tc_saved_stack_ptr;
;
        LDR     a2,[a1, #3ch]               ; Pickup saved stack pointer
        STR     a2,[a1, #2ch]               ; Place in current stack pointer
;
;    /* Clear the task's current protection.  */
;    (REG_Thread_Ptr -> tc_current_protect) -> tc_tcb_pointer =  NU_NULL;
;    REG_Thread_Ptr -> tc_current_protect =  NU_NULL;
;
        LDR     a2,[a1, #38h]               ; Pickup current thread pointer
        MOV     a3,#0                       ; Build NU_NULL value
        STR     a3,[a1, #38h]               ; Clear the protect pointer field
        STR     a3,[a2, #0]                 ; Release the actual protection
;
;    /* Switch to the system stack.  */
;    REG_Stack_Ptr =  (BYTE_PTR) TCD_System_Stack;
;
        LDR     a2,System_Stack		    ; Pickup address of stack pointer
        LDR     a3,System_Limit	  	    ; Pickup address of stack limit ptr
        LDR     sp,[a2, #0]                 ; Switch to system stack
        LDR     v7,[a3, #0]                 ; Setup system stack limit
;
;    /* Finished, return to the scheduling loop.  */
;
        B       _TCT_Schedule               ; Return to scheduling loop
;}
;
;
;
;/*************************************************************************/
;/*                                                                       */
;/* FUNCTION                                                              */
;/*                                                                       */
;/*      TCT_Current_Thread                                               */
;/*                                                                       */
;/* DESCRIPTION                                                           */
;/*                                                                       */
;/*      This function returns the current thread pointer.                */
;/*                                                                       */
;/* AUTHOR                                                                */
;/*                                                                       */
;/*      Barry Sellew, Accelerated Technology, Inc.                       */
;/*                                                                       */
;/* CALLED BY                                                             */
;/*                                                                       */
;/*      Application                                                      */
;/*      System Components                                                */
;/*                                                                       */
;/* CALLS                                                                 */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* INPUTS                                                                */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* OUTPUTS                                                               */
;/*                                                                       */
;/*      Pointer to current thread                                        */
;/*                                                                       */
;/* HISTORY                                                               */
;/*                                                                       */
;/*         NAME            DATE                    REMARKS               */
;/*                                                                       */
;/*      B. Sellew       01-19-1996      Created initial version 1.0      */
;/*	 B. Sellew	 01-22-1996	 Verified version 1.0		  */
;/*                                                                       */
;/*************************************************************************/
;VOID  *TCT_Current_Thread(void)
;{
	.def	$TCT_Current_Thread
$TCT_Current_Thread			    ; Dual-state interworking veneer
	.state16
	BX	pc
	NOP
	.state32
	B	_TCT_Current_Thread
;
        .def    _TCT_Current_Thread
_TCT_Current_Thread
;
;    /* Return the current thread pointer.  */
;    return(TCD_Current_Thread);
;
        LDR     a1,Current_Thread	    ; Pickup address of thread pointer
        LDR     a1,[a1, #0]                 ; Pickup current thread pointer
        BX      lr                          ; Return to caller
;}
;
;
;
;/*************************************************************************/
;/*                                                                       */
;/* FUNCTION                                                              */
;/*                                                                       */
;/*      TCT_Set_Execute_Task                                             */
;/*                                                                       */
;/* DESCRIPTION                                                           */
;/*                                                                       */
;/*      This function sets the current task to execute variable under    */
;/*      protection against interrupts.                                   */
;/*                                                                       */
;/* AUTHOR                                                                */
;/*                                                                       */
;/*      Barry Sellew, Accelerated Technology, Inc.                       */
;/*                                                                       */
;/* CALLED BY                                                             */
;/*                                                                       */
;/*      TCC Scheduling Routines                                          */
;/*                                                                       */
;/* CALLS                                                                 */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* INPUTS                                                                */
;/*                                                                       */
;/*      task                                Pointer to task control block*/
;/*                                                                       */
;/* OUTPUTS                                                               */
;/*                                                                       */
;/*      TCD_Execute_Task                    Modified variable            */
;/*                                                                       */
;/* HISTORY                                                               */
;/*                                                                       */
;/*         NAME            DATE                    REMARKS               */
;/*                                                                       */
;/*      B. Sellew       01-19-1996      Created initial version 1.0      */
;/*	 B. Sellew	 01-22-1996	 Verified version 1.0		  */
;/*                                                                       */
;/*************************************************************************/
;VOID  TCT_Set_Execute_Task(TC_TCB *task)
;{
	.def	$TCT_Set_Execute_Task
$TCT_Set_Execute_Task			    ; Dual-state interworking veneer
	.state16
	BX	pc
	NOP
	.state32
	B	_TCT_Set_Execute_Task
;
        .def    _TCT_Set_Execute_Task
_TCT_Set_Execute_Task
;
;    /* Now setup the TCD_Execute_Task pointer.  */
;    TCD_Execute_Task =  task;
;
        LDR     a2,Execute_Task	 	    ; Pickup execute task ptr address
        STR     a1,[a2,#0]                  ; Setup new task to execute
        BX      lr                          ; Return to caller
;}
;
;
;
;/*************************************************************************/
;/*                                                                       */
;/* FUNCTION                                                              */
;/*                                                                       */
;/*      TCT_Protect                                                      */
;/*                                                                       */
;/* DESCRIPTION                                                           */
;/*                                                                       */
;/*      This function protects against multiple thread access.           */
;/*                                                                       */
;/* AUTHOR                                                                */
;/*                                                                       */
;/*      Barry Sellew, Accelerated Technology, Inc.                       */
;/*                                                                       */
;/* CALLED BY                                                             */
;/*                                                                       */
;/*      Application                                                      */
;/*      System Components                                                */
;/*                                                                       */
;/* CALLS                                                                 */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* INPUTS                                                                */
;/*                                                                       */
;/*      protect                            Pointer to protection block   */
;/*                                                                       */
;/* OUTPUTS                                                               */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* HISTORY                                                               */
;/*                                                                       */
;/*         NAME            DATE                    REMARKS               */
;/*                                                                       */
;/*      B. Sellew       01-19-1996      Created initial version 1.0      */
;/*	 B. Sellew	 01-22-1996	 Verified version 1.0		  */
;/*                                                                       */
;/*************************************************************************/
;VOID  TCT_Protect(TC_PROTECT *protect)
;{
	.def	$TCT_Protect
$TCT_Protect				    ; Dual-state interworking veneer
	.state16
	BX	pc
	NOP
	.state32
	B	_TCT_Protect
;
        .def    _TCT_Protect
_TCT_Protect
;
;    /* Determine if the caller is in a task or HISR thread.  */
;    if (TCD_Current_Thread)
;    {
;
        LDR     a2,Current_Thread	    ; Pickup current thread ptr address
        LDR     a4,[a2, #0]                 ; Pickup current thread pointer
        CMP     a4,#0                       ; Check to see if it is non-NULL
        BEQ     TCT_Skip_Protect            ; If NULL, skip protection
;    
;        /* Lockout interrupts.  */
;
        MRS     a2,CPSR                     ; Pickup current CPSR
        ORR     a2,a2,#LOCKOUT              ; Place lockout value in
        MSR     CPSR,a2                     ; Lockout interrupts
;    
;        /* Wait until the protect structure is available.  */
;        while (protect -> tc_tcb_pointer != NU_NULL)
;        {
;
TCT_Protect_Loop
        LDR     a2,[a1, #0]                 ; Pickup protection owner field
        CMP     a2,#0                       ; Is there any protection?
        BEQ     TCT_Protect_Available       ; If NU_NULL, no current protection
;        
;            /* Protection structure is not available.  */
;            
;            /* Indicate that another thread is waiting.  */
;            protect -> tc_thread_waiting =  1;
;            
        MOV     a3,#1                       ; Build thread waiting flag
        STR     a3,[a1, #4]                 ; Set waiting field
;
;            /* Directly schedule the thread waiting.  */
;            TCT_Schedule_Protected(protect -> tc_tcb_pointer);
;            
        STR     a1,[sp, #-4]!               ; Save a1 on the stack
        STR     lr,[sp, #-4]!               ; Save lr on the stack
        MOV     a1,a4                       ; Place current thread into a1
        BL      _TCT_Schedule_Protected     ; Call routine to schedule the 
                                            ;   owner of the thread
;
        LDR     lr,[sp], #4                 ; Recover saved lr
        LDR     a1,[sp], #4                 ; Recover saved a1
;
;            /* Lockout interrupts.  */
;
        LDR     a2,Current_Thread	    ; Pickup current thread ptr address
        LDR     a4,[a2, #0]                 ; Pickup current thread pointer
        MRS     a2,CPSR                     ; Pickup current CPSR
        ORR     a2,a2,#LOCKOUT              ; Place lockout value in
        MSR     CPSR,a2                     ; Lockout interrupts
        B       TCT_Protect_Loop            ; Examine protect flags again
;        }
TCT_Protect_Available
;        
;        /* Protection structure is available.  */
;        
;        /* Indicate that this thread owns the protection.  */
;        protect -> tc_tcb_pointer =  TCD_Current_Thread;
;
        STR     a4,[a1, #0]                 ; Indicate calling thread owns this
                                            ;   protection
;        
;        /* Clear the thread waiting flag.  */
;        protect -> tc_thread_waiting =  0;
;        
        MOV     a3,#0                       ; Clear value
        STR     a3,[a1, #4]                 ; Clear the thread waiting flag
;
;        /* Save the protection pointer in the thread's control block.  Note 
;           that both task and HISR threads share the same control block 
;           format.  */
;        REG_Thread_Ptr =  (TC_TCB *) TCD_Current_Thread;
;        REG_Thread_Ptr -> tc_current_protect =  protect;
;
        STR     a1,[a4, #38h]               ; Setup current protection
;
;        /* Restore interrupts.  */
;
        LDR     a3,Int_Level	 	    ; Pickup address of interrupt level
        MRS     a2,CPSR                     ; Pickup current CPSR
        LDR     a4,[a3, #0]                 ; Pickup interrupt lockout level
        BIC     a2,a2,#LOCK_MSK             ; Clear lockout bits
        ORR     a2,a2,a4                    ; Build new interrupt lockout
        MSR     CPSR,a2                     ; Setup CPSR appropriately
;    }
;
TCT_Skip_Protect
        BX      lr                          ; Return to caller
;}
;
;
;
;/*************************************************************************/
;/*                                                                       */
;/* FUNCTION                                                              */
;/*                                                                       */
;/*      TCT_Unprotect                                                    */
;/*                                                                       */
;/* DESCRIPTION                                                           */
;/*                                                                       */
;/*      This function releases protection of the currently active        */
;/*      thread.  If the caller is not an active thread, then this        */
;/*      request is ignored.                                              */
;/*                                                                       */
;/* AUTHOR                                                                */
;/*                                                                       */
;/*      Barry Sellew, Accelerated Technology, Inc.                       */
;/*                                                                       */
;/* CALLED BY                                                             */
;/*                                                                       */
;/*      Application                                                      */
;/*      System Components                                                */
;/*                                                                       */
;/* CALLS                                                                 */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* INPUTS                                                                */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* OUTPUTS                                                               */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* HISTORY                                                               */
;/*                                                                       */
;/*         NAME            DATE                    REMARKS               */
;/*                                                                       */
;/*      B. Sellew       01-19-1996      Created initial version 1.0      */
;/*	 B. Sellew	 01-22-1996	 Verified version 1.0		  */
;/*                                                                       */
;/*************************************************************************/
;VOID  TCT_Unprotect(void)
;{
	.def	$TCT_Unprotect
$TCT_Unprotect				    ; Dual-state interworking veneer
	.state16
	BX	pc
	NOP
	.state32
	B	_TCT_Unprotect
;
        .def    _TCT_Unprotect
_TCT_Unprotect
;
;
;    /* Determine if the caller is in a task or HISR thread.  */
;    if (TCD_Current_Thread)
;    {
;
        LDR     a2,Current_Thread	    ; Pickup current thread ptr address
        LDR     a4,[a2, #0]                 ; Pickup current thread pointer
        CMP     a4,#0                       ; Check to see if it is non-NULL
        BEQ     TCT_Skip_Unprotect          ; If NULL, skip unprotection
;
;        /* Setup a thread control block pointer.  */
;        REG_Thread_Ptr =  (TC_TCB *) TCD_Current_Thread;
;        
;        /* Determine if there is a currently active protection.  */
;        if (REG_Thread_Ptr -> tc_current_protect)
;        {
;
        LDR     a1,[a4, #38h]               ; Pickup current protect field
        CMP     a1,#0                       ; Is there a protection in force?
        BEQ     TCT_Skip_Unprotect          ; If not, nothing is protected
;        
;             /* Lockout interrupts.  */
;    
        MRS     a2,CPSR                     ; Pickup current CPSR
        ORR     a2,a2,#LOCKOUT              ; Place lockout value in
        MSR     CPSR,a2                     ; Lockout interrupts
;
;            /* Yes, this thread still has this protection structure.  */
;            REG_Protect_Ptr =  REG_Thread_Ptr -> tc_current_protect;
;
;            /* Is there a higher priority thread waiting for the protection
;               structure?  */
;            if (REG_Protect_Ptr -> tc_thread_waiting)
;            
        LDR     a3,[a1, #4]                 ; Pickup thread waiting flag
        CMP     a3,#0                       ; Are there any threads waiting?
        BEQ     TCT_Not_Waiting_Unpr        ; If not, just release protection
;
;                /* Transfer control to the system.  Note that this 
;                   automatically clears the current protection and it returns
;                   to the caller of this routine instead of this routine.  */
;                TCT_Control_To_System();
;
        B       _TCT_Control_To_System      ; Return control to the system
;
;            else
;            {
TCT_Not_Waiting_Unpr
;            
;                /* Clear the protection.  */
;                REG_Thread_Ptr -> tc_current_protect =  NU_NULL;
;                REG_Protect_Ptr -> tc_tcb_pointer =  NU_NULL;
;
        MOV     a3,#0                       ; Build NU_NULL value
        STR     a3,[a1, #0]                 ; Release the protection
        STR     a3,[a4, #38h]               ; Clear protection pointer in the
                                            ;   control block
;                
;            }
;
TCT_Not_Protected
;            /* Restore interrupts again.  */
;
        LDR     a3,Int_Level		    ; Pickup address of interrupt level
        MRS     a2,CPSR                     ; Pickup current CPSR
        LDR     a4,[a3, #0]                 ; Pickup interrupt lockout level
        BIC     a2,a2,#LOCK_MSK             ; Clear lockout bits
        ORR     a2,a2,a4                    ; Build new interrupt lockout
        MSR     CPSR,a2                     ; Setup CPSR appropriately
;
;        }
;    }
TCT_Skip_Unprotect
        BX      lr                          ; Return to caller
;}
;
;
;
;/*************************************************************************/
;/*                                                                       */
;/* FUNCTION                                                              */
;/*                                                                       */
;/*      TCT_Unprotect_Specific                                           */
;/*                                                                       */
;/* DESCRIPTION                                                           */
;/*                                                                       */
;/*      This function releases a specific protection structure.          */
;/*                                                                       */
;/* AUTHOR                                                                */
;/*                                                                       */
;/*      Barry Sellew, Accelerated Technology, Inc.                       */
;/*                                                                       */
;/* CALLED BY                                                             */
;/*                                                                       */
;/*      Application                                                      */
;/*      System Components                                                */
;/*                                                                       */
;/* CALLS                                                                 */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* INPUTS                                                                */
;/*                                                                       */
;/*      protect                            Pointer to protection block   */
;/*                                                                       */
;/* OUTPUTS                                                               */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* HISTORY                                                               */
;/*                                                                       */
;/*         NAME            DATE                    REMARKS               */
;/*                                                                       */
;/*      B. Sellew       01-19-1996      Created initial version 1.0      */
;/*	 B. Sellew	 01-22-1996	 Verified version 1.0		  */
;/*                                                                       */
;/*************************************************************************/
;VOID   TCT_Unprotect_Specific(TC_PROTECT *protect)
;{
	.def	$TCT_Unprotect_Specific
$TCT_Unprotect_Specific			    ; Dual-state interworking veneer
	.state16
	BX	pc
	NOP
	.state32
	B	_TCT_Unprotect_Specific
;
        .def    _TCT_Unprotect_Specific
_TCT_Unprotect_Specific
;
;    /* Determine if the caller is in a task or HISR thread.  */
;    if (TCD_Current_Thread)
;    {
;
        LDR     a2,Current_Thread	    ; Pickup current thread ptr address
        LDR     a4,[a2, #0]                 ; Pickup current thread pointer
        CMP     a4,#0                       ; Check to see if it is non-NULL
        BEQ     TCT_Skip_Unprot_Spec        ; If NULL, skip unprotect specific
;     
;        /* Lockout interrupts.  */
;
        MRS     a2,CPSR                     ; Pickup current CPSR
        ORR     a2,a2,#LOCKOUT              ; Place lockout value in
        MSR     CPSR,a2                     ; Lockout interrupts
;
;        /* Clear the protection pointer.  */
;        protect -> tc_tcb_pointer =  NU_NULL;
;        
        MOV     a3,#0                       ; Build NU_NULL value
        STR     a3,[a1, #0]                 ; Clear protection ownership
;
;        /* Determine if a thread is waiting.  */
;        if (protect -> tc_thread_waiting)
;        {
;
        LDR     a2,[a1, #4]                 ; Pickup the waiting field
        CMP     a2,#0                       ; Is there another thread waiting?
        BEQ     TCT_Not_Waiting_Unspec      ; No, restore interrupts and return
;        
;            /* A higher-priority thread is waiting.  */
;
;            /* Save a minimal context of the thread.  */
;
        STMDB   sp!,{v1-ip,lr}              ; Save minimal context of thread on
                                            ;   the current stack
	MOV	a3,lr			    ; Determine what state the
	MOV	a3,a3,LSL #31   	    ;   caller was in and build an
	MOV	a3,a3,LSR #26		    ;   appropriate state mask
	STR	a3,[sp, #-4]!		    ; Place it on the stack
        MOV     a3,#0                       ; Build solicited stack type value
                                            ;   and NU_NULL value
        STR     a3,[sp, #-4]!               ; Place it on the top of the stack
;
;            /* Setup a pointer to the thread control block.  */
;            REG_Thread_Ptr =  (TC_TCB *) TCD_Current_Thread;
;
        LDR     a2,Current_Thread	    ; Pickup current thread ptr address
        LDR     a1,[a2, #0]                 ; Pickup current thread pointer
;
;            /* Clear the current thread control block pointer.  */
;            TCD_Current_Thread =  NU_NULL;
;    
        LDR     a4,Slice_State		    ; Pickup time slice state address
        STR     a3,[a2, #0]                 ; Set current thread pointer to 
                                            ;   NU_NULL
;
;            /* Check to see if a time slice is active.  If so, copy the 
;               original time slice into the current time slice field of the 
;               thread's control block. */
;            if (TMD_Time_Slice_State == 0)
;            {
;
        LDR     a2,[a4, #0]                 ; Pickup time slice state flag
        CMP     a2,#0                       ; Compare with active value
        BNE     TCT_No_Stop_TS_3            ; If non-active, don't disable
;
;               /* Insure that the next time the task runs it gets a fresh time
;                   slice.  */
;                REG_Thread_Ptr -> tc_cur_time_slice =  
;                                        REG_Thread_Ptr -> tc_time_slice;
;
        LDR     a2,[a1, #40h]               ; Pickup original time slice
;
;                /* Clear any active time slice by setting the state to 
;                   NOT_ACTIVE.  */
;                TMD_Time_Slice_State =  1;
;
        MOV     a3,#1                       ; Build disable value
        STR     a3,[a4, #0]                 ; Disable time slice
        STR     a2,[a1, #20h]               ; Reset current time slice
;            }
;
TCT_No_Stop_TS_3
;
;            /* Save off the current stack pointer in the control block.  */
;            REG_Thread_Ptr -> tc_stack_pointer =  (VOID *) REG_Stack_Ptr;
;
        STR     sp,[a1, #2ch]               ; Save the thread's stack pointer
;
;            /* Switch to the system stack.  */
;            REG_Stack_Ptr =  TCD_System_Stack;
;
        LDR     a2,System_Stack		    ; Pickup address of stack pointer
        LDR     a3,System_Limit		    ; Pickup address of stack limit ptr
        LDR     sp,[a2, #0]                 ; Switch to system stack
        LDR     v7,[a3, #0]                 ; Setup system stack limit
;
;            /* Finished, return to the scheduling loop.  */
;
        B       _TCT_Schedule               ; Return to scheduling loop
;
;        }
;        else
;        {
TCT_Not_Waiting_Unspec
;        
;            /* No higher-priority thread is waiting.  */
;            
;            /* Restore interrupts.  */
;
        LDR     a3,Int_Level		    ; Pickup address of interrupt level
        MRS     a2,CPSR                     ; Pickup current CPSR
        LDR     a4,[a3, #0]                 ; Pickup interrupt lockout level
        BIC     a2,a2,#LOCK_MSK             ; Clear lockout bits
        ORR     a2,a2,a4                    ; Build new interrupt lockout
        MSR     CPSR,a2                     ; Setup CPSR appropriately
;
;        }
;    }
;
TCT_Skip_Unprot_Spec
        BX      lr                          ; Return to caller
;}
;
;
;
;/*************************************************************************/
;/*                                                                       */
;/* FUNCTION                                                              */
;/*                                                                       */
;/*      TCT_Set_Current_Protect                                          */
;/*                                                                       */
;/* DESCRIPTION                                                           */
;/*                                                                       */
;/*      This function sets the current protection field of the current   */
;/*      thread's control block to the specified protection pointer.      */
;/*                                                                       */
;/* AUTHOR                                                                */
;/*                                                                       */
;/*      Barry Sellew, Accelerated Technology, Inc.                       */
;/*                                                                       */
;/* CALLED BY                                                             */
;/*                                                                       */
;/*      TCC_Resume_Task                    Resume task function          */
;/*                                                                       */
;/* CALLS                                                                 */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* INPUTS                                                                */
;/*                                                                       */
;/*      protect                            Pointer to protection block   */
;/*                                                                       */
;/* OUTPUTS                                                               */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* HISTORY                                                               */
;/*                                                                       */
;/*         NAME            DATE                    REMARKS               */
;/*                                                                       */
;/*      B. Sellew       01-19-1996      Created initial version 1.0      */
;/*	 B. Sellew	 01-22-1996	 Verified version 1.0		  */
;/*                                                                       */
;/*************************************************************************/
;VOID  TCT_Set_Current_Protect(TC_PROTECT *protect)
;{
	.def	$TCT_Set_Current_Protect
$TCT_Set_Current_Protect		    ; Dual-state interworking veneer
	.state16
	BX	pc
	NOP
	.state32
	B	_TCT_Set_Current_Protect
;
        .def    _TCT_Set_Current_Protect
_TCT_Set_Current_Protect
;
;    /* Determine if the caller is in a task or HISR thread.  */
;    if (TCD_Current_Thread)
;    {
;
        LDR     a2,Current_Thread	    ; Pickup current thread ptr address
        LDR     a4,[a2, #0]                 ; Pickup current thread pointer
        CMP     a4,#0                       ; Check to see if a thread is 
                                            ;   active
;
;        /* Point at the current thread control block.  */
;        REG_Thread_Ptr =  (TC_TCB *) TCD_Current_Thread;
;    
;        /* Modify the current protection.  */
;        REG_Thread_Ptr -> tc_current_protect =  protect;
;
        STRNE   a1,[a4, #38h]               ; Setup new protection
;    }
;
        BX      lr                          ; Return to caller
;}
;
;
;
;/*************************************************************************/
;/*                                                                       */
;/* FUNCTION                                                              */
;/*                                                                       */
;/*      TCT_Protect_Switch                                               */
;/*                                                                       */
;/* DESCRIPTION                                                           */
;/*                                                                       */
;/*      This function waits until a specific task no longer has any      */
;/*      protection associated with it.  This is necessary since task's   */
;/*      cannot be suspended or terminated unless they have released all  */
;/*      of their protection.                                             */
;/*                                                                       */
;/* AUTHOR                                                                */
;/*                                                                       */
;/*      Barry Sellew, Accelerated Technology, Inc.                       */
;/*                                                                       */
;/* CALLED BY                                                             */
;/*                                                                       */
;/*      System Components                                                */
;/*                                                                       */
;/* CALLS                                                                 */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* INPUTS                                                                */
;/*                                                                       */
;/*      thread                             Pointer to thread control blk */
;/*                                                                       */
;/* OUTPUTS                                                               */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* HISTORY                                                               */
;/*                                                                       */
;/*         NAME            DATE                    REMARKS               */
;/*                                                                       */
;/*      B. Sellew       01-19-1996      Created initial version 1.0      */
;/*	 B. Sellew	 01-22-1996	 Verified version 1.0		  */
;/*                                                                       */
;/*************************************************************************/
;VOID  TCT_Protect_Switch(VOID *thread)
;{
	.def	$TCT_Protect_Switch
$TCT_Protect_Switch			    ; Dual-state interworking veneer
	.state16
	BX	pc
	NOP
	.state32
	B	_TCT_Protect_Switch
;
        .def    _TCT_Protect_Switch
_TCT_Protect_Switch
;
;    /* Lockout interrupts.  */
;    
        MRS     a2,CPSR                     ; Pickup current CPSR
        ORR     a2,a2,#LOCKOUT              ; Place lockout value in
        MSR     CPSR,a2                     ; Lockout interrupts
;
;    REG_Thread_Ptr =  (TC_TCB *) thread;
;    
;    /* Wait until the specified task has no protection associated with it.  */
;    while (REG_Thread_Ptr -> tc_current_protect)
;    {
;
        LDR     a2,[a1, #38h]               ; Pickup protection of specified
                                            ;   thread
        CMP     a2,#0                       ; Does the specified thread have
                                            ;   an active protection?
        BEQ     TCT_Switch_Done             ; If not, protect switch is done
;    
;        /* Let the task run again in an attempt to clear its protection.  */
;        
;        /* Indicate that a higher priority thread is waiting.  */
;        (REG_Thread_Ptr -> tc_current_protect) -> tc_thread_waiting =  1;
;        
        MOV     a3,#1                       ; Build waiting flag value
        STR     a3,[a2, #4]                 ; Set waiting flag of the 
                                            ;   protection owned by the other
                                            ;   thread
;
;        /* Directly schedule the thread waiting.  */
;        TCT_Schedule_Protected((REG_Thread_Ptr -> tc_current_protect)  
;                                                        -> tc_tcb_pointer);
;
        LDR     a3,Current_Thread	    ; Pickup current thread ptr address
        STR     a1,[sp, #-4]!               ; Save a1 on the stack
        STR     lr,[sp, #-4]!               ; Save lr on the stack
        MOV     a2,a1                       ; Move new thread into a2
        LDR     a1,[a3, #0]                 ; Pickup current thread pointer
        BL      _TCT_Schedule_Protected     ; Call routine to schedule the 
                                            ;   owner of the thread
;
        LDR     lr,[sp], #4                 ; Recover saved lr
        LDR     a1,[sp], #4                 ; Recover saved a1
;            
;        /* Lockout interrupts.  */
;
        B       _TCT_Protect_Switch         ; Branch to top of routine and 
                                            ;   start over
;    }
TCT_Switch_Done
;
;    /* Restore interrupts.  */
;
        LDR     a3,Int_Level	            ; Pickup address of interrupt level
        MRS     a2,CPSR                     ; Pickup current CPSR
        LDR     a4,[a3, #0]                 ; Pickup interrupt lockout level
        BIC     a2,a2,#LOCK_MSK             ; Clear lockout bits
        ORR     a2,a2,a4                    ; Build new interrupt lockout
        MSR     CPSR,a2                     ; Setup CPSR appropriately
;
        BX      lr                          ; Return to caller
;}
;
;
;
;/*************************************************************************/
;/*                                                                       */
;/* FUNCTION                                                              */
;/*                                                                       */
;/*      TCT_Schedule_Protected                                           */
;/*                                                                       */
;/* DESCRIPTION                                                           */
;/*                                                                       */
;/*      This function saves the minimal context of the thread and then   */
;/*      directly schedules the thread that has protection over the       */
;/*      the thread that called this routine.                             */
;/*                                                                       */
;/* AUTHOR                                                                */
;/*                                                                       */
;/*      Barry Sellew, Accelerated Technology, Inc.                       */
;/*                                                                       */
;/* CALLED BY                                                             */
;/*                                                                       */
;/*      TCT_Protect                                                      */
;/*      TCT_Protect_Switch                                               */
;/*                                                                       */
;/* CALLS                                                                 */
;/*                                                                       */
;/*      TCT_Control_To_Thread               Transfer control to protected*/
;/*                                              thread                   */
;/*                                                                       */
;/* INPUTS                                                                */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* OUTPUTS                                                               */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* HISTORY                                                               */
;/*                                                                       */
;/*         NAME            DATE                    REMARKS               */
;/*                                                                       */
;/*      B. Sellew       01-19-1996      Created initial version 1.0      */
;/*	 B. Sellew	 01-22-1996	 Verified version 1.0		  */
;/*                                                                       */
;/*************************************************************************/
;VOID  TCT_Schedule_Protected(VOID *thread)
;{
;
_TCT_Schedule_Protected
;
;    /* Interrupts are already locked out by the caller.  */
;    
;    /* Save minimal context required by the system.  */
;
        STMDB   sp!,{v1-ip,lr}              ; Save minimal context of thread on
                                            ;   the current stack
	MOV	a3,lr			    ; Determine what state the
	MOV	a3,a3,LSL #31   	    ;   caller was in and build an
	MOV	a3,a3,LSR #26		    ;   appropriate state mask
	STR	a3,[sp, #-4]!		    ; Place it on the stack
        MOV     a3,#0                       ; Build solicited stack type value
                                            ;   and NU_NULL value
        STR     a3,[sp, #-4]!               ; Place it on the top of the stack
        MOV     v1,a2                       ; Save thread to schedule
;
;    /* Setup a pointer to the thread control block.  */
;    REG_Thread_Ptr =  (TC_TCB *) TCD_Current_Thread;
;    
        LDR     a2,Current_Thread	    ; Pickup current thread ptr address
;
;    /* Clear the current thread control block.  */
;    TCD_Current_Thread =  NU_NULL;
;
        LDR     a4,Slice_State		    ; Pickup time slice state address
        STR     a3,[a2, #0]                 ; Set current thread pointer to 
                                            ;   NU_NULL
;
;    /* Check to see if a time slice is active.  If so, copy the original time
;       slice into the current time slice field of the task's control block. */
;    if (TMD_Time_Slice_State == 0)
;    {
;
        LDR     a2,[a4, #0]                 ; Pickup time slice state flag
        CMP     a2,#0                       ; Compare with active value
        BNE     TCT_No_Stop_TS_4            ; If non-active, don't disable
;    
;        /* Insure that the next time the task runs it gets a fresh time 
;           slice.  */
;       REG_Thread_Ptr -> tc_cur_time_slice =  REG_Thread_Ptr -> tc_time_slice;
;
        LDR     a2,[a1, #40h]               ; Pickup original time slice
;
;        /* Clear any active time slice by setting the state to NOT_ACTIVE.  */
;        TMD_Time_Slice_State =  1;
;
        MOV     a3,#1                       ; Build disable value
        STR     a3,[a4, #0]                 ; Disable time slice
        STR     a2,[a1, #20h]               ; Reset current time slice
;
;    }
TCT_No_Stop_TS_4
;
;    /* Save off the current stack pointer in the control block.  */
;    REG_Thread_Ptr -> tc_stack_pointer =  (VOID *) REG_Stack_Ptr;
;
        STR     sp,[a1, #2ch]               ; Save the thread's stack pointer
;
;    /* Switch to the system stack.  */
;    TCD_System_Stack =  (VOID *) REG_Stack_Ptr;
;
        LDR     a2,System_Stack		    ; Pickup address of stack pointer
        LDR     a3,System_Limit		    ; Pickup address of stack limit ptr
        LDR     sp,[a2, #0]                 ; Switch to system stack
        LDR     v7,[a3, #0]                 ; Setup system stack limit
;
;    /* Transfer control to the specified thread directly. */
;    TCT_Control_To_Thread(thread);
;
        LDR     a3,Int_Level		    ; Pickup address of interrupt level
        MRS     a2,CPSR                     ; Pickup current CPSR
        LDR     a4,[a3, #0]                 ; Pickup interrupt lockout level
        BIC     a2,a2,#LOCK_MSK             ; Clear lockout bits
        ORR     a2,a2,a4                    ; Build new interrupt lockout
        MOV     a1,v1                       ; Indicate thread to schedule
        MSR     CPSR,a2                     ; Setup CPSR appropriately
        ORR     a2,a2,#LOCKOUT              ; Build lockout value again
        MSR     CPSR,a2                     ; Lockout interrupts again
        B       _TCT_Control_To_Thread      ; Schedule the thread indirectly
;}
;
;
;
;/*************************************************************************/
;/*                                                                       */
;/* FUNCTION                                                              */
;/*                                                                       */
;/*      TCT_Interrupt_Context_Save                                       */
;/*                                                                       */
;/* DESCRIPTION                                                           */
;/*                                                                       */
;/*      This function saves the interrupted thread's context.  Nested    */
;/*      interrupts are also supported.  If a task or HISR thread was     */
;/*      interrupted, the stack pointer is switched to the system stack   */
;/*      after the context is saved.                                      */
;/*                                                                       */
;/* AUTHOR                                                                */
;/*                                                                       */
;/*      Barry Sellew, Accelerated Technology, Inc.                       */
;/*                                                                       */
;/* CALLED BY                                                             */
;/*                                                                       */
;/*      Application ISRs                    Assembly language ISRs       */
;/*      INT_Interrupt_Shell                 Interrupt handler shell      */
;/*                                                                       */
;/* CALLS                                                                 */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* INPUTS                                                                */
;/*                                                                       */
;/*      vector                              Interrupt's vector number    */
;/*                                                                       */
;/* OUTPUTS                                                               */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* HISTORY                                                               */
;/*                                                                       */
;/*         NAME            DATE                    REMARKS               */
;/*                                                                       */
;/*      B. Sellew       01-19-1996      Created initial version 1.0      */
;/*	 B. Sellew	 01-22-1996	 Verified version 1.0		  */
;/*                                                                       */
;/*************************************************************************/
;VOID  TCT_Interrupt_Context_Save(INT vector)
;{
	.def	$TCT_Interrupt_Context_Save
$TCT_Interrupt_Context_Save		    ; Dual-state interworking veneer
	.state16
	BX	pc
	NOP
	.state32
	B	_TCT_Interrupt_Context_Save
;
        .def    _TCT_Interrupt_Context_Save
_TCT_Interrupt_Context_Save
;
;    /* This routine is designed to handle THUMB IRQ interrupts.  The IRQ
;       stack is used as a temporary area.  Actual context is saved either
;       on the interrupted thread's stack or the system stack- both of which
;       are in the Supervisor (SVC) mode.  Note:  upon entry to this routine 
;       a1-a4 are saved on the current stack and a4 contains the original
;       (interrupt return address) lr value.  The current lr contains the 
;       ISR return address.  */
;
;    /* Determine if this is a nested interrupt.  */
;    if (TCD_Interrupt_Count++)
;    {
;
        LDR     a1,Int_Count		    ; Pickup address of interrupt count
        LDR     a2,[a1, #0]                 ; Pickup interrupt counter
        CMP     a2,#0                       ; Is it the first interrupt?
        BEQ     TCT_Not_Nested_Save         ; If so, not a nested interrupt
;    
;        /* Nested interrupt.  Save complete context on the current stack.  */
;        
        ADD     a2,a2,#1                    ; Increment the interrupt counter
        STR     a2,[a1, #0]                 ; Store in interrupt counter
        STMDB   sp!,{v1-v3}                 ; Save more registers on current
                                            ;   stack
        MRS     v1,SPSR                     ; Pickup and save current SPSR
        MOV     v2,lr                       ; Save current lr 
        MOV     v3,sp                       ; Save current sp
        ADD     sp,sp,#28                   ; Adjust sp for future interrupts
        MRS     a1,CPSR                     ; Pickup current CPSR
        BIC     a1,a1,#MODE_MASK            ; Clear the mode bits
        ORR     a1,a1,#SUP_MODE             ; Prepare to switch to supervisor
                                            ;   mode (SVC)
        MSR     CPSR,a1                     ; Switch to SVC mode
        MOV     a2,sp                       ; Use a non sp register
        NOP                                 ; 
        STR     a4,[a2, #-4]!               ; Save interrupted pc on sys stack
        STMDB   a2!,{v4-lr}   		    ; Save v4-lr on the system stack
        MOV     sp,a2                       ; Setup sp again
        LDMIA   v3!,{v4-v6}                 ; Recover v1-v3 from int stack
        STMDB   sp!,{v4-v6}                 ; Save v1-v3 on the system stack
        LDMIA   v3,{a1-a4}                  ; Recover a1-a4
        STMDB   sp!,{a1-a4}                 ; Save a1-a4 on the system stack
        STR     v1,[sp, #-4]!               ; Save CPSR on the stack
        BX      v2                          ; Return to calling ISR        
;    }
;    else
;    {
TCT_Not_Nested_Save
;    
        ADD     a2,a2,#1                    ; Increment the interrupt counter
        STR     a2,[a1, #0]                 ; Store in interrupt counter
;
;        /* Determine if a thread was interrupted.  */
;        if (TCD_Current_Thread)
;        {
;
        LDR     a2,Current_Thread	    ; Pickup current thread ptr address
        LDR     a2,[a2, #0]                 ; Pickup the current thread pointer
        CMP     a2,#0                       ; Is it NU_NULL?
        BEQ     TCT_Idle_Context_Save       ; If no, no real save is necessary
        
;        
;            /* Yes, a thread was interrupted.  Save complete context on the
;               thread's stack.  */
;
        STMDB   sp!,{v1-v3}                 ; Save more registers on temp stack
        MOV     v2,lr                       ; Save interrupt lr in v2
        MRS     v1,SPSR                     ; Save interrupt SPSR in v1
        MOV     v3,sp                       ; Save current sp in v3
        ADD     sp,sp,#28                   ; Adjust sp for future interrupts
        MRS     a1,CPSR                     ; Pickup current CPSR
        BIC     a1,a1,#MODE_MASK            ; Clear the mode bits
        ORR     a1,a1,#SUP_MODE             ; Prepare to switch to supervisor
                                            ;   mode (SVC)
        MSR     CPSR,a1                     ; Switch to supervisor mode (SVC)
        MOV     a2,sp                       ; Use a non-stack pointer register
        NOP                                 ; 
        STR     a4,[a2, #-4]!               ; Save interrupted pc on the stack
        STMDB   a2!,{v4-lr} 	            ; Save v4-lr on the stack
        MOV     sp,a2                       ; Setup sp again
        LDMIA   v3!,{v4-v6}                 ; Recover v1-v3 into v4-v6
        STMDB   sp!,{v4-v6}                 ; Save v1-v3 on the stack
        LDMIA   v3,{a1-a4}                  ; Recover a1-a4
        STMDB   sp!,{a1-a4}                 ; Save a1-a4 on the stack
        STR     v1,[sp, #-4]!               ; Save CPSR on the stack
        MOV     a2,#1                       ; Interrupt stack type
        STR     a2,[sp, #-4]!               ; Put interrupt stack type on top 
                                            ;   of stack
;
;            /* Save the thread's stack pointer in the control block.  */
;            REG_Thread_Ptr =  (TC_TCB *) TCD_Current_Thread;
;            REG_Thread_Ptr -> tc_stack_pointer =  (VOID *) REG_Stack_Ptr;
;   
        LDR     a2,Current_Thread	    ; Pickup current thread ptr address
        LDR     a1,[a2, #0]                 ; Pickup current thread pointer
        LDR     a4,Slice_State		    ; Pickup time slice state address
        STR     sp,[a1, #2ch]               ; Save stack pointer
;
;            /* Switch to the system stack.  */
;            REG_Stack_Ptr =  TCD_System_Stack;
;
        LDR     a2,System_Stack	  	    ; Pickup address of stack pointer
        LDR     a3,System_Limit		    ; Pickup address of stack limit ptr
        LDR     sp,[a2, #0]                 ; Switch to system stack
        LDR     v7,[a3, #0]                 ; Setup system stack limit
;
;            /* Return to caller ISR.  */
;
        BX      v2                          ; Return to caller ISR
;
;        }
;
TCT_Idle_Context_Save
;
        MOV     v2,lr                       ; Save lr in v2
        ADD     sp,sp,#16                   ; Adjust sp for future interrupts
        MRS     a1,CPSR                     ; Pickup current CPSR
        BIC     a1,a1,#MODE_MASK            ; Clear the current mode
        ORR     a1,a1,#SUP_MODE             ; Prepare to switch to supervisor
                                            ;   mode (SVC)
        MSR     CPSR,a1                     ; Switch to supervisor mode (SVC)
        BX      v2                          ; Return to caller ISR
;    }
;}
;
;
;
;/*************************************************************************/
;/*                                                                       */
;/* FUNCTION                                                              */
;/*                                                                       */
;/*      TCT_Interrupt_Context_Restore                                    */
;/*                                                                       */
;/* DESCRIPTION                                                           */
;/*                                                                       */
;/*      This function restores the interrupt context if a nested         */
;/*      interrupt condition is present.  Otherwise, this routine         */
;/*      transfers control to the scheduling function.                    */
;/*                                                                       */
;/* AUTHOR                                                                */
;/*                                                                       */
;/*      Barry Sellew, Accelerated Technology, Inc.                       */
;/*                                                                       */
;/* CALLED BY                                                             */
;/*                                                                       */
;/*      Application ISRs                    Assembly language ISRs       */
;/*      INT_Interrupt_Shell                 Interrupt handler shell      */
;/*                                                                       */
;/* CALLS                                                                 */
;/*                                                                       */
;/*      TCT_Schedule                        Thread scheduling function   */
;/*                                                                       */
;/* INPUTS                                                                */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* OUTPUTS                                                               */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* HISTORY                                                               */
;/*                                                                       */
;/*         NAME            DATE                    REMARKS               */
;/*                                                                       */
;/*      B. Sellew       01-19-1996      Created initial version 1.0      */
;/*	 B. Sellew	 01-22-1996	 Verified version 1.0		  */
;/*                                                                       */
;/*************************************************************************/
;VOID  TCT_Interrupt_Context_Restore(void)
;{
	.def	$TCT_Interrupt_Context_Restore
$TCT_Interrupt_Context_Restore		    ; Dual-state interworking veneer
	.state16
	BX	pc
	NOP
	.state32
	B	_TCT_Interrupt_Context_Restore
;
        .def    _TCT_Interrupt_Context_Restore
_TCT_Interrupt_Context_Restore
;
;    /* It is assumed that anything pushed on the stack by ISRs has been 
;       removed upon entry into this routine.  */
;
;    /* Lockout interrupts.  */
;    
        MRS     a2,CPSR                     ; Pickup current CPSR
        ORR     a2,a2,#LOCKOUT              ; Build lockout value
        MSR     CPSR,a2                     ; Lockout interrupts
;
;    /* Decrement and check for nested interrupt conditions.  */
;    if (--TCD_Interrupt_Count)
;    {
;
        LDR     a1,Int_Count		    ; Pickup address of interrupt count
        LDR     a2,[a1, #0]                 ; Pickup interrupt counter
        SUB     a2,a2,#1                    ; Decrement interrupt counter
        STR     a2,[a1, #0]                 ; Store interrupt counter
        CMP     a2,#0                       ; Is this a nested interrupt?
        BEQ     TCT_Not_Nested_Restore      ; If not, skip nested interrupt 
                                            ;   restoration
;    
;        /* Restore previous context.  */
;
        LDR     a1,[sp], #4                 ; Pickup the saved CPSR
	MSR	SPSR,a1			    ; Put in SPSR
        LDMIA   sp,{a1-pc}^  		    ; Return to the point of interrupt
;
;    }
;    else
;    {
;
TCT_Not_Nested_Restore
;    
;        /* Determine if a thread is active.  */
;        if (TCD_Current_Thread)
;        {
;
        LDR     a2,Current_Thread	    ; Pickup current thread ptr address
        LDR     a1,[a2, #0]                 ; Pickup current thread pointer
        CMP     a1,#0                       ; Determine if a thread is active
        BEQ     TCT_Idle_Context_Restore    ; If not, idle system restore
;
;            /* Clear the current thread pointer.  */
;            TCD_Current_Thread =  NU_NULL;
;
        LDR     a4,Slice_State		    ; Pickup time slice state address
        MOV     a3,#0                       ; Build NU_NULL value
        STR     a3,[a2, #0]                 ; Set current thread ptr to NU_NULL
;        
;            /* Determine if a time slice is active.  If so, the remaining
;               time left on the time slice must be saved in the task's
;               control block.  */
;            if (TMD_Time_Slice_State == 0)
;            {
;
        LDR     a2,[a4, #0]                 ; Pickup time slice state
        CMP     a2,#0                       ; Determine if time slice active
        BNE     TCT_Idle_Context_Restore    ; If not, skip time slice reset
;            
;                /* Pickup the remaining portion of the time slice and save it
;                   in the task's control block.  */
;                REG_Thread_Ptr -> tc_cur_time_slice =  TMD_Time_Slice;
;                TMD_Time_Slice_State =  1;
;
        LDR     a3,Time_Slice		    ; Pickup address of time slice left
        MOV     a2,#1                       ; Build disable time slice value
        LDR     a3,[a3, #0]                 ; Pickup remaining time slice
        STR     a2,[a4, #0]                 ; Disable time slice
        STR     a3,[a1, #20h]               ; Store remaining time slice       
;
;            }
;        }
TCT_Idle_Context_Restore
;
;        /* Reset the system stack pointer.  */
;
        LDR     a2,System_Stack		    ; Pickup address of stack pointer
        LDR     a3,System_Limit		    ; Pickup address of stack limit ptr
        LDR     sp,[a2, #0]                 ; Switch to system stack
        LDR     v7,[a3, #0]                 ; Setup system stack limit
;
;        /* Return to scheduler.  */
;
        B       _TCT_Schedule               ; Return to scheduling loop
;
;    }
;}
;
;
;
;/*************************************************************************/
;/*                                                                       */
;/* FUNCTION                                                              */
;/*                                                                       */
;/*      TCT_Activate_HISR                                                */
;/*                                                                       */
;/* DESCRIPTION                                                           */
;/*                                                                       */
;/*      This function activates the specified HISR.  If the HISR is      */
;/*      already activated, the HISR's activation count is simply         */
;/*      incremented.  Otherwise, the HISR is placed on the appropriate   */
;/*      HISR priority list in preparation for execution.                 */
;/*                                                                       */
;/* AUTHOR                                                                */
;/*                                                                       */
;/*      Barry Sellew, Accelerated Technology, Inc.                       */
;/*                                                                       */
;/* CALLED BY                                                             */
;/*                                                                       */
;/*      Application LISRs                                                */
;/*                                                                       */
;/* CALLS                                                                 */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* INPUTS                                                                */
;/*                                                                       */
;/*      hisr                                Pointer to HISR to activate  */
;/*                                                                       */
;/* OUTPUTS                                                               */
;/*                                                                       */
;/*      NU_SUCCESS                          Successful completion        */
;/*                                                                       */
;/* HISTORY                                                               */
;/*                                                                       */
;/*         NAME            DATE                    REMARKS               */
;/*                                                                       */
;/*      B. Sellew       01-19-1996      Created initial version 1.0      */
;/*	 B. Sellew	 01-22-1996	 Verified version 1.0		  */
;/*                                                                       */
;/*************************************************************************/
;STATUS  TCT_Activate_HISR(TC_HCB *hisr)
;{
	.def	$TCT_Activate_HISR
$TCT_Activate_HISR			    ; Dual-state interworking veneer
	.state16
	BX	pc
	NOP
	.state32
	B	_TCT_Activate_HISR
;
        .def    _TCT_Activate_HISR
_TCT_Activate_HISR
;
;INT     priority;
;
;
;    /* Lockout interrupts.  */
;
        STR     v1,[sp, #-4]!               ; Save v1
        MRS     v1,CPSR                     ; Pickup current CPSR
        ORR     a2,v1,#LOCKOUT              ; Build interrupt lockout value
        MSR     CPSR,a2                     ; Lockout interrupts
;
;    /* Determine if the HISR is already active.  */
;    if (hisr -> tc_activation_count)
;    {
;
        LDR     a2,[a1,#40h]                ; Pickup current activation count
        CMP     a2,#0                       ; Is it the first activation?
        BEQ     TCT_First_Activate          ; Yes, place it on the correct list
;
;        /* Increment the activation count.  Make sure that it does not go
;           to zero.  */
;        hisr -> tc_activation_count++;
;
        ADDS    a2,a2,#1                    ; Increment the activation count
        STR     a2,[a1,#40h]                ; Store new activation count
;
;        if (hisr -> tc_activation_count == 0)
;        
;            hisr -> tc_activation_count =  0xFFFFFFFFUL;
;
        MVNEQ   a2,#0                       ; If counter rolled-over reset
        STREQ   a2,[a1,#40h]                ; Store all ones count
        B       TCT_Activate_Done           ; Finished with activation
;    }
;    else
;    {
TCT_First_Activate
;
;
;        /* Set the activation count to 1.  */
;        hisr -> tc_activation_count =  1;
;
        MOV     a2,#1                       ; Initial activation count
        STR     a2,[a1,#40h]                ; Store initial activation count
;
;        /* Pickup the HISR's priority.  */
;        priority =  hisr -> tc_priority;
;
;        /* Determine if there is something in the given priority list.  */
;        if (TCD_Active_HISR_Tails[priority])
;        {
;
        LDRB    a2,[a1,#1ah]                ; Pickup priority of HISR
        LDR     a3,HISR_Tails	            ; Pickup tail pointer base
        LDR     a4,[a3,a2,LSL #2]           ; Pickup tail pointer for priority
        CMP     a4,#0                       ; Is this first HISR at priority?
        BEQ     TCT_First_HISR              ; No, append to end of HISR list
;
;            /* Something is already on this list.  Add after the tail.  */
;            (TCD_Active_HISR_Tails[priority]) -> tc_active_next =  hisr;
;            TCD_Active_HISR_Tails[priority] =  hisr;
;
        STR     a1,[a4,#3ch]                ; Setup the active next pointer
        STR     a1,[a3,a2,LSL #2]           ; Setup the tail pointer
        B       TCT_Activate_Done           ; Finished with activate processing
;        }
;        else
;        {
TCT_First_HISR
;
;           /* Nothing is on this list.  */
;           TCD_Active_HISR_Heads[priority] =  hisr;
;           TCD_Active_HISR_Tails[priority] =  hisr;
;
        LDR     a4,HISR_Heads		    ; Pickup address of head pointers
        STR     a1,[a3,a2,LSL #2]           ; Set tail pointer to this HISR
        STR     a1,[a4,a2,LSL #2]           ; Set head pointer to this HISR
;
;           /* Determine the highest priority HISR.  */
;           if (TCD_Active_HISR_Heads[0])
;               TCD_Execute_HISR =  TCD_Active_HISR_Heads[0];
;           else if (TCD_Active_HISR_Heads[1])
;               TCD_Execute_HISR =  TCD_Active_HISR_Heads[1];
;           else
;               TCD_Execute_HISR =  TCD_Active_HISR_Heads[2];
;
        LDR     a2,[a4,#0]                  ; Pickup priority 0 head pointer
        LDR     a1,Execute_HISR		    ; Build address to execute HISR ptr
        CMP     a2,#0                       ; Is priority 0 active?
        LDREQ   a2,[a4,#4]                  ; If not, pickup priority 1 head 
        CMPEQ   a2,#0                       ; Is priority 1 active?
        LDREQ   a2,[a4,#8]                  ; Else, must be priority 2 active
        STR     a2,[a1,#0]                  ; Store which ever priority is the
                                            ;   active one
;       }
;    }
TCT_Activate_Done
;
        MSR     CPSR,v1                     ; Restore interrupt lockout
        LDR     v1,[sp], #4                 ; Restore corrupted v1
;
;    return(NU_SUCCESS);
;
        MOV     a1,#0                       ; Always return NU_SUCCESS
        BX      lr                          ; Return to caller
;}
;
;
;
;/*************************************************************************/
;/*                                                                       */
;/* FUNCTION                                                              */
;/*                                                                       */
;/*      TCT_HISR_Shell                                                   */
;/*                                                                       */
;/* DESCRIPTION                                                           */
;/*                                                                       */
;/*      This function is the execution shell of each and every HISR.  If */
;/*      the HISR has completed its processing, this shell routine exits  */
;/*      back to the system.  Otherwise, it sequentially calls the HISR   */
;/*      routine until the activation count goes to zero.                 */
;/*                                                                       */
;/* AUTHOR                                                                */
;/*                                                                       */
;/*      Barry Sellew, Accelerated Technology, Inc.                       */
;/*                                                                       */
;/* CALLED BY                                                             */
;/*                                                                       */
;/*      HISR Scheduling                                                  */
;/*                                                                       */
;/* CALLS                                                                 */
;/*                                                                       */
;/*      hisr -> tc_entry                    Actual entry function of HISR*/
;/*                                                                       */
;/* INPUTS                                                                */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* OUTPUTS                                                               */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* HISTORY                                                               */
;/*                                                                       */
;/*         NAME            DATE                    REMARKS               */
;/*                                                                       */
;/*      B. Sellew       01-19-1996      Created initial version 1.0      */
;/*	 B. Sellew	 01-22-1996	 Verified version 1.0		  */
;/*                                                                       */
;/*************************************************************************/
;VOID    TCT_HISR_Shell(void)
;{
	.def	$TCT_HISR_Shell
$TCT_HISR_Shell				    ; Dual-state interworking veneer
	.state16
	BX	pc
	NOP
	.state32
	B	_TCT_HISR_Shell
;
        .def    _TCT_HISR_Shell
_TCT_HISR_Shell
;
;    /* Point at the HISR.  */
;    REG_HISR_Ptr =  (TC_HCB *) TCD_Current_Thread;
;
        LDR     a1,Current_Thread	    ; Build address of thread pointer
        LDR     v2,[a1, #0]                 ; Pickup control block pointer
;
;    do
;    {
TCT_HISR_Loop
;
;        /* Call the HISR's entry routine.  */
;        (*(REG_HISR_Ptr -> tc_entry)) ();
;
        LDR     v1,[v2,#44h]                ; Call HISR entry function
	BL	IND_CALL		    ;    indirectly
;
;        /* Lockout interrupts.  */
;
        MRS     a2,CPSR                     ; Pickup current CPSR
        ORR     a2,a2,#LOCKOUT              ; Build interrupt lockout 
        MSR     CPSR,a2                     ; Lockout interrupts
;
;        /* On return, decrement the activation count and check to see if 
;           it is 0.  Once it reaches 0, the HISR should be made inactive. */
;        REG_HISR_Ptr -> tc_activation_count--;
;
        LDR     a1,[v2, #40h]               ; Pickup current activation count
        SUBS    a1,a1,#1                    ; Subtract and set condition codes
        STR     a1,[v2, #40h]               ; Store new activation count
        BEQ     TCT_HISR_Finished           ; Finished processing HISR

;        /* Restore interrupts.  */
;
        LDR     a3,Int_Level		    ; Pickup address of interrupt level
        MRS     a2,CPSR                     ; Pickup current CPSR
        LDR     a4,[a3, #0]                 ; Pickup interrupt lockout level
        BIC     a2,a2,#LOCK_MSK             ; Clear lockout bits
        ORR     a2,a2,a4                    ; Build new interrupt lockout
        MSR     CPSR,a2                     ; Setup CPSR appropriately
        B       TCT_HISR_Loop               ; Return to HISR loop
;    }
;    while (REG_HISR_Ptr -> tc_activation_count);
;
TCT_HISR_Finished
;
;    /* At this point, the HISR needs to be made inactive.  */
;
;    /* Determine if this is the only HISR on the given priority list.  */
;    if (REG_HISR_Ptr == TCD_Active_HISR_Tails[REG_HISR_Ptr -> tc_priority])
;    {
;
        LDR     lr,HISR_Tails		    ; Pickup tail pointers address
        LDRB    a4,[v2,#1ah]                ; Pickup priority
        LDR     v3,[lr,a4,LSL #2]           ; Pickup this priority tail pointer
        LDR     a3,Execute_HISR		    ; Build address to execute HISR ptr
        MOV     a1,#0                       ; Clear a1
        LDR     a2,HISR_Heads		    ; Pickup head pointers address
        CMP     v3,v2                       ; Is this priority tail the same as
                                            ;   the current HISR?
        BNE     TCT_More_HISRs              ; If not, more HISRs at this 
                                            ;   priority
;
;        /* The only HISR on the list.  Clean up the list and check for the
;           highest priority HISR.  */
;       TCD_Active_HISR_Heads[REG_HISR_Ptr -> tc_priority] =  NU_NULL;
;       TCD_Active_HISR_Tails[REG_HISR_Ptr -> tc_priority] =  NU_NULL;
;
        STR     a1,[a2,a4,LSL #2]           ; Set head pointer to NU_NULL
        STR     a1,[lr,a4,LSL #2]           ; Set tail pointer to NU_NULL
;
;       /* Determine the highest priority HISR.  */
;       if (TCD_Active_HISR_Heads[0])
;           TCD_Execute_HISR =  TCD_Active_HISR_Heads[0];
;       else if (TCD_Active_HISR_Heads[1])
;           TCD_Execute_HISR =  TCD_Active_HISR_Heads[1];
;       else
;           TCD_Execute_HISR =  TCD_Active_HISR_Heads[2];
;
        LDR     a4,[a2,#0]                  ; Pickup priority 0 head pointer
        CMP     a4,#0                       ; Is there an HISR active?
        LDREQ   a4,[a2,#4]                  ; If not, pickup priority 1 pointer
        CMPEQ   a4,#0                       ; Is there an HISR active?
        LDREQ   a4,[a2,#8]                  ; If not, pickup priority 2 pointer
        STR     a4,[a3,#0]                  ; Setup execute HISR pointer
        B       TCT_HISR_Exit               ; Exit HISR processing
;    }
;    else
;    {
;
TCT_More_HISRs
;
;        /* Move the head pointer to the next HISR in the list.  */
;        TCD_Active_HISR_Heads[REG_HISR_Ptr -> tc_priority] =  
;                                        REG_HISR_Ptr -> tc_active_next;
;
;        /* Also set the TCD_Execute_HISR pointer.  */
;        TCD_Execute_HISR =  REG_HISR_Ptr -> tc_active_next;
;
        LDR     lr,[v2,#3ch]                ; Pickup next HISR to activate
        STR     lr,[a2,a4,LSL #2]           ; Setup new head pointer
        STR     lr,[a3, #0]                 ; Setup execute HISR pointer
;    }
;
TCT_HISR_Exit
;
;    /* Build fake return to the top of this loop.  The next time the HISR
;       is activated, it will return to the top of this function.  */
;
        LDR     lr,HISR_Shell		    ; Pickup address of shell entry
        STMDB   sp!,{v1-ip,lr}              ; Save minimal context of thread on
                                            ;   the current stack
        MOV     a3,#0                       ; Build solicited stack type value
                                            ;   and NU_NULL value
	STR	a3,[sp, #-4]!		    ; Save state mask
        STR     a3,[sp, #-4]!               ; Place it on the top of the stack
;
;    /* Clear the current thread control block.  */
;    TCD_Current_Thread =  NU_NULL;
;
        LDR     a2,Current_Thread	    ; Pickup current thread ptr address
        STR     a3,[a2, #0]                 ; Set current thread pointer to 
                                            ;   NU_NULL
;
;    /* Save off the current stack pointer in the control block.  */
;    REG_HISR_Ptr -> tc_stack_pointer =  (VOID *) REG_Stack_Ptr;
;
        STR     sp,[v2, #2ch]               ; Save the thread's stack pointer
;
;    /* Switch to the system stack.  */
;    REG_Stack_Ptr =  (BYTE_PTR) TCD_System_Stack;
;
        LDR     a2,System_Stack		    ; Pickup address of stack pointer
        LDR     a3,System_Limit		    ; Pickup address of stack limit ptr
        LDR     sp,[a2, #0]                 ; Switch to system stack
        LDR     v7,[a3, #0]                 ; Setup system stack limit
;
;    /* Transfer control to the main scheduling loop.  */
;
        B       _TCT_Schedule               ; Return to main scheduling loop
;}
;
;/* Define the global addresses used in this section */
;
System_Limit
        .word   _TCT_System_Limit
;
Int_Level
        .word   _TCD_Interrupt_Level
;
Task_Shell
        .word   $TCC_Task_Shell
;
HISR_Shell
        .word   _TCT_HISR_Shell
;
Signal_Shell
        .word   $TCC_Signal_Shell
;
Current_Thread
        .word   _TCD_Current_Thread
;
Execute_HISR
        .word   _TCD_Execute_HISR
;
Execute_Task
        .word   _TCD_Execute_Task
;
Time_Slice
        .word   _TMD_Time_Slice
;
Slice_State
        .word   _TMD_Time_Slice_State
;
System_Stack
        .word   _TCD_System_Stack
;
Int_Count
        .word   _TCD_Interrupt_Count
;
HISR_Tails
        .word   _TCD_Active_HISR_Tails
;
HISR_Heads
        .word   _TCD_Active_HISR_Heads
;
System_Error
	.word	$ERC_System_Error
;
        .end