gemrtos_core.h

Go to the documentation of this file.

 
/******************************************************************************
*                                                                             *
* License Agreement                                                           *
* Copyright (c) Ricardo L. Cayssials                                          *
* All rights reserved.                                                        *
*                                                                             *
******************************************************************************/
 
// Check https://stackoverflow.com/questions/1154709/how-can-i-hide-the-declaration-of-a-struct-in-c
 
#ifndef GEMRTOS_CORE_H_
#define GEMRTOS_CORE_H_
 
#include <grtosdefinitions.h>
 
/************************************************************************************
 *  System constants definitions
 ************************************************************************************/
#define G_FALSE             0u
#define G_TRUE              1u
 
 
/************************************************************************************
 *  GRTOS TYPE DEFINITIONS
 ************************************************************************************/
 
typedef struct gs_kcb      GS_KCB;
typedef struct gs_pcb      GS_PCB;
typedef struct gs_lcb      GS_LCB;
typedef struct gs_tcb      GS_TCB;
typedef struct gs_ecb      GS_ECB;
typedef struct gs_scb      GS_SCB; 
typedef struct gs_rrds     GS_RRDS;
typedef struct g_rgb       G_RCB;
typedef struct gs_mcb      GS_MCB; 
typedef struct g_rgb       t_message_resource; 
typedef struct g_rgb       t_semaphore_resource;
 
 
/* This is the definition for Nios32.  */
typedef unsigned long long INT64;
typedef unsigned           INT32;       /* Unsigned 32 bit quantity      */
typedef unsigned int       GS_STK;      /* Type to Stack Pointers        */
 
typedef unsigned long long gt_time;
typedef unsigned long long gt_priority;
 
 
typedef union timepriority {
    INT64 i64  __attribute__((aligned(4)));
    INT32 i32[2];
} TIMEPRIORITY;
 
 
typedef struct gs_tm {
    int tm_msec;    /* Seconds: 0-59 (K&R says 0-61?) */
    int tm_sec;     /* Seconds: 0-59 (K&R says 0-61?) */
    int tm_min;     /* Minutes: 0-59 */
    int tm_hour;    /* Hours since midnight: 0-23 */
    int tm_day;     /* Day of the month: 1-31 */
    int tm_year;    /* Years since 1900 */
} gt_tm;
 
struct gs_ext_isr {
    struct gs_tcb *G_TCB_ISR;        
    INT32         G_EXT_INT_Count;  
    gt_priority   G_EXT_ISR_Timeout; 
};
 
/************************************************************************************
 *  GeMRTOS DATA STRUCTURES
 ************************************************************************************/
 
//*************************************************************************************************
 
 
struct gs_ecb {
    unsigned int   BLOCK_HASH;         
    INT32          ECBState;           
    INT32          ECBType;            
    void           *malloc_address;    
    TIMEPRIORITY   ECBValue;           
    struct gs_ecb  *ECB_NextECB;       
    struct gs_ecb  *ECB_PrevECB;       
    struct gs_tcb  *ECB_AssocTCB;      
    struct g_rcb   *ECB_AssocRCB;      
    struct gs_ecb  *ECB_NextTCBAEL;    
    struct gs_ecb  *ECB_PrevTCBAEL;    
    struct gs_ecb  *ECB_NextECBAEL;    
    struct gs_scb  *ECB_NextECBASL;    
    struct gs_rrds *ECB_RRDS;          
    
    struct gs_ecb  *ECB_NEXT_ECBs;     
    struct gs_ecb  *ECB_PREV_ECBs;     
};
 
#define  GS_ECBState_GRANTED_RESOURCE            1u      
#define  GS_ECBState_WAITING_RESOURCE            2u      
#define  GS_ECBState_FREE                        3u      
#define  GS_ECBState_WAITING_TIME                4u      
#define  GS_ECBState_UNLINKED                    5u      
 
