diff gsm-fw/nucleus/tcce.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/tcce.c@947b1f473960
children
line wrap: on
line diff
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gsm-fw/nucleus/tcce.c	Tue Nov 12 05:35:48 2013 +0000
@@ -0,0 +1,1134 @@
+/*************************************************************************/
+/*                                                                       */
+/*               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       */
+/*                                                                       */
+/*      tcce.c                                         Nucleus PLUS 1.14 */
+/*                                                                       */
+/* COMPONENT                                                             */
+/*                                                                       */
+/*      TC - Thread Control                                              */
+/*                                                                       */
+/* DESCRIPTION                                                           */
+/*                                                                       */
+/*      This file contains error checking routines for the functions in  */
+/*      the Thread Control component.  This permits easy removal of      */
+/*      error checking logic when it is not needed.                      */
+/*                                                                       */
+/* DATA STRUCTURES                                                       */
+/*                                                                       */
+/*      None                                                             */
+/*                                                                       */
+/* FUNCTIONS                                                             */
+/*                                                                       */
+/*      TCCE_Create_Task                    Create a task                */
+/*      TCCE_Create_HISR                    Create HISR                  */
+/*      TCCE_Delete_HISR                    Delete HISR                  */
+/*      TCCE_Delete_Task                    Delete a task                */
+/*      TCCE_Reset_Task                     Reset a task                 */
+/*      TCCE_Terminate_Task                 Terminate a task             */
+/*      TCCE_Resume_Service                 Resume a task service call   */
+/*      TCCE_Suspend_Service                Suspend a task service call  */
+/*      TCCE_Relinquish                     Relinquish task execution    */
+/*      TCCE_Task_Sleep                     Task sleep request           */
+/*      TCCE_Suspend_Error                  Check for suspend req error  */
+/*      TCCE_Activate_HISR                  Activate an HISR             */
+/*      TCCE_Validate_Resume                Validates resume requests    */
+/*                                                                       */
+/* DEPENDENCIES                                                          */
+/*                                                                       */
+/*      tc_extr.h                           Thread Control functions     */
+/*                                                                       */
+/* HISTORY                                                               */
+/*                                                                       */
+/*         DATE                    REMARKS                               */
+/*                                                                       */
+/*      03-01-1993      Created initial version 1.0                      */
+/*      04-19-1993      Verified version 1.0                             */
+/*      03-01-1994      Modified logic that checked task                 */
+/*                        status without protection of                   */
+/*                        scheduling structures,                         */
+/*                        resulting in version 1.0a                      */
+/*      03-01-1994      Verified version 1.0a                            */
+/*      03-01-1994      Moved non-core error checking                    */
+/*                        functions to a supplemental                    */
+/*                        file, and modified function                    */
+/*                        interfaces, added validate                     */
+/*                        resume service, resulting in                   */
+/*                        version 1.1                                    */
+/*                                                                       */
+/*      03-18-1994      Verified version 1.1                             */
+/*      03-19-1996      Added error checking to                          */
+/*                        TCCE_Task_Sleep, resulting                     */
+/*                        in version 1.1+ (spr037)                       */
+/*      04-17-1996      updated to version 1.2                           */
+/*      10-16-1996      Modified to save the current                     */
+/*                        thread's protection rather                     */
+/*                        than that of the task being                    */
+/*                        resumed (SPR212)(SPR268)                       */
+/*      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                                                              */
+/*                                                                       */
+/*      TCCE_Create_Task                                                 */
+/*                                                                       */
+/* DESCRIPTION                                                           */
+/*                                                                       */
+/*      This function performs error checking on the parameters supplied */
+/*      to the create task function.                                     */
+/*                                                                       */
+/* CALLED BY                                                             */
+/*                                                                       */
+/*      Application                                                      */
+/*                                                                       */
+/* CALLS                                                                 */
+/*                                                                       */
+/*      TCC_Create_Task                     Actual create task function  */
+/*                                                                       */
+/* INPUTS                                                                */
+/*                                                                       */
+/*      task_ptr                            Task control block pointer   */
+/*      name                                Task name                    */
+/*      task_entry                          Entry function of the task   */
+/*      argc                                Optional task parameter      */
+/*      argv                                Optional task parameter      */
+/*      stack_address                       Pointer to start of stack    */
+/*      stack_size                          Size of task stack in bytes  */
+/*      priority                            Task priority                */
+/*      time_slice                          Task time slice              */
+/*      preempt                             Task preemptability flag     */
+/*      auto_start                          Automatic task start         */
+/*                                                                       */
+/* OUTPUTS                                                               */
+/*                                                                       */
+/*      NU_SUCCESS                          Successful request           */
+/*      NU_INVALID_TASK                     Task control block pointer   */
+/*                                            is NULL                    */
+/*      NU_INVALID_ENTRY                    Task entry function is NULL  */
+/*      NU_INVALID_MEMORY                   Stack pointer is NULL        */
+/*      NU_INVALID_SIZE                     Stack size is too small      */
+/*      NU_INVALID_PRIORITY                 Invalid task priority        */
+/*      NU_INVALID_PREEMPT                  Invalid preemption selection */
+/*      NU_INVALID_START                    Invalid start selection      */
+/*                                                                       */
+/* HISTORY                                                               */
+/*                                                                       */
+/*         DATE                    REMARKS                               */
+/*                                                                       */
+/*      03-01-1993      Created initial version 1.0                      */
+/*      04-19-1993      Verified version 1.0                             */
+/*      03-01-1994      Modified function interface,                     */
+/*                        added register optimizations,                  */
+/*                        resulting in version 1.1                       */
+/*                                                                       */
+/*      03-18-1994      Verified version 1.1                             */
+/*                                                                       */
+/*************************************************************************/
+STATUS  TCCE_Create_Task(NU_TASK *task_ptr, CHAR *name, 
+          VOID (*task_entry)(UNSIGNED, VOID *), UNSIGNED argc, VOID *argv, 
+          VOID *stack_address, UNSIGNED stack_size,
+          OPTION priority, UNSIGNED time_slice, 
+          OPTION preempt, OPTION auto_start)
+{
+
+TC_TCB         *task;                       /* Task control block ptr    */
+STATUS          status;                     /* Completion status         */
+
+
+    /* Move input task control block pointer into internal pointer.  */
+    task =  (TC_TCB *) task_ptr;
+
+    /* Check each parameter.  */
+    if ((task == NU_NULL) || (task -> tc_id == TC_TASK_ID))
+    
+        /* Invalid task control block pointer.  */
+        status =  NU_INVALID_TASK;
+
+    else if (task_entry == NU_NULL)
+    
+        /* Invalid task entry function pointer.  */
+        status =  NU_INVALID_ENTRY;
+        
+    else if (stack_address == NU_NULL)
+    
+        /* Invalid stack starting address.  */
+        status =  NU_INVALID_MEMORY;
+        
+    else if (stack_size < NU_MIN_STACK_SIZE)
+    
+        /* Invalid stack size.  */
+        status =  NU_INVALID_SIZE;
+        
+   
+    else if ((preempt != NU_PREEMPT) && (preempt != NU_NO_PREEMPT))
+    
+        /* Invalid preemption.  */
+        status =  NU_INVALID_PREEMPT;
+        
+    else if ((auto_start != NU_START) && (auto_start != NU_NO_START))
+    
+        /* Invalid start selection. */
+        status =  NU_INVALID_START;
+        
+    else
+    
+        /* Call the actual function to create a task.  All the parameters 
+           appear to be correct.  */
+        status =  TCC_Create_Task(task_ptr, name, task_entry, argc, argv,
+         stack_address, stack_size, priority, time_slice, preempt, auto_start);
+        
+    /* Return completion status.  */
+    return(status);
+}
+
+
+/*************************************************************************/
+/*                                                                       */
+/* FUNCTION                                                              */
+/*                                                                       */
+/*      TCCE_Create_HISR                                                 */
+/*                                                                       */
+/* DESCRIPTION                                                           */
+/*                                                                       */
+/*      This function performs error checking on the parameters supplied */
+/*      to the create HISR function.                                     */
+/*                                                                       */
+/* CALLED BY                                                             */
+/*                                                                       */
+/*      Application                                                      */
+/*                                                                       */
+/* CALLS                                                                 */
+/*                                                                       */
+/*      TCC_Create_HISR                     Actual create HISR function  */
+/*                                                                       */
+/* INPUTS                                                                */
+/*                                                                       */
+/*      hisr_ptr                            HISR control block pointer   */
+/*      name                                HISR name                    */
+/*      hisr_entry                          Entry function of the HISR   */
+/*      priority                            Task priority                */
+/*      stack_address                       Pointer to start of stack    */
+/*      stack_size                          Size of HISR stack in bytes  */
+/*                                                                       */
+/* OUTPUTS                                                               */
+/*                                                                       */
+/*      NU_INVALID_HISR                     Invalid HISR pointer         */
+/*      NU_INVALID_ENTRY                    Invalid HISR entry point     */
+/*      NU_INVALID_PRIORITY                 Invalid HISR priority        */
+/*      NU_INVALID_MEMORY                   Indicates stack pointer NULL */
+/*      NU_INVALID_SIZE                     Indicates stack size is too  */
+/*                                            small                      */
+/*                                                                       */
+/* HISTORY                                                               */
+/*                                                                       */
+/*         DATE                    REMARKS                               */
+/*                                                                       */
+/*      03-01-1993      Created initial version 1.0                      */
+/*      04-19-1993      Verified version 1.0                             */
+/*      03-01-1994      Modified function interface,                     */
+/*                        added register optimizations,                  */
+/*                        resulting in version 1.1                       */
+/*                                                                       */
+/*      03-18-1994      Verified version 1.1                             */
+/*                                                                       */
+/*************************************************************************/
+STATUS  TCCE_Create_HISR(NU_HISR *hisr_ptr, CHAR *name, 
+                            VOID (*hisr_entry)(VOID), OPTION priority, 
+                            VOID *stack_address, UNSIGNED stack_size)
+{
+
+TC_HCB         *hisr;                       /* HISR control block ptr    */
+STATUS          status;                     /* Completion status         */
+
+
+
+    /* Move input HISR pointer into internal pointer.  */
+    hisr =  (TC_HCB *) hisr_ptr;
+
+    /* Check each parameter.  */
+    if ((hisr == NU_NULL) || (hisr -> tc_id == TC_HISR_ID))
+    
+        /* Invalid HISR control block pointer.  */
+        status =  NU_INVALID_HISR;
+
+    else if (hisr_entry == NU_NULL)
+    
+        /* Invalid HISR entry function pointer.  */
+        status =  NU_INVALID_ENTRY;
+        
+    else if (stack_address == NU_NULL)
+    
+        /* Invalid stack starting address.  */
+        status =  NU_INVALID_MEMORY;
+        
+    else if (stack_size < NU_MIN_STACK_SIZE)
+    
+        /* Invalid stack size.  */
+        status =  NU_INVALID_SIZE;
+        
+    else if (((INT) priority) >= TC_HISR_PRIORITIES)
+    
+        /* Invalid HISR priority.  */
+        status =  NU_INVALID_PRIORITY;
+
+    else
+    
+        /* Call the actual function to create a HISR.  All the parameters 
+           appear to be correct.  */
+        status =  TCC_Create_HISR(hisr_ptr, name, hisr_entry, priority,
+                                                stack_address, stack_size);
+        
+    /* Return completion status.  */
+    return(status);
+}
+
+
+/*************************************************************************/
+/*                                                                       */
+/* FUNCTION                                                              */
+/*                                                                       */
+/*      TCCE_Delete_Task                                                 */
+/*                                                                       */
+/* DESCRIPTION                                                           */
+/*                                                                       */
+/*      This function performs error checking on the parameters supplied */
+/*      to the delete task function.                                     */
+/*                                                                       */
+/* CALLED BY                                                             */
+/*                                                                       */
+/*      Application                                                      */
+/*                                                                       */
+/* CALLS                                                                 */
+/*                                                                       */
+/*      TCC_Delete_Task                     Actual delete task function  */
+/*                                                                       */
+/* INPUTS                                                                */
+/*                                                                       */
+/*      task_ptr                            Task control block pointer   */
+/*                                                                       */
+/* OUTPUTS                                                               */
+/*                                                                       */
+/*      NU_SUCCESS                          If successful completion     */
+/*      NU_INVALID_TASK                     Task pointer is invalid      */
+/*      NU_INVALID_DELETE                   Task not in a finished or    */
+/*                                            terminated state           */
+/*                                                                       */
+/* HISTORY                                                               */
+/*                                                                       */
+/*         DATE                    REMARKS                               */
+/*                                                                       */
+/*      03-01-1993      Created initial version 1.0                      */
+/*      04-19-1993      Verified version 1.0                             */
+/*      03-01-1994      Modified function interface,                     */
+/*                        added register optimizations,                  */
+/*                        resulting in version 1.1                       */
+/*                                                                       */
+/*      03-18-1994      Verified version 1.1                             */
+/*                                                                       */
+/*************************************************************************/
+STATUS  TCCE_Delete_Task(NU_TASK *task_ptr)
+{
+
+TC_TCB         *task;                       /* Task control block ptr    */
+STATUS          status;                     /* Completion status         */
+
+
+    /* Move input task control block pointer into internal pointer.  */
+    task =  (TC_TCB *) task_ptr;
+
+    /* Determine if the supplied task pointer is valid.  */
+    if ((task == NU_NULL) || (task -> tc_id != TC_TASK_ID))
+    
+        /* Invalid task pointer supplied.  */
+        status =  NU_INVALID_TASK;
+
+    else if ((task -> tc_status != NU_FINISHED) &&
+             (task -> tc_status != NU_TERMINATED))
+             
+        /* A task that is not in the finished or terminated state cannot
+           be deleted.  */
+        status =  NU_INVALID_DELETE;
+
+    else
+    
+        /* Valid task pointer, call the function to delete the task.  */
+        status =  TCC_Delete_Task(task_ptr);
+        
+    /* Return the completion status.  */
+    return(status);
+}
+
+
+/*************************************************************************/
+/*                                                                       */
+/* FUNCTION                                                              */
+/*                                                                       */
+/*      TCCE_Delete_HISR                                                 */
+/*                                                                       */
+/* DESCRIPTION                                                           */
+/*                                                                       */
+/*      This function performs error checking on the parameters supplied */
+/*      to the delete HISR function.                                     */
+/*                                                                       */
+/* CALLED BY                                                             */
+/*                                                                       */
+/*      Application                                                      */
+/*                                                                       */
+/* CALLS                                                                 */
+/*                                                                       */
+/*      TCC_Delete_HISR                     Actual delete HISR function  */
+/*                                                                       */
+/* INPUTS                                                                */
+/*                                                                       */
+/*      hisr_ptr                            HISR control block pointer   */
+/*                                                                       */
+/* OUTPUTS                                                               */
+/*                                                                       */
+/*      NU_INVALID_HISR                     Indicates HISR pointer is    */
+/*                                            invalid                    */
+/*                                                                       */
+/* HISTORY                                                               */
+/*                                                                       */
+/*         DATE                    REMARKS                               */
+/*                                                                       */
+/*      03-01-1993      Created initial version 1.0                      */
+/*      04-19-1993      Verified version 1.0                             */
+/*      03-01-1994      Modified function interface,                     */
+/*                        added register optimizations,                  */
+/*                        resulting in version 1.1                       */
+/*                                                                       */
+/*      03-18-1994      Verified version 1.1                             */
+/*                                                                       */
+/*************************************************************************/
+STATUS  TCCE_Delete_HISR(NU_HISR *hisr_ptr)
+{
+
+TC_HCB         *hisr;                       /* HISR control block ptr    */
+STATUS          status;                     /* Completion status         */
+
+
+    /* Move input HISR control block pointer into internal pointer.  */
+    hisr =  (TC_HCB *) hisr_ptr;
+    
+    /* Determine if the supplied HISR pointer is valid.  */
+    if ((hisr) && (hisr -> tc_id == TC_HISR_ID))
+    
+        /* Valid HISR pointer, call the function to delete the HISR.  */
+        status =  TCC_Delete_HISR(hisr_ptr);
+    else
+    
+        /* Invalid HISR pointer, indicate with the status.  */
+        status =  NU_INVALID_HISR;
+        
+    /* Return the completion status.  */
+    return(status);
+}
+
+
+/*************************************************************************/
+/*                                                                       */
+/* FUNCTION                                                              */
+/*                                                                       */
+/*      TCCE_Reset_Task                                                  */
+/*                                                                       */
+/* DESCRIPTION                                                           */
+/*                                                                       */
+/*      This function performs error checking on the parameters supplied */
+/*      to the reset task function.                                      */
+/*                                                                       */
+/* CALLED BY                                                             */
+/*                                                                       */
+/*      Application                                                      */
+/*                                                                       */
+/* CALLS                                                                 */
+/*                                                                       */
+/*      TCC_Reset_Task                      Actual reset task function   */
+/*                                                                       */
+/* INPUTS                                                                */
+/*                                                                       */
+/*      task_ptr                            Task control block pointer   */
+/*      argc                                Optional task parameter      */
+/*      argv                                Optional task parameter      */
+/*                                                                       */
+/* OUTPUTS                                                               */
+/*                                                                       */
+/*      NU_INVALID_TASK                     Indicates 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      Modified function interface,                     */
+/*                        added register optimizations,                  */
+/*                        resulting in version 1.1                       */
+/*                                                                       */
+/*      03-18-1994      Verified version 1.1                             */
+/*                                                                       */
+/*************************************************************************/
+STATUS  TCCE_Reset_Task(NU_TASK *task_ptr, UNSIGNED argc, VOID *argv)
+{
+
+TC_TCB         *task;                       /* Task control block ptr   */
+STATUS          status;                     /* Status of the request    */
+
+
+    /* Move input task control block 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 invalid.  */
+        status =  NU_INVALID_TASK;
+    else
+    
+        /* Call actual function to reset the task.  */
+        status =  TCC_Reset_Task(task_ptr, argc, argv);
+
+    /* Return completion status.  */
+    return(status);
+}
+
+
+/*************************************************************************/
+/*                                                                       */
+/* FUNCTION                                                              */
+/*                                                                       */
+/*      TCCE_Terminate_Task                                              */
+/*                                                                       */
+/* DESCRIPTION                                                           */
+/*                                                                       */
+/*      This function performs error checking on the parameters supplied */
+/*      to the terminate task function.                                  */
+/*                                                                       */
+/* CALLED BY                                                             */
+/*                                                                       */
+/*      Application                                                      */
+/*                                                                       */
+/* CALLS                                                                 */
+/*                                                                       */
+/*      TCC_Terminate_Task                  Actual terminate task funct  */
+/*                                                                       */
+/* INPUTS                                                                */
+/*                                                                       */
+/*      task_ptr                            Task control block pointer   */
+/*                                                                       */
+/* OUTPUTS                                                               */
+/*                                                                       */
+/*      NU_INVALID_TASK                     Indicates 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      Modified function interface,                     */
+/*                        added register optimizations,                  */
+/*                        resulting in version 1.1                       */
+/*                                                                       */
+/*      03-18-1994      Verified version 1.1                             */
+/*                                                                       */
+/*************************************************************************/
+STATUS  TCCE_Terminate_Task(NU_TASK *task_ptr)
+{
+
+TC_TCB         *task;                       /* Task control block ptr    */
+STATUS          status;                     /* Status return             */
+
+
+    /* Move input task control block 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 invalid.  */
+        status =  NU_INVALID_TASK;
+    else
+    
+        /* Call actual function to terminate the task.  */
+        status =  TCC_Terminate_Task(task_ptr);
+
+    /* Return completion status.  */
+    return(status);
+}
+
+
+/*************************************************************************/
+/*                                                                       */
+/* FUNCTION                                                              */
+/*                                                                       */
+/*      TCCE_Resume_Service                                              */
+/*                                                                       */
+/* DESCRIPTION                                                           */
+/*                                                                       */
+/*      This function performs error checking on the parameters supplied */
+/*      to the resume task function.                                     */
+/*                                                                       */
+/* CALLED BY                                                             */
+/*                                                                       */
+/*      Application                                                      */
+/*                                                                       */
+/* CALLS                                                                 */
+/*                                                                       */
+/*      TCCE_Validate_Resume                Function that checks the     */
+/*                                            current task status for a  */
+/*                                            valid resume request       */
+/*      TCC_Resume_Service                  Actual task resume service   */
+/*                                                                       */
+/* INPUTS                                                                */
+/*                                                                       */
+/*      task_ptr                            Task control block pointer   */
+/*                                                                       */
+/* OUTPUTS                                                               */
+/*                                                                       */
+/*      NU_SUCCESS                          If successful completion     */
+/*      NU_INVALID_TASK                     Task pointer is invalid      */
+/*      NU_INVALID_RESUME                   Not previously suspended     */
+/*                                                                       */
+/* HISTORY                                                               */
+/*                                                                       */
+/*         DATE                    REMARKS                               */
+/*                                                                       */
+/*      03-01-1993      Created initial version 1.0                      */
+/*      04-19-1993      Verified version 1.0                             */
+/*      03-01-1994      Modified logic that checked task                 */
+/*                        status without protection of                   */
+/*                        scheduling structures,                         */
+/*                        resulting in version 1.0a                      */
+/*      03-01-1994      Verified version 1.0a                            */
+/*      03-01-1994      Modified function interface,                     */
+/*                        added register optimizations,                  */
+/*                        moved validate resume function                 */
+/*                        to this file, resulting in                     */
+/*                        version 1.1                                    */
+/*      03-18-1994      Verified version 1.1                             */
+/*                                                                       */
+/*************************************************************************/
+STATUS  TCCE_Resume_Service(NU_TASK *task_ptr)
+{
+
+TC_TCB         *task;                       /* Task control block ptr    */
+STATUS          status;                     /* Completion status         */
+
+
+
+    /* Move task control block 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 invalid.  */
+        status =  NU_INVALID_TASK;
+        
+    /* Make sure that the task is suspended in an identical manner.  */
+    else if (TCCE_Validate_Resume(NU_PURE_SUSPEND, task_ptr))
+    
+        /* Task is not unconditionally suspended, return error status.  */
+        status =  NU_INVALID_RESUME;
+    
+    else
+    
+        /* Call the actual resume service.  */
+        status =  TCC_Resume_Service(task_ptr);
+        
+    /* Return the completion status.  */
+    return(status);
+}
+
+
+/*************************************************************************/
+/*                                                                       */
+/* FUNCTION                                                              */
+/*                                                                       */
+/*      TCCE_Suspend_Service                                             */
+/*                                                                       */
+/* DESCRIPTION                                                           */
+/*                                                                       */
+/*      This function performs error checking on the suspend service.    */
+/*                                                                       */
+/* CALLED BY                                                             */
+/*                                                                       */
+/*      Application                                                      */
+/*                                                                       */
+/* CALLS                                                                 */
+/*                                                                       */
+/*      TCC_Suspend_Service                 Actual suspend service       */
+/*                                              function                 */
+/*                                                                       */
+/* INPUTS                                                                */
+/*                                                                       */
+/*      task_ptr                            Task control block pointer   */
+/*                                                                       */
+/* OUTPUTS                                                               */
+/*                                                                       */
+/*      NU_SUCCESS                          If successful completion     */
+/*      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      Modified function interface,                     */
+/*                        added register optimizations,                  */
+/*                        resulting in version 1.1                       */
+/*                                                                       */
+/*      03-18-1994      Verified version 1.1                             */
+/*                                                                       */
+/*************************************************************************/
+STATUS  TCCE_Suspend_Service(NU_TASK *task_ptr)
+{
+
+TC_TCB         *task;                       /* Task control block ptr    */
+STATUS          status;                     /* Completion status         */
+
+
+
+    /* Move task control block 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 invalid.  */
+        status =  NU_INVALID_TASK;
+        
+    else
+
+       if ((task->tc_status == NU_FINISHED) ||  (task->tc_status == NU_TERMINATED))
+
+             /* Can't suspend a task in a finished or terminated state */
+             status =  NU_INVALID_SUSPEND;
+
+
+    else
+     
+        /* Call the actual service routine.  */
+        status =  TCC_Suspend_Service(task_ptr);    
+    
+    /* Return completion status.  */                             
+    return(status);
+}
+
+
+/*************************************************************************/
+/*                                                                       */
+/* FUNCTION                                                              */
+/*                                                                       */
+/*      TCCE_Relinquish                                                  */
+/*                                                                       */
+/* DESCRIPTION                                                           */
+/*                                                                       */
+/*      This function performs error checking for the relinquish         */
+/*      function.  If the current thread is not a task, this request     */
+/*      is ignored.                                                      */
+/*                                                                       */
+/* CALLED BY                                                             */
+/*                                                                       */
+/*      Application                                                      */
+/*                                                                       */
+/* CALLS                                                                 */
+/*                                                                       */
+/*      TCC_Relinquish                      Actual relinquish function   */
+/*                                                                       */
+/* INPUTS                                                                */
+/*                                                                       */
+/*      None                                                             */
+/*                                                                       */
+/* OUTPUTS                                                               */
+/*                                                                       */
+/*      None                                                             */
+/*                                                                       */
+/* HISTORY                                                               */
+/*                                                                       */
+/*         DATE                    REMARKS                               */
+/*                                                                       */
+/*      03-01-1993      Created initial version 1.0                      */
+/*      04-19-1993      Verified version 1.0                             */
+/*                                                                       */
+/*************************************************************************/
+VOID  TCCE_Relinquish(VOID)
+{
+
+TC_TCB         *task;                       /* Pointer to task           */
+
+    /* Pickup the current thread and place it in the task pointer.  */
+    task =  (TC_TCB *) TCD_Current_Thread;
+     
+    /* Determine if the current thread is a task.  If so, call the actual
+       relinquish routine.  Otherwise, ignore the request.  */
+    if ((task) && (task -> tc_id == TC_TASK_ID))
+    
+        /* Valid request, call the relinquish function.  */
+        TCC_Relinquish();
+}
+
+
+/*************************************************************************/
+/*                                                                       */
+/* FUNCTION                                                              */
+/*                                                                       */
+/*      TCCE_Task_Sleep                                                  */
+/*                                                                       */
+/* DESCRIPTION                                                           */
+/*                                                                       */
+/*      This function performs error checking for the task sleep         */
+/*      function.  If the current thread is not a task, this request     */
+/*      is ignored.                                                      */
+/*                                                                       */
+/* CALLED BY                                                             */
+/*                                                                       */
+/*      Application                                                      */
+/*                                                                       */
+/* CALLS                                                                 */
+/*                                                                       */
+/*      TCC_Task_Sleep                      Actual task sleep function   */
+/*                                                                       */
+/* INPUTS                                                                */
+/*                                                                       */
+/*      ticks                               Number of ticks to sleep for */
+/*                                                                       */
+/* OUTPUTS                                                               */
+/*                                                                       */
+/*      None                                                             */
+/*                                                                       */
+/* HISTORY                                                               */
+/*                                                                       */
+/*         DATE                    REMARKS                               */
+/*                                                                       */
+/*      03-01-1993      Created initial version 1.0                      */
+/*      04-19-1993      Verified version 1.0                             */
+/*      03-19-1996      Added check for parameter of 0                   */
+/*                        or negative number, resulting                  */
+/*                        in version 1.1+ (spr037)                       */
+/*                                                                       */
+/*************************************************************************/
+VOID  TCCE_Task_Sleep(UNSIGNED ticks)
+{
+
+TC_TCB         *task;                       /* Pointer to task           */
+
+    /* If parameter is zero, return */
+    if (ticks == 0)
+        return;
+
+    /* Pickup the current thread and place it in the task pointer.  */
+    task =  (TC_TCB *) TCD_Current_Thread;
+     
+    /* Determine if the current thread is a task.  If so, call the actual
+       task sleep routine.  Otherwise, ignore the request.  */
+    if ((task) && (task -> tc_id == TC_TASK_ID))
+    
+        /* Valid request, call the sleep function.  */
+        TCC_Task_Sleep(ticks);
+}
+
+
+/*************************************************************************/
+/*                                                                       */
+/* FUNCTION                                                              */
+/*                                                                       */
+/*      TCCE_Suspend_Error                                               */
+/*                                                                       */
+/* DESCRIPTION                                                           */
+/*                                                                       */
+/*      This function checks for a suspend request error.  Suspension    */
+/*      requests are only allowed from task threads.  A suspend request  */
+/*      from any other thread is an error.                               */
+/*                                                                       */
+/* CALLED BY                                                             */
+/*                                                                       */
+/*      Other Components                                                 */
+/*                                                                       */
+/* CALLS                                                                 */
+/*                                                                       */
+/*      None                                                             */
+/*                                                                       */
+/* INPUTS                                                                */
+/*                                                                       */
+/*      None                                                             */
+/*                                                                       */
+/* OUTPUTS                                                               */
+/*                                                                       */
+/*      NU_TRUE                             If an error is detected      */
+/*      NU_FALSE                            If no error is detected      */
+/*                                                                       */
+/* HISTORY                                                               */
+/*                                                                       */
+/*         DATE                    REMARKS                               */
+/*                                                                       */
+/*      03-01-1993      Created initial version 1.0                      */
+/*      04-19-1993      Verified version 1.0                             */
+/*                                                                       */
+/*************************************************************************/
+INT   TCCE_Suspend_Error(VOID)
+{
+
+TC_TCB          *task;                      /* Task pointer              */
+INT              status =  NU_FALSE;        /* Initialize to no error    */
+
+
+    /* Setup the task pointer.  */
+    task =  (TC_TCB *) TCD_Current_Thread;
+
+    /* Check for suspension errors.  */
+    if (task == NU_NULL)
+    
+        /* Error, suspend request probably from initialization.  */
+        status =  NU_TRUE;
+        
+    else if (task -> tc_id != TC_TASK_ID)
+
+        /* Control block is probably an HISR not a task.  */
+        status =  NU_TRUE;
+
+    else if (task -> tc_signal_active)
+    
+        /* Called from a signal handler.  */
+        status =  NU_TRUE;
+        
+    /* Return status to caller.  */
+    return(status);
+}
+
+
+/*************************************************************************/
+/*                                                                       */
+/* FUNCTION                                                              */
+/*                                                                       */
+/*      TCCE_Activate_HISR                                               */
+/*                                                                       */
+/* DESCRIPTION                                                           */
+/*                                                                       */
+/*      This function performs error checking on the parameters supplied */
+/*      to the activate HISR function.                                   */
+/*                                                                       */
+/* CALLED BY                                                             */
+/*                                                                       */
+/*      Application                                                      */
+/*                                                                       */
+/* CALLS                                                                 */
+/*                                                                       */
+/*      TCT_Activate_HISR                   Actual HISR activate call    */
+/*                                                                       */
+/* INPUTS                                                                */
+/*                                                                       */
+/*      hisr_ptr                            HISR control block pointer   */
+/*                                                                       */
+/* OUTPUTS                                                               */
+/*                                                                       */
+/*      NU_INVALID_HISR                     Invalid HISR pointer         */
+/*                                                                       */
+/* HISTORY                                                               */
+/*                                                                       */
+/*         DATE                    REMARKS                               */
+/*                                                                       */
+/*      03-01-1993      Created initial version 1.0                      */
+/*      04-19-1993      Verified version 1.0                             */
+/*      03-01-1994      Modified function interface,                     */
+/*                        added register optimizations,                  */
+/*                        resulting in version 1.1                       */
+/*                                                                       */
+/*      03-18-1994      Verified version 1.1                             */
+/*                                                                       */
+/*************************************************************************/
+STATUS  TCCE_Activate_HISR(NU_HISR *hisr_ptr)
+{
+
+TC_HCB         *hisr;                       /* HISR control block ptr    */
+STATUS          status;                     /* Completion status         */
+NU_SUPERV_USER_VARIABLES
+
+    NU_SUPERVISOR_MODE();
+    /* Move input HISR control block pointer into internal pointer.  */
+    hisr =  (TC_HCB *) hisr_ptr;
+
+    /* Check each parameter.  */
+    if (hisr == NU_NULL)
+    
+        /* Invalid HISR control block pointer.  */
+        status =  NU_INVALID_HISR;
+
+    else if (hisr -> tc_id != TC_HISR_ID)
+    
+        /* Invalid HISR control block pointer.  */
+        status =  NU_INVALID_HISR;
+        
+    else
+    
+        /* Call the routine to activate the HISR.  */
+        status =  TCT_Activate_HISR(hisr_ptr);
+
+    /* Return to user mode */
+    NU_USER_MODE();
+        
+    /* Return completion status.  */
+    return(status);
+}
+
+
+/*************************************************************************/
+/*                                                                       */
+/* FUNCTION                                                              */
+/*                                                                       */
+/*      TCCE_Validate_Resume                                             */
+/*                                                                       */
+/* DESCRIPTION                                                           */
+/*                                                                       */
+/*      This function validates the resume service and resume driver     */
+/*      calls with scheduling protection around the examination of the   */
+/*      task status.                                                     */
+/*                                                                       */
+/* CALLED BY                                                             */
+/*                                                                       */
+/*      IOCE_Resume_Driver                  Driver error checking funct. */
+/*      TCCE_Resume_Service                 Error checking function      */
+/*                                                                       */
+/* CALLS                                                                 */
+/*                                                                       */
+/*      TCT_Set_Current_Protect             Setup current protect pointer*/
+/*      TCT_System_Protect                  Protect from system access   */
+/*      TCT_System_Unprotect                Release system protection    */
+/*      TCT_Unprotect                       Release current protection   */
+/*                                                                       */
+/* INPUTS                                                                */
+/*                                                                       */
+/*      resume_type                         Type of resume request       */
+/*      task_ptr                            Task control block pointer   */
+/*                                                                       */
+/* OUTPUTS                                                               */
+/*                                                                       */
+/*      NU_TRUE                             Invalid resume               */
+/*      NU_FALSE                            Valid resume                 */
+/*                                                                       */
+/* HISTORY                                                               */
+/*                                                                       */
+/*         DATE                    REMARKS                               */
+/*                                                                       */
+/*      03-01-1994      Created initial version of                       */
+/*                        function for version 1.0g                      */
+/*      03-01-1994      Verified version 1.0g                            */
+/*      03-01-1994      Modified function interface,                     */
+/*                        added register optimizations,                  */
+/*                        added system protection logic,                 */
+/*                        moved to TCCE since it is an                   */
+/*                        error interface function,                      */
+/*                        resulting in version 1.1                       */
+/*                                                                       */
+/*      03-18-1994      Verified version 1.1                             */
+/*      10-16-1996      Modified to save the current                     */
+/*                        thread's protection rather                     */
+/*                        than that of the task being                    */
+/*                        resumed (SPR212)(SPR268)                       */
+/*                                                                       */
+/*************************************************************************/
+STATUS  TCCE_Validate_Resume(OPTION resume_type, NU_TASK *task_ptr)
+{
+
+R1 TC_TCB      *task;                       /* Task control block ptr    */
+TC_PROTECT     *save_protect;               /* Save current protection   */
+STATUS          status;                     /* Return status variable    */
+NU_SUPERV_USER_VARIABLES
+
+    NU_SUPERVISOR_MODE();
+
+    /* Move input task pointer into internal pointer.  */
+    task =  (TC_TCB *) task_ptr;
+
+    /* Save current protection.  */
+    if (TCD_Current_Thread != NU_NULL)
+    {
+        save_protect = TCT_Get_Current_Protect();
+    }
+    else
+    {
+        save_protect = NU_NULL;
+    }
+
+    /* Protect the scheduling structures from multiple access.  */
+    TCT_System_Protect();
+    
+    /* Does the resume type match the current status?  */
+    if (task -> tc_status == resume_type)
+
+        /* Indicate that there is no error.  */
+        status =  NU_FALSE;
+    
+    /* Check for a resumption of a delayed pure suspend.  */
+    else if ((resume_type == NU_PURE_SUSPEND) && (task -> tc_delayed_suspend))
+        
+        /* Indicate that there is no error.  */
+        status =  NU_FALSE;
+            
+    /* Check for a signal active and the saved status the same as
+       the resume request.  */
+    else if ((resume_type == task -> tc_saved_status) &&
+            (task -> tc_signal_active))
+
+        /* Indicate that there is no error.  */
+        status =  NU_FALSE;
+        
+    else
+    
+        /* Indicate that there is an error.  */
+        status =  NU_TRUE;
+
+    /* Determine how to get out of protection.  */
+    if (save_protect)
+    {
+
+        /* Restore current protection.  */
+        TCT_Set_Current_Protect(save_protect);
+
+        /* Release system protect.  */
+        TCT_System_Unprotect();
+    }
+    else
+
+        /* Release protection of system structures.  */
+        TCT_Unprotect();
+            
+    /* Return to user mode */
+    NU_USER_MODE();
+    
+    /* Return status to caller.  */
+    return(status);
+}
+
+
+
+