FreeCalypso > hg > fc-selenite
diff src/cs/os/nucleus/tct.s @ 0:b6a5e36de839
src/cs: initial import from Magnetite
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Sun, 15 Jul 2018 04:39:26 +0000 |
| parents | |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/cs/os/nucleus/tct.s Sun Jul 15 04:39:26 2018 +0000 @@ -0,0 +1,3073 @@ +;/*************************************************************************/ +;/* */ +;/* 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