#define  G_ECBType_OSTimeDly                   21u       
#define  G_ECBType_PERIODIC                    22u       
#define  G_ECBType_LASTEST_TIME                23u       
#define  G_ECBType_TIMEOUT_SEM_GRANTED         24u       
#define  G_ECBType_TIMEOUT_SEM_WAITING         25u       
#define  G_ECBType_SEM_GRANTED                 28u       
#define  G_ECBType_SEM_WAITING                 29u       
#define  G_ECBType_NOT_SPECIFIED               30u       
#define  G_ECBType_QUEUE_CONSUME               31u       
#define  G_ECBType_MESSAGE_CONSUME_WAIT        33u       
#define  G_ECBType_MESSAGE_CONSUME_EXPIRED     34u       
#define  G_ECBType_MESSAGE_SEND_EXPIRED        35u       
#define  G_ECBType_MESSAGE_SEND_WAIT           36u       
 
 
//*************************************************************************************************
 
struct gs_kcb {
    struct gs_ecb     *KCB_NextECBTL;        
    struct gs_tcb     *KCB_NextTCBWL;        
    struct gs_lcb     *KCB_NextLCBL;         
    struct gs_scb     *KCB_NextKCBASL;       
    struct gs_ext_isr KCB_ExtISR[ALT_NIRQ] __attribute__((aligned(4)));  
    
    // int     *GRTOS_PROCESSOR_BASE[G_NUMBER_OF_PCB+1] __attribute__((aligned(4))); /// \brief Processor specific addresses to go to idle state
    
    GS_PCB  *G_PCBTbl __attribute__((aligned(4)));                                
    
    INT32             KCB_NUMBER_OF_TCBs;    
    INT32             KCB_NUMBER_OF_PCBs;    
    INT32             KCB_NUMBER_OF_ECBs;    
    INT32             KCB_NUMBER_OF_RCBs;    
    INT32             KCB_NUMBER_OF_LCBs;    
    INT32             KCB_NUMBER_OF_SCBs;    
    INT32             KCB_NUMBER_OF_RRDSs;   
    
    // volatile INT32   G_ISR_STACK[ALT_NIRQ][G_ISR_STACKSIZE] __attribute__((aligned(4)));           ///< \brief Array of STACKS for ISR tasks
    // volatile GS_STK  G_IDLE_STACK[G_NUMBER_OF_PCB][G_IDLE_STACKSIZE] __attribute__((aligned(4)));  ///< \brief Array of STACKS for IDLE tasks    
    volatile INT32   *G_ISR_STACK;
    volatile GS_STK  *G_IDLE_STACK;
    
    struct gs_tcb    *KCB_ROOT_TCBs;        
    struct gs_ecb    *KCB_ROOT_ECBs;        
    struct g_rcb     *KCB_ROOT_RCBs;        
    struct gs_lcb    *KCB_ROOT_LCBs;        
    struct gs_scb    *KCB_ROOT_SCBs;        
    struct gs_rrds   *KCB_ROOT_RRDSs;       
};
 
//*************************************************************************************************
 
 
struct gs_lcb {
    unsigned int  BLOCK_HASH;           
    INT32         LCBState;             
    INT32         LCBType;              
    void          *malloc_address;      
    INT64         LCBRunPriority;      
    INT32         LCBCurrentRunning;   
    INT32         LCBExclusion;        
    struct gs_tcb *LCB_NextTCBRUNL;    
    struct gs_tcb *LCB_NextTCBRDYL;    
    struct gs_lcb *LCB_NextLCBL;       
    struct gs_lcb *LCB_PrevLCBL;       
    struct gs_pcb *LCB_NextLCBFPL;     
    
    struct gs_lcb  *LCB_NEXT_LCBs;     
    struct gs_lcb  *LCB_PREV_LCBs;     
};
 
#define  GS_LCBState_LINKED                        1u  
#define  GS_LCBState_UNLINKED                      2u  
 
#define  GS_LCBType_UNSPECIFIED                    2u  
//*************************************************************************************************
 
 
struct gs_pcb {
    int PCBID;                                  
    int PCBState;                               
    int PCBType;                                
    int *GRTOS_PROCESSOR_BASE __attribute__((aligned(4))); 
    struct gs_lcb *PCB_RDY_LCBL[G_NUMBER_OF_LCBs_FOR_PCB] __attribute__((aligned(4))); 
    struct gs_tcb *PCB_IDLETCB;                 
    struct gs_tcb *PCB_EXECTCB;                 
    struct gs_pcb *PCB_NextPCB;                 
    struct gs_pcb *PCB_PrevPCB;                 
};
 
