FreeCalypso > hg > fc-magnetite
view src/cs/os/nucleus/tct.s @ 685:3fb7384e820d
tpudrv12.h: FCDEV3B goes back to being itself
A while back we had the idea of a FreeCalypso modem family whereby our
current fcdev3b target would some day morph into fcmodem, with multiple
FC modem family products, potentially either triband or quadband, being
firmware-compatible with each other and with our original FCDEV3B. But
in light of the discovery of Tango modules that earlier idea is now being
withdrawn: instead the already existing Tango hw is being adopted into
our FreeCalypso family.
Tango cannot be firmware-compatible with triband OM/FCDEV3B targets
because the original quadband RFFE on Tango modules is wired in TI's
original Leonardo arrangement. Because this Leonardo/Tango way is now
becoming the official FreeCalypso way of driving quadband RFFEs thanks
to the adoption of Tango into our FC family, our earlier idea of
extending FIC's triband RFFE control signals with TSPACT5 no longer makes
much sense - we will probably never produce any new hardware with that
once-proposed arrangement. Therefore, that triband-or-quadband FCFAM
provision is being removed from the code base, and FCDEV3B goes back to
being treated the same way as CONFIG_TARGET_GTAMODEM for RFFE control
purposes.
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Thu, 24 Sep 2020 21:03:08 +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