diff gsm-fw/nucleus/tcse.c @ 143:afceeeb2cba1

Our nuc-fw is destined to become gsm-fw, so I went ahead and did the big hg mv
author Michael Spacefalcon <msokolov@ivan.Harhan.ORG>
date Tue, 12 Nov 2013 05:35:48 +0000
parents nuc-fw/nucleus/tcse.c@947b1f473960
children
line wrap: on
line diff
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gsm-fw/nucleus/tcse.c	Tue Nov 12 05:35:48 2013 +0000
@@ -0,0 +1,527 @@
+/*************************************************************************/
+/*                                                                       */
+/*               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);
+}
+
+
+
+