#define  GS_PCBState_NOTRUNNING           1u    
#define  GS_PCBState_RUNNING              2u    
#define  GS_PCBState_FREE                 3u    
 
#define  GS_PCBType_UNSPECIFIED           1u    
 
#include <mq.h>
#include <sem.h>
 
struct T_MESSAGE_RESOURCE {
    INT32          MESSize;            
    INT32          MESEntries;         
    struct gs_mcb  *MES_FirstMCB;      
    struct gs_mcb  *MES_LastMCB;       
    INT32          LAST_MCB_ID;        
};
 
struct gs_mcb {                      
    INT32         MCBState;          
    INT32         MCBCount;          
    struct gs_mcb *MCB_NextMCB;      
    struct gs_mcb *MCB_PrevMCB;      
    void          *MCB_StartMessage; 
    void          *MCB_EndMessage;   
    INT32         MCB_ID;            
    INT32         MCB_RlsCount;      
};
 
#define  GK_MCBState_UNLINKED   2u
#define  GK_MCBState_FREE       3u
#define  GK_MCBState_LINKED     4u
 
 
extern struct T_QUEUE_RESOURCE     queue;
 
//*************************************************************************************************
 
 
struct g_rgb{
    struct {
        unsigned int  BLOCK_HASH;             
        INT32         RCBState;               
        INT32         RCBType;                
        INT32         RCBCount;               
        void          *malloc_address;        
        TIMEPRIORITY  RCBPriority;            
        TIMEPRIORITY  RCBGrantedPriority;     
        TIMEPRIORITY  RCBWaitingTimeout;      
        TIMEPRIORITY  RCBGrantedTimeout;      
        struct gs_ecb *RCB_NextRCBWEL;        
        struct gs_ecb *RCB_NextRCBGEL;        
        struct g_rcb  *RCB_NextRCB;           
        struct gs_scb *RCB_NextRCBASL;        
        
        struct g_rgb *RCB_NEXT_RCBs;     
        struct g_rgb *RCB_PREV_RCBs;     
    };    
    union {
        struct T_SEMAPHORE_RESOURCE semaphore;         
        struct T_MESSAGE_RESOURCE   message;           
        struct T_QUEUE_RESOURCE     queue;             
    };
};
 
#define  GK_RCBState_SEM           3u        
#define  GK_RCBState_MQ            4u        
#define  GK_RCBState_UNDEFINED     5u        
#define  GK_RCBState_QUEUE         6u        
 
#define  GK_RCBType_UNUSED         1u        
#define  GK_RCBType_FREE           2u        
#define  GK_RCBType_SEM            3u        
#define  GK_RCBType_MQ             4u        
#define  GK_RCBType_QUEUE          5u        
 
 
//*************************************************************************************************
 
 
struct gs_rrds {
    struct {
            unsigned int   BLOCK_HASH;           
            INT32          RRDS_State;           
            INT32          RRDS_Type;            
            void           *malloc_address;      
            struct gs_rrds *RRDS_NextRRDS;       
            struct gs_scb  *RRDS_NextSCB;        
            struct gs_ecb  *RRDS_AsocECB;        
            
            struct gs_rrds  *RRDS_NEXT_RRDSs;     
            struct gs_rrds  *RRDS_PREV_RRDSs;     
    };
    union {
        struct {         
            TIMEPRIORITY   RRDSWaitingTimeout;   
            TIMEPRIORITY   RRDSGrantedTimeout;   
            TIMEPRIORITY   RRDSWaitingPriority;  
            TIMEPRIORITY   RRDSGrantedPriority;  
        };
        struct queue_buffer queue_buffer;                 
    };
};
 
 
//*************************************************************************************************
 
 
struct gs_scb {
    unsigned int  BLOCK_HASH;               
    INT32         SCBState;                 
    INT32         SCBType;                  
    void          *malloc_address;          
    INT32         SCBPriority;              
    void          *SCB_TaskCode;            
    void          *SCB_TaskArg;             
    struct        gs_scb *SCB_NextSCB;      
    struct        gs_scb *SCB_NextSCBAPSL;  
    void          *SCB_AssocXCB;            
    
