FreeCalypso > hg > freecalypso-sw
view gsm-fw/nucleus/tcse.c @ 302:cd5068cf0551
fc-fsio: symlink command implemented
author | Michael Spacefalcon <msokolov@ivan.Harhan.ORG> |
---|---|
date | Sun, 02 Mar 2014 04:34:49 +0000 |
parents | afceeeb2cba1 |
children |
line wrap: on
line source
/*************************************************************************/ /* */ /* Copyright Mentor Graphics Corporation 2002 */ /* All Rights Reserved. */ /* */ /* THIS WORK CONTAINS TRADE SECRET AND PROPRIETARY INFORMATION WHICH IS */ /* THE PROPERTY OF MENTOR GRAPHICS CORPORATION OR ITS LICENSORS AND IS */ /* SUBJECT TO LICENSE TERMS. */ /* */ /*************************************************************************/ /*************************************************************************/ /* */ /* FILE NAME VERSION */ /* */ /* tcse.c Nucleus PLUS 1.14 */ /* */ /* COMPONENT */ /* */ /* TC - Thread Control */ /* */ /* DESCRIPTION */ /* */ /* This file contains error checking routines for the supplemental */ /* functions in the Thread Control component. This permits easy */ /* removal of error checking logic when it is not needed. */ /* */ /* DATA STRUCTURES */ /* */ /* None */ /* */ /* FUNCTIONS */ /* */ /* TCSE_Change_Priority Change task's priority */ /* TCSE_Change_Preemption Change task's preemption */ /* TCSE_Change_Time_Slice Change task's time slice */ /* TCSE_Control_Signals Enable and disable signals */ /* TCSE_Receive_Signals Receive current signals */ /* TCSE_Register_Signal_Handler Register a signal handler */ /* TCSE_Send_Signals Send signals to a task */ /* TCSE_Activate_HISR Activate an HISR */ /* */ /* DEPENDENCIES */ /* */ /* tc_extr.h Thread Control functions */ /* */ /* HISTORY */ /* */ /* DATE REMARKS */ /* */ /* 03-01-1994 Created initial version 1.1 from */ /* routines originally in core */ /* error checking file */ /* */ /* 03-18-1994 Verified version 1.1 */ /* 04-17-1996 updated to version 1.2 */ /* 03-17-1997 Protected Send Signals service */ /* from NULL Control Block pointers */ /* creating 1.2a. (SPR220) */ /* 03-24-1998 Released version 1.3. */ /* 04-17-2002 Released version 1.13m */ /* 11-07-2002 Released version 1.14 */ /*************************************************************************/ #define NU_SOURCE_FILE #include "tc_extr.h" /* Thread control functions */ /* Define external inner-component global data references. */ extern TC_TCB *TCD_Execute_Task; extern VOID *TCD_Current_Thread; /*************************************************************************/ /* */ /* FUNCTION */ /* */ /* TCSE_Change_Priority */ /* */ /* DESCRIPTION */ /* */ /* This function performs error checking for the change priority */ /* service. If an error is detected, this service is ignored and */ /* the requested priority is returned. */ /* */ /* CALLED BY */ /* */ /* Application */ /* */ /* CALLS */ /* */ /* TCS_Change_Priority Actual change priority */ /* */ /* INPUTS */ /* */ /* task_ptr Task control block pointer */ /* new_priority New priority for task */ /* */ /* OUTPUTS */ /* */ /* old_priority Original task priority */ /* */ /* HISTORY */ /* */ /* DATE REMARKS */ /* */ /* 03-01-1993 Created initial version 1.0 */ /* 04-19-1993 Verified version 1.0 */ /* 03-01-1994 Changed function interface, */ /* resulting in version 1.1 */ /* */ /* 03-18-1994 Verified version 1.1 */ /* */ /*************************************************************************/ OPTION TCSE_Change_Priority(NU_TASK *task_ptr, OPTION new_priority) { TC_TCB *task; /* Task control block ptr */ OPTION old_priority; /* Previous priority of task */ /* Move input task pointer into internal task pointer. */ task = (TC_TCB *) task_ptr; /* Determine if the task pointer is valid. */ if (task -> tc_id == TC_TASK_ID) /* Nothing seems to be wrong, change the priority as specified. */ old_priority = TCS_Change_Priority(task_ptr, new_priority); else /* Copy the new priority into the old priority. */ old_priority = new_priority; /* Return the previous priority. */ return(old_priority); } /*************************************************************************/ /* */ /* FUNCTION */ /* */ /* TCSE_Change_Preemption */ /* */ /* DESCRIPTION */ /* */ /* This function performs error checking on the change preemption */ /* service. If the current thread is not a task thread, this */ /* request is ignored. */ /* */ /* CALLED BY */ /* */ /* Application */ /* */ /* CALLS */ /* */ /* TCS_Change_Preemption Change the preemption posture*/ /* of the calling task */ /* */ /* INPUTS */ /* */ /* preempt Preempt selection parameter */ /* */ /* OUTPUTS */ /* */ /* old_preempt Original preempt value */ /* */ /* HISTORY */ /* */ /* DATE REMARKS */ /* */ /* 03-01-1993 Created initial version 1.0 */ /* 04-19-1993 Verified version 1.0 */ /* */ /*************************************************************************/ OPTION TCSE_Change_Preemption(OPTION preempt) { TC_TCB *task; /* Pointer to task */ OPTION old_preempt; /* Pickup the current thread and place it in the task pointer. */ task = (TC_TCB *) TCD_Current_Thread; /* Determine if the current thread is really a task thread. */ if (task -> tc_id == TC_TASK_ID) /* Yes, change the preemption posture. */ old_preempt = TCS_Change_Preemption(preempt); else /* Return the original request. */ old_preempt = preempt; /* Return the previous preemption posture. */ return(old_preempt); } /*************************************************************************/ /* */ /* FUNCTION */ /* */ /* TCSE_Change_Time_Slice */ /* */ /* DESCRIPTION */ /* */ /* This function performs error checking on the change time slice */ /* service. If the specified task pointer is invalid, this */ /* request is ignored. */ /* */ /* CALLED BY */ /* */ /* Application */ /* */ /* CALLS */ /* */ /* TCS_Change_Time_Slice Change the time slice of the */ /* specified task */ /* */ /* INPUTS */ /* */ /* task_ptr Task control block pointer */ /* time_slice New time slice value */ /* */ /* OUTPUTS */ /* */ /* old_time_slice Old time slice value */ /* */ /* HISTORY */ /* */ /* DATE REMARKS */ /* */ /* 03-01-1993 Created initial version 1.0 */ /* 04-19-1993 Verified version 1.0 */ /* 03-01-1994 Changed function interface, */ /* resulting in version 1.1 */ /* */ /* 03-18-1994 Verified version 1.1 */ /* */ /*************************************************************************/ UNSIGNED TCSE_Change_Time_Slice(NU_TASK *task_ptr, UNSIGNED time_slice) { TC_TCB *task; /* Task control block ptr */ UNSIGNED old_time_slice; /* Old time slice value */ /* Move input task pointer into internal pointer. */ task = (TC_TCB *) task_ptr; /* Determine if the task pointer is valid. */ if (task -> tc_id == TC_TASK_ID) /* Yes, change the time slice. */ old_time_slice = TCS_Change_Time_Slice(task_ptr, time_slice); else /* Return the current request. */ old_time_slice = time_slice; /* Return the previous time slice value. */ return(old_time_slice); } /*************************************************************************/ /* */ /* FUNCTION */ /* */ /* TCSE_Control_Signals */ /* */ /* DESCRIPTION */ /* */ /* This function checks to see if the call is being made from a */ /* non-task thread. If so, the request is simply ignored. */ /* */ /* CALLED BY */ /* */ /* Application */ /* */ /* CALLS */ /* */ /* TCS_Control_Signals Actual control signals func */ /* */ /* INPUTS */ /* */ /* enable_signal_mask Enable signal mask */ /* */ /* OUTPUTS */ /* */ /* Previous signal enable mask */ /* */ /* HISTORY */ /* */ /* DATE REMARKS */ /* */ /* 03-01-1993 Created initial version 1.0 */ /* 04-19-1993 Verified version 1.0 */ /* */ /*************************************************************************/ UNSIGNED TCSE_Control_Signals(UNSIGNED enable_signal_mask) { UNSIGNED return_mask; /* Return signal mask */ TC_TCB *task; /* Task pointer */ /* Pickup the task pointer. */ task = (TC_TCB *) TCD_Current_Thread; /* Determine if the call is valid. */ if (task -> tc_id == TC_TASK_ID) /* Valid request- call actual routine to control signals. */ return_mask = TCS_Control_Signals(enable_signal_mask); else /* Return a cleared mask. */ return_mask = 0; /* Return the old enable mask. */ return(return_mask); } /*************************************************************************/ /* */ /* FUNCTION */ /* */ /* TCSE_Receive_Signals */ /* */ /* DESCRIPTION */ /* */ /* This function determines whether or not the call is being made */ /* from a task thread of execution. If not, the call is ignored. */ /* */ /* CALLED BY */ /* */ /* Application */ /* */ /* CALLS */ /* */ /* TCS_Receive_Signals Actual receive signals func */ /* */ /* INPUTS */ /* */ /* None */ /* */ /* OUTPUTS */ /* */ /* Current signals */ /* */ /* HISTORY */ /* */ /* DATE REMARKS */ /* */ /* 03-01-1993 Created initial version 1.0 */ /* 04-19-1993 Verified version 1.0 */ /* */ /*************************************************************************/ UNSIGNED TCSE_Receive_Signals(VOID) { TC_TCB *task; /* Task pointer */ UNSIGNED signals; /* Current signals */ /* Pickup the task pointer. */ task = (TC_TCB *) TCD_Current_Thread; /* Determine if the call is valid. */ if (task -> tc_id == TC_TASK_ID) /* Valid request- call actual routine to receive signals. */ signals = TCS_Receive_Signals(); else /* Return cleared signals. */ signals = 0; /* Return the signals to the caller. */ return(signals); } /*************************************************************************/ /* */ /* FUNCTION */ /* */ /* TCSE_Register_Signal_Handler */ /* */ /* DESCRIPTION */ /* */ /* This function determines whether or not the caller is a task. */ /* If the caller is not a task and/or if the supplied signal */ /* handling function pointer is NULL, an appropriate error status */ /* is returned. */ /* */ /* CALLED BY */ /* */ /* Application */ /* */ /* CALLS */ /* */ /* TCS_Register_Signal_Handler Actual function to register */ /* the signal handler */ /* */ /* INPUTS */ /* */ /* signal_handler Signal execution shell */ /* */ /* OUTPUTS */ /* */ /* NU_INVALID_TASK Not called from task thread */ /* NU_INVALID_POINTER Signal handler pointer NULL */ /* */ /* HISTORY */ /* */ /* DATE REMARKS */ /* */ /* 03-01-1993 Created initial version 1.0 */ /* 04-19-1993 Verified version 1.0 */ /* */ /*************************************************************************/ STATUS TCSE_Register_Signal_Handler(VOID (*signal_handler)(UNSIGNED)) { STATUS status; /* Return status */ TC_TCB *task; /* Task pointer */ /* Pickup the task pointer. */ task = (TC_TCB *) TCD_Current_Thread; /* Determine if the caller is a task. */ if (task -> tc_id != TC_TASK_ID) /* Indicate that the caller is invalid. */ status = NU_INVALID_TASK; else if (signal_handler == NU_NULL) /* Indicate that the signal handler is invalid. */ status = NU_INVALID_POINTER; else /* Everything is fine, call the actual function. */ status = TCS_Register_Signal_Handler(signal_handler); /* Return completion status. */ return(status); } /*************************************************************************/ /* */ /* FUNCTION */ /* */ /* TCSE_Send_Signals */ /* */ /* DESCRIPTION */ /* */ /* This function checks for an invalid task. If an invalid task */ /* is selected and error is returned. */ /* */ /* CALLED BY */ /* */ /* Application */ /* */ /* CALLS */ /* */ /* TCS_Send_Signals Actual send signal function */ /* */ /* INPUTS */ /* */ /* task_ptr Task pointer */ /* signals Signals to send to the task */ /* */ /* OUTPUTS */ /* */ /* NU_INVALID_TASK Task pointer is invalid */ /* */ /* HISTORY */ /* */ /* DATE REMARKS */ /* */ /* 03-01-1993 Created initial version 1.0 */ /* 04-19-1993 Verified version 1.0 */ /* 03-01-1994 Changed function interface, */ /* resulting in version 1.1 */ /* */ /* 03-18-1994 Verified version 1.1 */ /* 03-17-1997 Corrected SPR220. */ /* */ /*************************************************************************/ STATUS TCSE_Send_Signals(NU_TASK *task_ptr, UNSIGNED signals) { TC_TCB *task; /* Task control block ptr */ STATUS status; /* Completion status */ /* Move input task pointer into internal pointer. */ task = (TC_TCB *) task_ptr; /* Determine if the task pointer is valid. */ if ((task != NU_NULL) && (task -> tc_id == TC_TASK_ID)) /* Task pointer is valid, call the actual function. */ status = TCS_Send_Signals(task_ptr, signals); else /* Task pointer is invalid, return an error status. */ status = NU_INVALID_TASK; /* Return the completion status. */ return(status); }