    struct gs_scb  *SCB_NEXT_SCBs;     
    struct gs_scb  *SCB_PREV_SCBs;     
};
 
// SCBState gruop
#define  G_SCBState_FREE          1u         
#define  G_SCBState_IN_KCB        2u         
#define  G_SCBState_IN_ECB        3u         
#define  G_SCBState_IN_TCB        4u         
#define  G_SCBState_IN_RCB        5u         
#define  G_SCBState_IN_PCB        6u         
#define  G_SCBState_IN_LCB        7u         
#define  G_SCBState_UNLINKED      8u         
#define  G_SCBState_PENDING       9u         
#define  G_SCBState_EXECUTING    10u         
 
// SCBType group
#define G_SCBType_TCB_ABORTED          1000u      
 
 
//*************************************************************************************************
 
struct gs_tcb 
{
    unsigned int  BLOCK_HASH;             
    unsigned int  TCBState;               
    unsigned int  TCBType;                
    void *malloc_address;                 
    INT64  TCBReadyPriority;              
    INT64  TCBInherPriority;              
    INT64  TCBRunPriority;                
    INT64  TCBCurrentPriority;            
    INT64  TCBPeriod;                     
    INT64  TCBDeadline;                   
    GS_STK *TCB_StackPointer;             
    GS_STK *TCB_StackBottom;              
    GS_STK *TCB_StackTop;                 
    void   *TCB_TaskCode;                 
    void   *TCB_TaskArg;                  
    volatile struct gs_tcb *TCB_NextTCB;  
    struct gs_tcb *TCB_PrevTCB;           
    struct gs_ecb *TCB_NextTCBAEL;        
    struct gs_scb *TCB_NextTCBASL;        
    struct gs_scb *TCB_NextTCBPSL;        
    unsigned int TCB_AssocPCB;            
    int TCB_INTNumber;                    
    struct gs_lcb *TCB_RDY_LCB_Index;     
    int TCB_Abort_w_Deadline;             
    struct gs_tcb *TCB_NextISRTCB;        
    struct gs_tcb *TCB_PrevISRTCB;        
    
    struct gs_tcb  *TCB_NEXT_TCBs;     
    struct gs_tcb  *TCB_PREV_TCBs;     
};
 
// TCBState gruop
#define  GRTOS_TASK_STATE_WAITING(ptcb)  ((ptcb->TCBState >> 1) & 1) 
 
#define  G_TCBState_WAITING_COMPLETED           2u   
#define  G_TCBState_WAITING                   258u   
#define  G_TCBState_READY                       4u   
#define  G_TCBState_RUNNING                     8u   
#define  G_TCBState_FREE                       16u   
#define  G_TCBState_UNLINKED                   32u   
 
// TCBType group
#define G_TCBType_UCOS                          1u   
#define G_TCBType_PERIODIC                      2u   
#define G_TCBType_ISR                           4u   
#define G_TCBType_IDLE                          5u   
#define G_TCBType_UNDEFINED                     7u   
 
/*
*********************************************************************************************************
*    SYSTEM VARIABLES
*********************************************************************************************************
*/
 
 
extern volatile int G_DEBUG_SAMPLE_BEGIN_ENABLE;
extern volatile int G_DEBUG_SAMPLE_END_ENABLE;
 
extern volatile INT32  G_Running;      
extern volatile INT32  gs_sizeof_G_PCBTbl;
extern volatile void   *gs_addressof_G_PCBTbl;
extern volatile INT32  gs_offsetof_PCB_EXECTCB;
extern volatile INT32  gs_offsetof_TCB_StackPointer;
extern volatile INT32  gs_offsetof_PCB_IDLETCB;
 
 
extern GS_KCB g_kcb;
 
//Variable to interface C and assembler
extern volatile GS_STK G_TCB_CURRENT;
extern volatile INT32  G_SCB_PENDING;
extern volatile INT32  G_SCB_CODE;
extern volatile INT32  G_SCB_ARG;
 
// extern volatile int GRTOS_S_PROCESSOR1_IRQ_INTERRUPT_CONTROLLER_ID;
extern volatile int GRTOS_S_PROCESSOR1_IRQ;
 
extern volatile int G_IRQ_ENABLED;
extern volatile int G_IRQ_PENDING;
 
extern volatile INT32 GRTOS_MutexReleaseRegisterAddress;
extern volatile INT32 GRTOS_MutexRequestRegisterAddress;
extern volatile INT32 GRTOS_InterruptEnableRegisterAddress;
extern volatile INT32 GRTOS_InterruptDisableRegisterAddress;  
 
extern FILE* fpuart[G_NUMBER_OF_PCB];
 
extern volatile INT32 G_TASK_TYPE_DEFAULT;
extern volatile GS_LCB *G_TASK_LCB_DEFAULT;
extern volatile INT64 G_TASK_PRIORITY_DEFAULT;
extern volatile INT64 G_TASK_PERIOD_DEFAULT;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
GS_ECB *gk_Get_ECB(void);
G_RCB  *gk_Get_RCB(void);
GS_SCB *gk_Get_SCB(void);
GS_RRDS *gk_Get_RRDS(void);
GS_LCB *gk_Get_LCB(void);
INT32 gk_Create_PCBs(int Nmbr_PCB);
 
 
/***************************************************************/
/* INTERNAL SYSTEM FUNCTIONS                                   */
/***************************************************************/
gt_time gu_get_mutex_time(void);
INT32     gk_TCBLowerPriorityThanTCB(GS_TCB *ptcb1, GS_TCB *ptcb2);
INT32   gk_LCB_CheckInvertion(void);
INT32    gk_SetLowestProcessor(void);
INT32    gk_SetNextTimeProcessor(void);
INT32     gk_LCBLowerPriorityThanLCB(GS_LCB *plcb1, GS_LCB *plcb2);
GS_TCB *gk_PCB_GetNextTCB(void);
GS_TCB *gk_PCB_GetCurrentTCB(void);
 
/***************************************************************/
/* debug function                                              */
/***************************************************************/
INT32 TCB_IsValid(GS_TCB *ptcb);
 
INT32 LCB_IsValid(GS_LCB *plcb);
 
INT32 PCB_IsValid(GS_PCB *ppcb);
INT32 ECB_IsValid(GS_ECB *pevent);
INT32 SCB_IsValid(GS_SCB *pscb);
INT32 RCB_IsValid(void *prcb);
INT32 RRDS_IsValid(GS_RRDS *prrds);
 
INT32 TCBState_Valid(unsigned int tcbstate);
INT32 TCBType_Valid(unsigned int tcbtype);
INT32 ECBState_Valid(unsigned int ecbstate);
INT32 ECBType_Valid(unsigned int ecbtype);
 
INT32 IsAListorNull(GS_LCB *plcb);
 
 
/***************************************************************/
/*  LIST AND DATA STRUCTURES PROTOTYPES                        */
/***************************************************************/
 
INT32   gk_ECBAEL_Link(GS_ECB *pevent1, GS_ECB *pevent2);
INT32   gk_ECBAEL_Remove(GS_ECB *pevent);
 
void    gk_ECBASL_Link(GS_ECB *pevent, GS_SCB *psignal);
INT32   gk_ECBASL_Unlink(GS_ECB *pevent, GS_SCB *psignal);
GS_SCB *gk_ECBASL_GetSCB(GS_ECB *pevent, INT32 SignalType);
 
GS_ECB *gk_ECB_GetFree(void);
// INT32   gk_ECBFL_Link(GS_ECB *pevent);
 
extern INT32    gk_ECBTL_Link (GS_ECB *pevent);
extern INT32    gk_ECBTL_Unlink(GS_ECB *pevent);
 
INT32    gk_KCBASL_Link(GS_SCB *psignal);
INT32   gk_KCBASL_Unlink(GS_SCB *psignal);
INT32    gk_LCBL_Link(GS_LCB *plcb);
GS_SCB *gk_KCBASL_GetSCB(INT32 SignalType);
 
INT32    gk_LCBFPL_Link(int processorID);
INT32    gk_LCBFPL_Unlink(int processorID);
 
INT32    gk_LCBL_UnLink(GS_LCB *plcb);
//void    gk_LCB_Link_to_LCB_List(GS_LCB *plcb);
 
// GS_MCB *gk_MCB_GetFree(void);
// void    gk_MCBFL_Link(GS_MCB *pmcb);
 
// int     gk_MCBQL_Link(GS_MCB *pmcb, G_RCB * prcb);
// void    gk_MCBQL_Unlink(GS_MCB *pmcb, G_RCB * prcb);
 
void    gk_PCBInit(void);
 
G_RCB  *gk_RCB_GetFree(void);
INT32    gk_RCBFL_Link(G_RCB *presource);
 
INT32 gk_TASK_RELEASE(GS_TCB *ptcb);
INT32 gk_TASK_RESOURCE_WAIT(G_RCB *presource, GS_ECB *pevent);
INT32 gk_TASK_RESOURCE_UNWAIT(G_RCB *presource, GS_ECB *pevent);
INT32 gk_TASK_RESOURCE_GRANT(G_RCB *presource, GS_ECB *pevent);
INT32 gk_TASK_RESOURCE_UNGRANT(G_RCB *presource, GS_ECB *pevent) ;
GS_ECB *gk_TASK_RESOURCE_CREATE(G_RCB *presource, 
                                GS_TCB  *ptcb, 
                                INT64 waiting_priority,
                                INT64 RCBGrantedPriority,
                                INT64 RCBWaitingTimeout,
                                INT64 RCBGrantedTimeout);
INT32 gk_TASK_RESOURCE_DESTROY(GS_ECB *pevent);
 
GS_ECB *gk_RCBGEL_Link(G_RCB *presource, GS_ECB *pevent);
void    gk_RCBGEL_Unlink(GS_ECB *pevent);
 
INT32    gk_RCBASL_Link(G_RCB *presource, GS_SCB *psignal);
INT32    gk_RCBASL_Unlink(G_RCB *presource, GS_SCB *psignal);
GS_SCB *gk_RCBASL_GetSCB(G_RCB *presource, INT32 SignalType);
 
GS_ECB *gk_RCBWEL_Link(G_RCB *presource, GS_ECB *pevent);
void    gk_RCBWEL_Unlink(GS_ECB *pevent);
 
INT32    gk_RRDSASL_Link(GS_RRDS *prrds, GS_SCB *psignal);
INT32    gk_RRDSASL_UnLink(GS_RRDS *prrds, GS_SCB *psignal);
GS_SCB *gk_RRDSASL_GetSCB(GS_RRDS *prrds, INT32 SignalType);
 
GS_RRDS *gk_RRDS_GetFree(void);
INT32    gk_RRDSFL_Link(GS_RRDS *prrds);
 
INT32    gk_SCBFL_Link(GS_SCB *psignal);
GS_SCB *gk_SCB_GetFree(void);
GS_SCB *gk_SCB_Copy(GS_SCB *psignal);
 
void    gk_SCBAPSL_Link(GS_SCB *pscb_root, GS_SCB *pscb_pending);
INT32   gk_SCBAPSL_UnLink(GS_SCB *pscb_root, GS_SCB *pscb_pending);
 
GS_TCB *gk_TCB_GetFree(void);
INT32    gk_TCB_Unlink(GS_TCB *ptcb);
 
void    gk_TCBFL_Init(void);
INT32    gk_TCBFL_Link(GS_TCB *ptcb);
 
INT32    gk_TCBAEL_Link(GS_ECB *pevent, GS_TCB *ptcb);
INT32    gk_TCBAEL_Unlink(GS_ECB *pevent);
 
INT32    gk_TCBASL_Link(GS_TCB *ptcb, GS_SCB *psignal);
INT32    gk_TCBASL_Unlink(GS_TCB *ptcb, GS_SCB *psignal);
GS_SCB *gk_TCBASL_GetSCB(GS_TCB *ptcb, INT32 SignalType);
INT32    gk_TCB_List_Unlink(GS_TCB *ptcb);
INT32   gk_ECB_List_Unlink(GS_ECB *pevent);
INT32   gk_ECBFL_Link(GS_ECB *pevent);
 
INT32    gk_TCBPSL_Link(GS_TCB *ptcb, GS_SCB *psignal);
INT32    gk_TCBPSL_Unlink(GS_TCB *ptcb, GS_SCB *psignal);
GS_SCB *gk_TCBPSL_GetSCB(GS_TCB *ptcb, INT32 SignalType);
 
INT32    gk_TCBRDYL_Link(GS_TCB *ptcb);
INT32    gk_TCBRDYL_Unlink(GS_TCB *ptcb);
 
INT32    gk_TCBRUNL_Link(GS_TCB *ptcb);
INT32    gk_TCBRUNL_Unlink(GS_TCB *ptcb);
 
INT32    gk_TCBWL_Link(GS_TCB *ptcb, unsigned int state);
INT32    gk_TCBWL_Unlink(GS_TCB *ptcb);
 
/***************************************************************/
/*         TASK RELATED FUNCTIONS                              */
/***************************************************************/
// GS_TCB *gk_TASK_Create(void);
INT32    gk_TASK_Kill(GS_TCB *ptcb);
void    gk_KERNEL_TASK_SUSPEND(GS_TCB *ptcb);
void    gk_KERNEL_TASK_SUSPEND_CURRENT(void);
INT32   gk_TASK_IS_BLOCKED(GS_TCB *ptcb);
GS_ECB *gk_TCB_in_RCBGEL(G_RCB *presource, GS_TCB *ptcb);
INT32    gk_TASK_PRIORITY_SET(GS_TCB *ptcb, INT32 task_state);
INT64   gk_TASK_GRANTED_PRIORITY_GET(GS_TCB *ptcb);
INT32    gk_TASK_INHERENCE_PRIORITY_SET(GS_TCB * ptcb);
 
 
/***************************************************************/
/*  INTERNAL ROUTINES FOR TASK EXECUTION                       */
/***************************************************************/
// void gk_Start_Main(void);
void gk_KERNEL_TASK_START (void);
void gk_ENTRY_IRQ_HANDLER (void);
void GRTOS_Start_Task(void);
void grtos_irq_entry(void);
void GRTOS_Suspend_Task(void);
// void gk_INT_TASK_SWITCH(void);
GS_TCB *gk_CreateTask(void *TaskCode,              
                     void *p_arg,                  
                     void *StkBotton,              
                     unsigned int StkSize,         
                     unsigned int TCBType,         
                     INT64 TCBReadyPriority,       
                     INT64 TCBRunPriority,         
                     INT64 TCBDeadline,            
                     INT64 TCBPeriod,              
                     GS_LCB *TCB_RDY_LCB_Index,        
                     int TCB_Abort_w_Deadline,     
                     INT64 TCBInherPriority, int TCB_INTNumber); 
                     
INT32 gk_TASK_STK_Init(GS_TCB *ptcb);
// void gk_TASK_TCB_Init (GS_TCB *ptcb);
// void gk_INIT_IRQ(void);
// void gk_KERNEL_TIME_IRQ_HANDLER (void);
void gk_TIME_CALLBACK(GS_ECB *event);
void gk_RESOURCE_ECB_KILL_CALLBACK(GS_ECB *pevent);
void gk_FROZEN_CALLBACK(void);
void gk_INIT_KERNEL(void);
void gk_KERNEL_TASK_COMPLETE(void);
void GRTOS_Task_GetPendingSCB(void);
// void gk_KERNEL_FROZEN_IRQ_HANDLER(void);
void gk_RST_MONITOR_HANDLER (void);
 
 
/***************************************************************/
/*  SYSTEM TASKS                                               */
/***************************************************************/
void gk_ENTRY_SIGNAL_RETURN(void);
void gk_CODE_IDLE_TASK(void* pdata);
 
 
 
INT32  gu_TASK_Sleep(INT32 hours, INT32 minutes, INT32 seconds, INT32 ms);
INT32  gu_TASK_Sleep_Time(gt_time ticks);
 
int     gu_Get_CPU_ID(void);
gt_time gu_Get_Next_Occurrence_Time(void);
gt_tm   gu_Clock(gt_time gtime);
 
INT32 gu_Set_Default_Task_Type(unsigned int type);
INT32 gu_Get_Default_Task_Type(void);
INT32 gu_Set_Default_Task_List(GS_LCB * list);
INT32 gu_Get_Default_Task_List(void);
void gu_Set_Default_Task_Priority(INT32 level, INT32 priority);
void gu_Set_Default_Task_Period(INT32 hours, INT32 minutes, INT32 seconds, INT32 ms);
INT32 gu_SetTaskType(struct gs_tcb *ptcb, unsigned int type);
INT32 gu_SetTaskList(struct gs_tcb *ptcb, struct gs_lcb *plcb);
INT32 gu_SetTaskReadyPriority(struct gs_tcb *ptcb, long long priority);
INT32 gu_SetTaskRunPriority(struct gs_tcb *ptcb, long long priority);
INT32 gu_SetTaskDeadline(struct gs_tcb *ptcb, unsigned int hours, unsigned int minutes, unsigned int seconds, unsigned int ms);
INT32 gu_SetTaskPeriod(struct gs_tcb *ptcb, unsigned int hours, unsigned int minutes, unsigned int seconds, unsigned int ms);
INT32 gu_SetTaskAbortwhenDeadline(struct gs_tcb *ptcb, unsigned int abort_when_deadline);
INT32 gu_StartTaskwithOffset(struct gs_tcb *ptcb,unsigned int hours, unsigned int minutes, unsigned int seconds, unsigned int ms);
 
 
void *gu_GetTask(void         *TaskCode,   
                 void         *p_arg,      
                 void         *StkBotton,  
                 unsigned int  StkSize);    
 
 
INT32   gu_TASK_Kill(GS_TCB *ptcb);
INT32   gu_TASK_SUSPEND(GS_TCB *ptcb);
INT32   gu_TASK_RESUME(GS_TCB *ptcb);
INT32   gu_TASK_IS_BLOCKED(GS_TCB *ptcb);
 
 
 
 
GS_SCB *gu_signal_create(INT32 Type, INT32 Priority, void *pxcb, void *Signal_Code, void *Signal_Arg);
INT32      gu_signal_destroy(GS_SCB *pscb);
 
gt_time  gu_Convert_Time(INT32 days, INT32 hours, INT32 minutes, INT32 seconds, INT32 ms);
INT32    gu_get_irq_status(void);
INT32    gu_get_reserved_mutex_processor(void);
gt_time gu_get_now(void);
gt_time gu_get_frozen_threshold(void);
 
void  gk_INIT_IRQ (void);
INT32 gk_ISR_COMPLETE (GS_TCB *ptcb);
void  gk_ISR_RELEASE (int irq_nbr);
INT32 gu_SetTaskISR(struct gs_tcb *ptcb, unsigned int irq_nbr);
INT32 gk_SetTaskISR(struct gs_tcb *ptcb, unsigned int irq_nbr);
 
 
// *************************************************** //
// *************************************************** //
//void  gu_TASK_Sleep_Time(gt_time ticks)
//{
//  G_DEBUG_VERBOSE
//    GRTOS_USER_CRITICAL_SECTION_GET;
//    
//        <PREVIOUS SUSPEND PROCEDURE >
//    
//  gk_KERNEL_TASK_SUSPEND_CURRENT();
//    GRTOS_USER_CRITICAL_SECTION_GET;
//    
//        <AFTER SUSPEND PROCEDURE >
//        
//  GRTOS_CMD_CRITICAL_SECTION_RELEASE;
//}
// *************************************************** //
// *************************************************** //
 
// alt_exception_result handler (alt_exception_cause cause, alt_u32 addr, alt_u32 bad_addr );
 
void gk_MONITOR_FIFO_SAMPLE(int data);
INT32 Check_list_TCBAEL_IsValid(int cycles);
 
 
 
#endif /* GEMRTOS_CORE_H_ */