Add L2 IF-Module

cmake_targets/CMakeLists.txt

@@ -1418,7 +1418,7 @@ set(L2_SRC
   ${RRC_DIR}/rrc_common.c
   #${RRC_NB_DIR}/rrc_common_NB_IoT.c
   ${RRC_DIR}/L2_interface.c
-  #${RRC_NB_DIR}/L2_interface_NB_IoT.c
+  ${RRC_NB_DIR}/L2_interface_NB_IoT.c
   ${RRC_DIR}/L2_interface_common.c
   ${RRC_DIR}/L2_interface_ue.c
   )
@@ -1467,6 +1467,8 @@ set(L2_SRC_UE
 set (MAC_SRC
   #${PHY_INTERFACE_DIR}/phy_stub_UE.c
   ${PHY_INTERFACE_DIR}/IF_Module.c
+  ${PHY_INTERFACE_DIR}/IF_Module_NB_IoT.c
+  ${PHY_INTERFACE_DIR}/IF_Module_L2_primitives_NB_IoT.c
   ${MAC_DIR}/main.c
   ${MAC_DIR}/main_NB_IoT.c
   #${MAC_DIR}/main_ue.c

common/utils/msc/msc.h

@@ -110,7 +110,7 @@ void msc_log_message(
 
 #else
 
-#define MESSAGE_CHART_GENERATOR  msc_interface.msc_loaded
+#define MESSAGE_CHART_GENERATOR msc_interface.msc_loaded
 
 msc_interface_t msc_interface;
 #define MSC_INIT(arg1,arg2)                                     if(msc_interface.msc_loaded) msc_interface.msc_init(arg1,arg2)

openair2/COMMON/mac_rrc_primitives.h

@@ -30,6 +30,8 @@
 #include "COMMON/platform_types.h"
 #include "COMMON/platform_constants.h"
 
+#include "openair2/RRC/LTE/rrc_defs.h"
+
 #include "LTE_RadioResourceConfigCommonSIB.h"
 #include "LTE_RadioResourceConfigDedicated.h"
 #include "LTE_MeasGapConfig.h"

openair2/LAYER2/MAC/defs_NB_IoT.h

@@ -78,6 +78,13 @@
 /*!\brief LCID of padding LCID for DLSCH */
 #define SHORT_PADDING 31
 
+typedef enum rach_state_e
+{
+  initial_access = 0,
+  rach_for_auth_rsp,
+  rach_for_TAU,
+  rach_for_next
+}rach_state_t;
 
 typedef enum tone_type_e
 {

openair2/LAYER2/MAC/vars_NB_IoT.h

@@ -140,8 +140,15 @@ int extend_alpha_offset[2] = {10, 10};
 int uss_space = 320;
 int uss_alpha_offset = 10;
 
+rach_state_t UE_state_machine = initial_access;
+
 const int si_repetition_pattern[4] = {20, 40, 80, 160};
 
+int waiting_flag_from_RLC = 0;
+int block_RLC = 0;
+int Valid_msg3 = 1;
+int RLC_RECEIVE_MSG5_FAILED = 0;
+
 #endif
 
 

openair2/LAYER2/PDCP_v10.1.0/pdcp.h

@@ -73,7 +73,12 @@ typedef struct {
   pdcp_data_ind_func_t pdcp_data_ind_func;
 } pdcp_params_t;
 
-
+/*
+ * SN size
+ */
+#define PDCP_SN_5BIT  5
+#define PDCP_SN_7BIT  7
+#define PDCP_SN_12BIT 12
 
 #define PDCP_USE_NETLINK            ( get_pdcp_optmask() & PDCP_USE_NETLINK_BIT)
 #define LINK_ENB_PDCP_TO_IP_DRIVER  ( get_pdcp_optmask() & LINK_ENB_PDCP_TO_IP_DRIVER_BIT)
@@ -200,6 +205,7 @@ typedef struct pdcp_s {
    */
   pdcp_hfn_t tx_hfn;
   pdcp_hfn_t rx_hfn;
+  pdcp_hfn_offset_t rx_hfn_offset; // related to sn mismatch
 
   /*
    * SN of the last PDCP SDU delivered to upper layers

openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_entity.h

@@ -135,6 +135,16 @@ typedef struct rlc_am_entity_s {
   uint16_t           poll_pdu;           /*!< \brief This parameter is used by the transmitting side of each AM RLC entity to trigger a poll for every pollPDU PDUs. */
   uint32_t           poll_byte;          /*!< \brief This parameter is used by the transmitting side of each AM RLC entity to trigger a poll for every pollByte bytes. */
 
+  //----------------------------------------------------
+  // NB-IOT RLC Parameters
+  //----------------------------------------------------
+
+  //DL-AM-RLC Config NB-IoT parameter
+  uint32_t      *enableStatusReportSN_Gap_NB_IoT;
+  //UL-AM-RLC Config. NB-IoT parameter
+  uint16_t       max_retx_threshold_NB_IoT;
+  rlc_am_timer_t t_poll_retransmit_NB_IoT; //TIMER
+  
   //---------------------------------------------------------------------
   // STATISTICS
   //---------------------------------------------------------------------

openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_init.h

@@ -55,6 +55,14 @@ typedef volatile struct {
   uint32_t t_status_prohibit;   /*!< \brief t-StatusProhibit timer initial value. */
 } rlc_am_info_t;
 
+typedef volatile struct {
+//UL-AM-RLC Configurations
+uint16_t max_retx_threshold_NB_IoT;
+uint32_t t_poll_retransmit_NB_IoT;
+//DL-AM-RLC Configurations
+uint32_t* enableStatusReportSN_Gap_NB_IoT; /*OPTIONAL*/
+}rlc_am_info_NB_IoT_t;
+
 //-----------------------------------------------------------------------------
 /*! \fn void rlc_am_init   (const protocol_ctxt_t* const ctxtP, rlc_am_entity_t * const rlc_pP)
 * \brief    Initialize the RLC AM protocol instance, reset variables, allocate buffers, lists, then, the next step in order have a running RLC AM instance is to configure and set debug informations for this RLC instance.

openair2/LAYER2/RLC/rlc.h

@@ -36,6 +36,7 @@
 #    define __RLC_H__
 
 #    include "platform_types.h"
+#    include "platform_types_NB_IoT.h"
 #    include "platform_constants.h"
 #    include "hashtable.h"
 #    include "rlc_am.h"
@@ -62,6 +63,45 @@
 typedef uint64_t hash_key_t;
 #define HASHTABLE_NOT_A_KEY_VALUE ((uint64_t)-1)
 
+//-----------------------------------------------------------------------------
+#    ifdef RLC_MAC_C
+#        define private_rlc_mac(x) x
+#        define public_rlc_mac(x) x
+#    else
+#        define private_rlc_mac(x)
+#        define public_rlc_mac(x) extern x
+#    endif
+
+#    ifdef RLC_MPLS_C
+#        define private_rlc_mpls(x) x
+#        define public_rlc_mpls(x) x
+#    else
+#        define private_rlc_mpls(x)
+#        define public_rlc_mpls(x) extern x
+#    endif
+
+#    ifdef RLC_RRC_C
+#        define private_rlc_rrc(x) x
+#        define public_rlc_rrc(x) x
+#    else
+#        define private_rlc_rrc(x)
+#        define public_rlc_rrc(x) extern x
+#    endif
+
+#    ifdef RLC_C
+#        define private_rlc(x) x
+#        define protected_rlc(x) x
+#        define public_rlc(x) x
+#    else
+#        define private_rlc(x)
+#        if defined(RLC_MAC_C) || defined(RLC_MPLS_C) || defined(RLC_RRC_C) || defined(RLC_AM_C) || defined(RLC_TM_C) || defined(RLC_UM_C) || defined (PDCP_C)
+#            define protected_rlc(x) extern x
+#        else
+#            define protected_rlc(x)
+#        endif
+#        define public_rlc(x) extern x
+#    endif
+
 //-----------------------------------------------------------------------------
 #define  RLC_OP_STATUS_OK                1
 #define  RLC_OP_STATUS_BAD_PARAMETER     22
@@ -96,6 +136,7 @@ typedef volatile struct {
   rlc_mode_t             rlc_mode;
   union {
     rlc_am_info_t              rlc_am_info; /*!< \sa rlc_am.h. */
+    rlc_am_info_NB_IoT_t       rlc_am_info_NB_IoT; //integrate NB-IoT
     rlc_tm_info_t              rlc_tm_info; /*!< \sa rlc_tm.h. */
     rlc_um_info_t              rlc_um_info; /*!< \sa rlc_um.h. */
   } rlc;
@@ -160,6 +201,28 @@ typedef void (rrc_data_conf_cb_t)(
   const rlc_tx_status_t statusP);
 
 
+//------------------------------------------------
+// NB-IoT (may this stuff are no more used)
+//------------------------------------------------
+//pointer functions
+protected_rlc(void (*rlc_rrc_data_ind_NB_IoT)(
+                const protocol_ctxt_t* const ctxtP,
+                const rb_id_t     rb_idP,
+                const sdu_size_t  sdu_sizeP,
+                const uint8_t   * const sduP,
+        const srb1bis_flag_t srb1bis_flag);)
+
+typedef void (rrc_data_ind_cb_NB_IoT_t)(
+  const protocol_ctxt_t* const ctxtP,
+  const rb_id_t     rb_idP,
+  const sdu_size_t  sdu_sizeP,
+  const uint8_t   * const sduP,
+  const srb1bis_flag_t srb1bis_flag);
+
+
+//------------------------------------------------
+
+
 /*! \struct  rlc_t
 * \brief Structure to be instanciated to allocate memory for RLC protocol instances.
 */

openair2/PHY_INTERFACE/IF_Module_L2_primitives_NB_IoT.c

 #include "IF_Module_L2_primitives_NB_IoT.h"
 #include "LAYER2/MAC/proto_NB_IoT.h"
 #include "LAYER2/MAC/extern_NB_IoT.h"
+#include "openair2/LAYER2/MAC/vars_NB_IoT.h"
 
 int tmp = 0;
 //int block_rach = 0;
 int first_msg4 = 0;
+int rach_count = 0;
 
 void simulate_preamble(UL_IND_NB_IoT_t *UL_INFO, int CE, int sc)
 {
@@ -41,8 +43,8 @@ void enable_preamble_simulation(UL_IND_NB_IoT_t *UL_INFO,int i)
 
 void simulate_msg3(UL_IND_NB_IoT_t *UL_INFO)
 {
-	uint8_t *msg3 = NULL;
-	msg3 = (uint8_t *) malloc (11*sizeof(uint8_t));
+  uint8_t *msg3 = NULL;
+  msg3 = (uint8_t *) malloc (11*sizeof(uint8_t));
   msg3[0] = 0;
   msg3[1] = 58;
   msg3[2] = 42; // 2A
@@ -54,24 +56,24 @@ void simulate_msg3(UL_IND_NB_IoT_t *UL_INFO)
   msg3[8] = 64; // 40
   msg3[9] = 0;
   msg3[10] = 0;
-	UL_INFO->RX_NPUSCH.number_of_pdus = 1;
-	UL_INFO->module_id = 0;
-	UL_INFO->CC_id = 0;
-	UL_INFO->frame = 521;
-	UL_INFO->subframe = 1;
-	UL_INFO->RX_NPUSCH.rx_pdu_list = (nfapi_rx_indication_pdu_t * )malloc(sizeof(nfapi_rx_indication_pdu_t));
-	UL_INFO->RX_NPUSCH.rx_pdu_list->rx_ue_information.rnti = 0x0101;
-	UL_INFO->RX_NPUSCH.rx_pdu_list->data = msg3;
-	UL_INFO->RX_NPUSCH.rx_pdu_list->rx_indication_rel8.length = 11; 
+  UL_INFO->RX_NPUSCH.number_of_pdus = 1;
+  UL_INFO->module_id = 0;
+  UL_INFO->CC_id = 0;
+  UL_INFO->frame = 521;
+  UL_INFO->subframe = 1;
+  UL_INFO->RX_NPUSCH.rx_pdu_list = (nfapi_rx_indication_pdu_t * )malloc(sizeof(nfapi_rx_indication_pdu_t));
+  UL_INFO->RX_NPUSCH.rx_pdu_list->rx_ue_information.rnti = 0x0101;
+  UL_INFO->RX_NPUSCH.rx_pdu_list->data = msg3;
+  UL_INFO->RX_NPUSCH.rx_pdu_list->rx_indication_rel8.length = 11; 
 }
 void enable_msg3_simulation(UL_IND_NB_IoT_t *UL_INFO, int i)
 {
   if(i==1)
   {
-	if(UL_INFO->frame==521 && UL_INFO->subframe==1)
-	{
-		simulate_msg3(UL_INFO);
-	}
+  if(UL_INFO->frame==521 && UL_INFO->subframe==1)
+  {
+    simulate_msg3(UL_INFO);
+  }
   }
 }
 // Sched_INFO as a input for the scheduler
@@ -79,7 +81,6 @@ void UL_indication_NB_IoT(UL_IND_NB_IoT_t *UL_INFO)
 {
     int i=0;
     uint32_t abs_subframe;
-    Sched_Rsp_NB_IoT_t *SCHED_info = &mac_inst->Sched_INFO;
     UE_TEMPLATE_NB_IoT *ue_info = (UE_TEMPLATE_NB_IoT *)0;
     uint16_t tmp_rnti;
 
@@ -118,6 +119,22 @@ void UL_indication_NB_IoT(UL_IND_NB_IoT_t *UL_INFO)
                       );
           //block_rach = 2;
 
+        }else if (UE_state_machine == rach_for_next || UE_state_machine == rach_for_TAU)
+        {
+          //rach_count++;
+          //if (rach_count%3==0)
+          //{
+          LOG_N(MAC,"It is the third time that this UE try to rach\n");
+                    init_RA_NB_IoT(mac_inst,
+                      (UL_INFO->nrach_ind.nrach_pdu_list+i)->nrach_indication_rel13.initial_sc,
+                      (UL_INFO->nrach_ind.nrach_pdu_list+i)->nrach_indication_rel13.nrach_ce_level,
+                      UL_INFO->frame,
+                      //timing_offset = Timing_advance * 16
+                      (UL_INFO->nrach_ind.nrach_pdu_list+i)->nrach_indication_rel13.timing_advance*16
+                      );
+
+          UE_state_machine = rach_for_TAU;
+          //}
         }
       }
     }
@@ -138,7 +155,7 @@ void UL_indication_NB_IoT(UL_IND_NB_IoT_t *UL_INFO)
         }
       }
     }
-	 */
+   */
     // Check if there is any feed back of HARQ
     if(UL_INFO->nb_harq_ind.nb_harq_indication_body.number_of_harqs>0)
     {
@@ -152,7 +169,7 @@ void UL_indication_NB_IoT(UL_IND_NB_IoT_t *UL_INFO)
           ue_info->direction=0;
         }else
         {
-          LOG_I(MAC,"This UE get the response of HARQ DL : ACK, update the UL buffer for next message\n");
+          LOG_I(MAC,"This UE get the response of HARQ DL : ACK\n");
           ue_info->direction=-1;
           //ue_info->ul_total_buffer = 11;
           UE_state_machine = rach_for_auth_rsp;
@@ -178,6 +195,14 @@ void UL_indication_NB_IoT(UL_IND_NB_IoT_t *UL_INFO)
     {
       for(i=0;i<UL_INFO->RX_NPUSCH.number_of_pdus;i++)
       {
+        printf("The Receive MAC PDU:");
+        int x = 0;
+        for (x = 0; x < (UL_INFO->RX_NPUSCH.rx_pdu_list+i)->rx_indication_rel8.length; x ++)
+        {
+          printf("%02x ", (UL_INFO->RX_NPUSCH.rx_pdu_list+i)->data[x]);
+        }
+
+        printf("\n");
         //For MSG3, Normal Uplink Data, NAK
         rx_sdu_NB_IoT(UL_INFO->module_id,
                       UL_INFO->CC_id,
@@ -191,7 +216,7 @@ void UL_indication_NB_IoT(UL_IND_NB_IoT_t *UL_INFO)
       }
     }
 
-	  UL_INFO->RX_NPUSCH.number_of_pdus = 0;
+    UL_INFO->RX_NPUSCH.number_of_pdus = 0;
 
     if(UL_INFO->hypersfn==1 && UL_INFO->frame==0)
     {

openair2/PHY_INTERFACE/IF_Module_NB_IoT.c

 #include "openair2/PHY_INTERFACE/IF_Module_NB_IoT.h"
 #include "openair2/PHY_INTERFACE/IF_Module_L2_primitives_NB_IoT.h"
-#include "openair1/SCHED/IF_Module_L1_primitives_NB_IoT.h"
+#include "openair1/SCHED_NBIOT/IF_Module_L1_primitives_NB_IoT.h"
 #include "LAYER2/MAC/extern_NB_IoT.h"
 //#include "LAYER2/MAC/proto_NB_IoT.h"
 

openair2/RRC/NBIOT/defs_NB_IoT.h

@@ -18,7 +18,7 @@
  *      contact@openairinterface.org
  */
 
-/*! \file RRC/NBIOT/defs_NB_IoT.h
+/*! \file RRC/LITE/defs_NB_IoT.h
 * \brief NB-IoT RRC struct definitions and function prototypes
 * \author Navid Nikaein, Raymond Knopp and Michele Paffetti
 * \date 2010 - 2014, 2017
@@ -44,19 +44,19 @@
 #include "COMMON/platform_constants.h"
 #include "COMMON/platform_types.h"
 
-//#include "COMMON/mac_rrc_primitives.h"
+#include "COMMON/mac_rrc_primitives.h"
 //#include "LAYER2/MAC/defs.h"
 
 //#include "COMMON/openair_defs.h"
-//#ifndef USER_MODE
-//#include <rtai.h>
-//#endif
+// #ifndef USER_MODE
+// #include <rtai.h>
+// #endif
 
 
 //-----NB-IoT #include files-------
 
-//#include "SystemInformationBlockType1-NB.h"
-//#include "SystemInformation-NB.h"
+#include "LTE_SystemInformationBlockType1-NB.h"
+#include "LTE_SystemInformation-NB.h"
 #include "LTE_RRCConnectionReconfiguration-NB.h"
 #include "LTE_RRCConnectionReconfigurationComplete-NB.h"
 #include "LTE_RRCConnectionSetup-NB.h"
@@ -68,6 +68,8 @@
 #include "LTE_AS-Config-NB.h"
 #include "LTE_AS-Context-NB.h"
 #include "LTE_UE-Capability-NB-r13.h" //equivalent of UE-EUTRA-Capability.h
+#include "LTE_PhysCellId.h"
+#include "LTE_SRB-ToAddModList-NB-r13.h"
 //-------------------
 
 #if defined(ENABLE_ITTI)
@@ -255,19 +257,19 @@ typedef struct eNB_RRC_UE_NB_IoT_s {
    *
    * SRB_configList --> is used for the actual list of SRBs that is managed/that should be send over the RRC message
    * SRB_configList2--> refers to all the SRBs configured for that specific transaction identifier
-   * 					this because in a single transaction one or more SRBs could be established
-   * 					and you want to keep memory on what happen for every transaction
+   *          this because in a single transaction one or more SRBs could be established
+   *          and you want to keep memory on what happen for every transaction
    * Transaction ID (xid): is used to associate the proper RRC....Complete message received by the UE to the corresponding
-   * 					   message previously sent by the eNB (e.g. RRCConnectionSetup -- RRCConnectionSetupComplete)
-   * 					   this because it could happen that more messages are transmitted at the same time
+   *             message previously sent by the eNB (e.g. RRCConnectionSetup -- RRCConnectionSetupComplete)
+   *             this because it could happen that more messages are transmitted at the same time
    */
   LTE_SRB_ToAddModList_NB_r13_t*                SRB_configList;//for SRB1 and SRB1bis
   LTE_SRB_ToAddModList_NB_r13_t*                SRB_configList2[RRC_TRANSACTION_IDENTIFIER_NUMBER];
   LTE_DRB_ToAddModList_NB_r13_t*                DRB_configList; //for all the DRBs
   LTE_DRB_ToAddModList_NB_r13_t*                DRB_configList2[RRC_TRANSACTION_IDENTIFIER_NUMBER]; //for the configured DRBs of a xid
-  uint8_t                            		DRB_active[2];//in LTE was 8 --> at most 2 for NB-IoT
+  uint8_t                               DRB_active[2];//in LTE was 8 --> at most 2 for NB-IoT
 
-  struct LTE_PhysicalConfigDedicated_NB_r13*    physicalConfigDedicated_NB_IoT;
+  struct PhysicalConfigDedicated_NB_r13*    physicalConfigDedicated_NB_IoT;
   LTE_MAC_MainConfig_NB_r13_t*           mac_MainConfig_NB_IoT;
 
   //No SPS(semi-persistent scheduling) in NB-IoT
@@ -357,13 +359,13 @@ typedef struct rrc_eNB_ue_context_NB_IoT_s {
 typedef struct {
 
   // buffer that contains the encoded messages
-  uint8_t							*MIB_NB_IoT;
-  uint8_t							sizeof_MIB_NB_IoT;
+  uint8_t             *MIB_NB_IoT;
+  uint8_t             sizeof_MIB_NB_IoT;
 
   uint8_t                           *SIB1_NB_IoT;
   uint8_t                           sizeof_SIB1_NB_IoT;
-  uint8_t                         	*SIB23_NB_IoT;
-  uint8_t                        	sizeof_SIB23_NB_IoT;
+  uint8_t                           *SIB23_NB_IoT;
+  uint8_t                         sizeof_SIB23_NB_IoT;
 
 
   //not actually implemented in OAI
@@ -386,9 +388,9 @@ typedef struct {
 
   //implicit parameters needed
   int                               Ncp; //cyclic prefix for DL
-  int								Ncp_UL; //cyclic prefix for UL
+  int               Ncp_UL; //cyclic prefix for UL
   int                               p_eNB; //number of tx antenna port
-  int								p_rx_eNB; //number of receiving antenna ports
+  int               p_rx_eNB; //number of receiving antenna ports
   uint32_t                          dl_CarrierFreq; //detected by the UE
   uint32_t                          ul_CarrierFreq; //detected by the UE
   uint16_t                          physCellId; //not stored in the MIB-NB but is getting through NPSS/NSSS
@@ -398,12 +400,12 @@ typedef struct {
   LTE_BCCH_DL_SCH_Message_NB_t             siblock1_NB_IoT; //SIB1-NB
   LTE_BCCH_DL_SCH_Message_NB_t             systemInformation_NB_IoT; //SI
 
-  LTE_SystemInformationBlockType1_NB_t     		*sib1_NB_IoT;
-  LTE_SystemInformationBlockType2_NB_r13_t   	*sib2_NB_IoT;
-  LTE_SystemInformationBlockType3_NB_r13_t   	*sib3_NB_IoT;
+  LTE_SystemInformationBlockType1_NB_t        *sib1_NB_IoT;
+  LTE_SystemInformationBlockType2_NB_r13_t    *sib2_NB_IoT;
+  LTE_SystemInformationBlockType3_NB_r13_t    *sib3_NB_IoT;
   //not implemented yet
-  LTE_SystemInformationBlockType4_NB_r13_t    	*sib4_NB_IoT;
-  LTE_SystemInformationBlockType5_NB_r13_t     	*sib5_NB_IoT;
+  LTE_SystemInformationBlockType4_NB_r13_t      *sib4_NB_IoT;
+  LTE_SystemInformationBlockType5_NB_r13_t      *sib5_NB_IoT;
   LTE_SystemInformationBlockType14_NB_r13_t     *sib14_NB_IoT;
   LTE_SystemInformationBlockType16_NB_r13_t     *sib16_NB_IoT;
 
@@ -419,9 +421,9 @@ typedef struct {
   SystemInformationBlockType20_NB_r14_t     *sib20;
   SystemInformationBlockType22_NB_r14_t     *sib22;
 
-  uint8_t							SCPTM_flag;
-  uint8_t							sizeof_SC_MCHH_MESS[];
-  SC_MCCH_Message_NB_t				scptm;*/
+  uint8_t             SCPTM_flag;
+  uint8_t             sizeof_SC_MCHH_MESS[];
+  SC_MCCH_Message_NB_t        scptm;*/
 
 
 } rrc_eNB_carrier_data_NB_IoT_t;
@@ -443,7 +445,7 @@ typedef struct eNB_RRC_INST_NB_IoT_s {
   hash_table_t                      *s1ap_id2_s1ap_ids   ; // key is    content is rrc_ue_s1ap_ids_t
 
   //RRC configuration
-  NbIoTRrcConfigurationReq configuration; //rrc_messages_types.h
+  RrcConfigurationReq configuration; //rrc_messages_types.h
 
   // other PLMN parameters
   /// Mobile country code
@@ -476,7 +478,7 @@ typedef struct OAI_UECapability_NB_IoT_s {
 
 #define RRC_BUFFER_SIZE_MAX_NB_IoT 1024
 
-#if 0
+
 
 typedef struct UE_RRC_INST_NB_IoT_s {
   Rrc_State_NB_IoT_t     RrcState;
@@ -571,7 +573,7 @@ typedef struct UE_RRC_INST_NB_IoT_s {
   */
 } UE_RRC_INST_NB_IoT;
 
-#endif
+
 #include "proto_NB_IoT.h" //should be put here otherwise compilation error
 
 #endif

openair2/RRC/NBIOT/vars_NB_IoT.h

@@ -42,7 +42,7 @@
 //------------------------------------------------------------------------
 
 
-//UE_RRC_INST_NB_IoT *UE_rrc_inst_NB_IoT; //MP: may not used for the moment
+UE_RRC_INST_NB_IoT *UE_rrc_inst_NB_IoT; //MP: may not used for the moment
 #ifndef USER_MODE
 
 #ifndef NO_RRM

openair2/UTIL/LOG/log.h

+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+/*! \file log.h
+* \brief openair log generator (OLG) for
+* \author Navid Nikaein
+* \date 2009 - 2014
+* \version 0.5
+* @ingroup util
+
+*/
+
+#ifndef __LOG_H__
+#    define __LOG_H__
+
+/*--- INCLUDES ---------------------------------------------------------------*/
+#ifdef USER_MODE
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <syslog.h>
+#include <assert.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stdarg.h>
+#include <time.h>
+#include <stdint.h>
+#ifndef __STDC_FORMAT_MACROS
+#define __STDC_FORMAT_MACROS
+#endif
+#include <inttypes.h>
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+#include <pthread.h>
+#else
+#include "rtai_fifos.h"
+#endif
+
+/*----------------------------------------------------------------------------*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** @defgroup _LOG LOG Generator
+ * @{*/
+/* @}*/
+
+/** @defgroup _macro Macro Definition
+ *  @ingroup _LOG
+ *  @brief these macros are used in the code of LOG
+ * @{*/
+/* @}*/
+
+/** @defgroup _max_length Maximum Length of LOG
+ *  @ingroup _macro
+ *  @brief the macros that describe the maximum length of LOG
+ * @{*/
+#define MAX_LOG_ITEM 100 /*!< \brief the maximum length of a LOG item, what is LOG_ITEM ??? */
+#define MAX_LOG_INFO 1000 /*!< \brief the maximum length of a log */
+#define MAX_LOG_TOTAL 1500 /*!< \brief the maximum length of a log */
+/* @}*/
+
+/** @defgroup _log_level Message levels defined by LOG
+ *  @ingroup _macro
+ *  @brief LOG defines 9 levels of messages for users. Importance of these levels decrease gradually from 0 to 8
+ * @{*/
+# define  LOG_EMERG 0 /*!< \brief system is unusable */
+# define  LOG_ALERT 1 /*!< \brief action must be taken immediately */
+# define  LOG_CRIT  2 /*!< \brief critical conditions */
+# define  LOG_ERR   3 /*!< \brief error conditions */
+# define  LOG_WARNING 4 /*!< \brief warning conditions */
+# define  LOG_NOTICE  5 /*!< \brief normal but significant condition */
+# define  LOG_INFO  6 /*!< \brief informational */
+# define  LOG_DEBUG 7 /*!< \brief debug-level messages */
+# define  LOG_FILE        8 /*!< \brief message sequence chart -level  */
+# define  LOG_TRACE 9 /*!< \brief trace-level messages */
+#define NUM_LOG_LEVEL  10 /*!< \brief the number of message levels users have with LOG */
+/* @}*/
+
+
+/** @defgroup _log_format Defined log format
+ *  @ingroup _macro
+ *  @brief Macro of log formats defined by LOG
+ * @{*/
+
+/* .log_format = 0x13 uncolored standard messages
+ * .log_format = 0x93 colored standard messages */
+
+#define LOG_RED "\033[1;31m"  /*!< \brief VT100 sequence for bold red foreground */
+#define LOG_GREEN "\033[32m"  /*!< \brief VT100 sequence for green foreground */
+#define LOG_ORANGE "\033[93m"   /*!< \brief VT100 sequence for orange foreground */
+#define LOG_BLUE "\033[34m" /*!< \brief VT100 sequence for blue foreground */
+#define LOG_CYBL "\033[40;36m"  /*!< \brief VT100 sequence for cyan foreground on black background */
+#define LOG_RESET "\033[0m" /*!< \brief VT100 sequence for reset (black) foreground */
+/* @}*/
+
+
+/** @defgroup _syslog_conf Macros for write in syslog.conf
+ *  @ingroup _macro
+ *  @brief Macros used to write lines (local/remote) in syslog.conf
+ * @{*/
+#define LOG_LOCAL      0x01
+#define LOG_REMOTE     0x02
+
+#define FLAG_COLOR     0x001  /*!< \brief defaults */
+#define FLAG_PID       0x002  /*!< \brief defaults */
+#define FLAG_COMP      0x004
+#define FLAG_THREAD    0x008  /*!< \brief all : 255/511 */
+#define FLAG_LEVEL     0x010
+#define FLAG_FUNCT     0x020
+#define FLAG_FILE_LINE 0x040
+#define FLAG_TIME      0x100
+
+#define LOG_NONE        0x00
+#define LOG_LOW         0x5
+#define LOG_MED         0x15
+#define LOG_HIGH        0x35
+#define LOG_FULL        0x75
+
+#define OAI_OK 0    /*!< \brief all ok */
+#define OAI_ERR 1   /*!< \brief generic error */
+#define OAI_ERR_READ_ONLY 2 /*!< \brief tried to write to read-only item */
+#define OAI_ERR_NOTFOUND 3  /*!< \brief something wasn't found */
+/* @}*/
+
+
+//static char *log_level_highlight_start[] = {LOG_RED, LOG_RED, LOG_RED, LOG_RED, LOG_BLUE, "", "", "", LOG_GREEN}; /*!< \brief Optional start-format strings for highlighting */
+
+//static char *log_level_highlight_end[]   = {LOG_RESET, LOG_RESET, LOG_RESET, LOG_RESET, LOG_RESET, "", "", "", LOG_RESET};  /*!< \brief Optional end-format strings for highlighting */
+
+typedef enum {
+    MIN_LOG_COMPONENTS = 0,
+    PHY = MIN_LOG_COMPONENTS,
+    MAC,
+    EMU,
+    OCG,
+    OMG,
+    OPT,
+    OTG,
+    OTG_LATENCY,
+    OTG_LATENCY_BG,
+    OTG_GP,
+    OTG_GP_BG,
+    OTG_JITTER,
+    RLC,
+    PDCP,
+    RRC,
+    NAS,
+    PERF,
+    OIP,
+    CLI,
+    MSC,
+    OCM,
+    UDP_,
+    GTPU,
+    SPGW,
+    S1AP,
+    SCTP,
+    HW,
+    OSA,
+    RAL_ENB,
+    RAL_UE,
+    ENB_APP,
+    FLEXRAN_AGENT,
+    TMR,
+    USIM,
+    LOCALIZE,
+    RRH,
+    X2AP,
+    MAX_LOG_COMPONENTS,
+}
+comp_name_t;
+
+//#define msg printf
+
+typedef struct {
+    char *name; /*!< \brief string name of item */
+    int value;  /*!< \brief integer value of mapping */
+} mapping;
+
+
+typedef struct  {
+    const char *name;
+    int         level;
+    int         flag;
+    int         interval;
+    int         fd;
+    int         filelog;
+    char       *filelog_name;
+
+    /* SR: make the log buffer component relative */
+    char        log_buffer[MAX_LOG_TOTAL];
+} log_component_t;
+
+typedef struct  {
+    unsigned int remote_ip;
+    unsigned int audit_ip;
+    int  remote_level;
+    int  facility;
+    int  audit_facility;
+    int  format;
+} log_config_t;
+
+
+typedef struct {
+    log_component_t         log_component[MAX_LOG_COMPONENTS];
+    log_config_t            config;
+    char*                   level2string[NUM_LOG_LEVEL];
+    int                     level;
+    int                     onlinelog;
+    int                     flag;
+    int                     syslog;
+    int                     filelog;
+    char*                   filelog_name;
+} log_t;
+
+typedef struct LOG_params {
+    const char *file;
+    const char *func;
+    int line;
+    int comp;
+    int level;
+    const char *format;
+    char l_buff_info [MAX_LOG_INFO];
+    int len;
+} LOG_params;
+
+#if defined(ENABLE_ITTI)
+typedef enum log_instance_type_e {
+    LOG_INSTANCE_UNKNOWN,
+    LOG_INSTANCE_ENB,
+    LOG_INSTANCE_UE,
+} log_instance_type_t;
+
+void log_set_instance_type (log_instance_type_t instance);
+#endif
+
+
+/*--- INCLUDES ---------------------------------------------------------------*/
+#    include "log_if.h"
+/*----------------------------------------------------------------------------*/
+int  logInit (void);
+void logRecord_mt(const char *file, const char *func, int line,int comp, int level, const char *format, ...) __attribute__ ((format (printf, 6, 7)));
+void logRecord(const char *file, const char *func, int line,int comp, int level, const char *format, ...) __attribute__ ((format (printf, 6, 7)));
+int  set_comp_log(int component, int level, int verbosity, int interval);
+int  set_log(int component, int level, int interval);
+void set_glog(int level, int verbosity);
+void set_log_syslog(int enable);
+void set_log_onlinelog(int enable);
+void set_log_filelog(int enable);
+void set_component_filelog(int comp);
+int  map_str_to_int(mapping *map, const char *str);
+char *map_int_to_str(mapping *map, int val);
+void logClean (void);
+int  is_newline( char *str, int size);
+void *log_thread_function(void * list);
+
+/** @defgroup _logIt logIt function
+ *  @ingroup _macro
+ *  @brief Macro used to call tr_log_full_ex with file, function and line information
+ * @{*/
+#ifdef USER_MODE
+//#define logIt(component, level, format, args...) do {logRecord(__FILE__, __FUNCTION__, __LINE__, component, level, format, ##args);} while(0);
+#ifdef LOG_NO_THREAD
+#define logIt(component, level, format, args...) logRecord_mt(__FILE__, __FUNCTION__, __LINE__, component, level, format, ##args)
+#else //default
+#define logIt(component, level, format, args...) logRecord(__FILE__, __FUNCTION__, __LINE__, component, level, format, ##args)
+#endif
+#else
+#ifdef LOG_NO_THREAD
+#define logIt(component, level, format, args...) logRecord_mt(NULL, __FUNCTION__, __LINE__, component, level, format, ##args)
+#else // default
+#define logIt(component, level, format, args...) logRecord(NULL, __FUNCTION__, __LINE__, component, level, format, ##args)
+#endif
+#endif
+/* @}*/
+
+
+/** @defgroup _debugging debugging macros
+ *  @ingroup _macro
+ *  @brief Macro used to call logIt function with different message levels
+ * @{*/
+
+// debugging macros
+#ifdef USER_MODE
+#  if T_TRACER
+#    include "T.h"
+#    define LOG_I(c, x...) T(T_LEGACY_ ## c ## _INFO, T_PRINTF(x))
+#    define LOG_W(c, x...) T(T_LEGACY_ ## c ## _WARNING, T_PRINTF(x))
+#    define LOG_E(c, x...) T(T_LEGACY_ ## c ## _ERROR, T_PRINTF(x))
+#    define LOG_D(c, x...) T(T_LEGACY_ ## c ## _DEBUG, T_PRINTF(x))
+#    define LOG_T(c, x...) T(T_LEGACY_ ## c ## _TRACE, T_PRINTF(x))
+#    define LOG_G(c, x...) /* */
+#    define LOG_A(c, x...) /* */
+#    define LOG_C(c, x...) /* */
+#    define LOG_N(c, x...) /* */
+#    define LOG_F(c, x...) /* */
+#  else /* T_TRACER */
+#    if DISABLE_LOG_X
+#        define LOG_I(c, x...) /* */
+#        define LOG_W(c, x...) /* */
+#        define LOG_E(c, x...) /* */
+#        define LOG_D(c, x...) /* */
+#        define LOG_T(c, x...) /* */
+#        define LOG_G(c, x...) /* */
+#        define LOG_A(c, x...) /* */
+#        define LOG_C(c, x...) /* */
+#        define LOG_N(c, x...) /* */
+#        define LOG_F(c, x...) /* */
+#    else  /*DISABLE_LOG_X*/
+#        define LOG_G(c, x...) logIt(c, LOG_EMERG, x)
+#        define LOG_A(c, x...) logIt(c, LOG_ALERT, x)
+#        define LOG_C(c, x...) logIt(c, LOG_CRIT,  x)
+#        define LOG_E(c, x...) logIt(c, LOG_ERR, x)
+#        define LOG_W(c, x...) logIt(c, LOG_WARNING, x)
+#        define LOG_N(c, x...) logIt(c, LOG_NOTICE, x)
+#        define LOG_I(c, x...) logIt(c, LOG_INFO, x)
+#        define LOG_D(c, x...) logIt(c, LOG_DEBUG, x)
+#        define LOG_F(c, x...) logIt(c, LOG_FILE, x)  // log to a file, useful for the MSC chart generation
+#        define LOG_T(c, x...) logIt(c, LOG_TRACE, x)
+#    endif /*DISABLE_LOG_X*/
+#  endif /* T_TRACER */
+#else /* USER_MODE */
+#  define LOG_G(c, x...) printk(x)
+#  define LOG_A(c, x...) printk(x)
+#  define LOG_C(c, x...) printk(x)
+#  define LOG_E(c, x...) printk(x)
+#  define LOG_W(c, x...) printk(x)
+#  define LOG_N(c, x...) printk(x)
+#  define LOG_I(c, x...) printk(x)
+#  define LOG_D(c, x...) printk(x)
+#  define LOG_T(c, x...) printk(x)
+#endif
+/* @}*/
+
+
+/** @defgroup _useful_functions useful functions in LOG
+ *  @ingroup _macro
+ *  @brief Macro of some useful functions defined by LOG
+ * @{*/
+#define LOG_ENTER(c) do {LOG_T(c, "Entering\n");}while(0) /*!< \brief Macro to log a message with severity DEBUG when entering a function */
+#define LOG_EXIT(c) do {LOG_T(c,"Exiting\n"); return;}while(0)  /*!< \brief Macro to log a message with severity TRACE when exiting a function */
+#define LOG_RETURN(c,x) do {uint32_t __rv;__rv=(unsigned int)(x);LOG_T(c,"Returning %08x\n", __rv);return((typeof(x))__rv);}while(0)  /*!< \brief Macro to log a function exit, including integer value, then to return a value to the calling function */
+/* @}*/
+
+static __inline__ uint64_t rdtsc(void) {
+  uint64_t a, d;
+  __asm__ volatile ("rdtsc" : "=a" (a), "=d" (d));
+  return (d<<32) | a;
+}
+
+#define DEBUG_REALTIME 1
+#if DEBUG_REALTIME
+
+extern double cpuf;
+
+static inline uint64_t checkTCPU(int timeout, char * file, int line) {
+    static uint64_t __thread lastCPUTime=0;
+    static uint64_t __thread last=0;
+    uint64_t cur=rdtsc();
+    struct timespec CPUt;
+    clock_gettime(CLOCK_THREAD_CPUTIME_ID, &CPUt);
+    uint64_t CPUTime=CPUt.tv_sec*1000*1000+CPUt.tv_nsec/1000;
+    double microCycles=(double)(cpuf*1000);
+    int duration=(int)((cur-last)/microCycles);
+    if ( last!=0 && duration > timeout ) {
+      //struct timespec ts;
+      //clock_gettime(CLOCK_MONOTONIC, &ts);
+      printf("%s:%d lte-ue delay %d (exceed %d), CPU for this period: %lld\n", file, line,
+               duration, timeout, (long long)CPUTime-lastCPUTime );
+    }
+    last=cur;
+    lastCPUTime=CPUTime;
+    return cur;
+}
+
+static inline unsigned long long checkT(int timeout, char * file, int line) {
+    static unsigned long long __thread last=0;
+    unsigned long long cur=rdtsc();
+    int microCycles=(int)(cpuf*1000);
+    int duration=(int)((cur-last)/microCycles);
+    if ( last!=0 && duration > timeout )
+        printf("%s:%d lte-ue delay %d (exceed %d)\n", file, line,
+               duration, timeout);
+    last=cur;
+    return cur;
+}
+
+typedef struct m {
+    uint64_t iterations;
+    uint64_t sum;
+    uint64_t maxArray[11];
+} Meas;
+
+static inline void printMeas(char * txt, Meas *M, int period) {
+    if (M->iterations%period == 0 ) {
+        char txt2[512];
+        sprintf(txt2,"%s avg=%" PRIu64 " iterations=%" PRIu64 " max=%" 
+                PRIu64 ":%" PRIu64 ":%" PRIu64 ":%" PRIu64 ":%" PRIu64 ":%" PRIu64 ":%" PRIu64 ":%" PRIu64 ":%" PRIu64 ":%" PRIu64 "\n",
+                txt,
+                M->sum/M->iterations,
+                M->iterations,
+                M->maxArray[1],M->maxArray[2], M->maxArray[3],M->maxArray[4], M->maxArray[5], 
+                M->maxArray[6],M->maxArray[7], M->maxArray[8],M->maxArray[9],M->maxArray[10]);
+#if DISABLE_LOG_X
+        printf("%s",txt2);
+#else
+        LOG_W(PHY, "%s",txt2);
+#endif
+    }
+}
+
+static inline int cmpint(const void* a, const void* b) {
+    uint64_t* aa=(uint64_t*)a;
+    uint64_t* bb=(uint64_t*)b;
+    return (int)(*aa-*bb);
+}
+
+static inline void updateTimes(uint64_t start, Meas *M, int period, char * txt) {
+    if (start!=0) {
+        uint64_t end=rdtsc();
+        long long diff=(end-start)/(cpuf*1000);
+        M->maxArray[0]=diff;
+        M->sum+=diff;
+        M->iterations++;
+        qsort(M->maxArray, 11, sizeof(uint64_t), cmpint);
+        printMeas(txt,M,period);
+    }
+}
+
+#define check(a) do { checkT(a,__FILE__,__LINE__); } while (0)
+#define checkcpu(a) do { checkTCPU(a,__FILE__,__LINE__); } while (0)
+#define initRefTimes(a) static __thread Meas a= {0}
+#define pickTime(a) uint64_t a=rdtsc()
+#define readTime(a) a
+#define initStaticTime(a) static __thread uint64_t a={0}
+#define pickStaticTime(a) do { a=rdtsc(); } while (0)
+
+#else
+#define check(a) do {} while (0)
+#define checkcpu(a) do {} while (0)
+#define initRefTimes(a) do {} while (0)
+#define initStaticTime(a) do {} while (0)
+#define pickTime(a) do {} while (0)
+#define readTime(a) 0
+#define pickStaticTime(a) do {} while (0)
+#define updateTimes(a,b,c,d) do {} while (0)
+#define printMeas(a,b,c) do {} while (0)
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+

openair2/UTIL/LOG/vcd_signal_dumper.h

+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+/*! \file vcd_signal_dumper.h
+ * \brief Output functions call to VCD file which is readable by gtkwave.
+ * \author ROUX Sebastien
+ * \author S. Roux
+ * \maintainer: navid nikaein
+ * \date 2012 - 2104
+ * \version 0.1
+ * \company Eurecom
+ * \email: navid.nikaein@eurecom.fr
+ * \note
+ * \warning
+ */
+
+#ifndef VCD_SIGNAL_DUMPER_H_
+#define VCD_SIGNAL_DUMPER_H_
+
+//#define ENABLE_USE_CPU_EXECUTION_TIME
+
+/* WARNING: if you edit the enums below, update also string definitions in vcd_signal_dumper.c */
+typedef enum {
+  VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_TX0_ENB = 0,
+  VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_TX1_ENB,
+  VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_RX0_ENB,
+  VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_RX1_ENB,
+  VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_TX0_ENB,
+  VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_TX1_ENB,
+  VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_RX0_ENB,
+  VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_RX1_ENB,
+  VCD_SIGNAL_DUMPER_VARIABLES_RUNTIME_TX_ENB,
+  VCD_SIGNAL_DUMPER_VARIABLES_RUNTIME_RX_ENB,
+  VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_TX0_UE,
+  VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_TX1_UE,
+  VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_RX0_UE,
+  VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_RX1_UE,
+  VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_TX0_UE,
+  VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_TX1_UE,
+  VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_RX0_UE,
+  VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_RX1_UE,
+  VCD_SIGNAL_DUMPER_VARIABLES_MISSED_SLOTS_ENB,
+  VCD_SIGNAL_DUMPER_VARIABLES_DAQ_MBOX,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE_OFFSET_MBOX,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE_RX_OFFSET,
+  VCD_SIGNAL_DUMPER_VARIABLES_DIFF,
+  VCD_SIGNAL_DUMPER_VARIABLES_HW_SUBFRAME,
+  VCD_SIGNAL_DUMPER_VARIABLES_HW_FRAME,
+  VCD_SIGNAL_DUMPER_VARIABLES_HW_SUBFRAME_RX,
+  VCD_SIGNAL_DUMPER_VARIABLES_HW_FRAME_RX,
+  VCD_SIGNAL_DUMPER_VARIABLES_TXCNT,
+  VCD_SIGNAL_DUMPER_VARIABLES_RXCNT,
+  VCD_SIGNAL_DUMPER_VARIABLES_TRX_TS,
+  VCD_SIGNAL_DUMPER_VARIABLES_TRX_TST,
+  VCD_SIGNAL_DUMPER_VARIABLES_TRX_WRITE_FLAGS,
+  VCD_SIGNAL_DUMPER_VARIABLES_TX_TS,
+  VCD_SIGNAL_DUMPER_VARIABLES_RX_TS,
+  VCD_SIGNAL_DUMPER_VARIABLES_RX_HWCNT,
+  VCD_SIGNAL_DUMPER_VARIABLES_RX_LHWCNT,
+  VCD_SIGNAL_DUMPER_VARIABLES_TX_HWCNT,
+  VCD_SIGNAL_DUMPER_VARIABLES_TX_LHWCNT,
+  VCD_SIGNAL_DUMPER_VARIABLES_RX_PCK,
+  VCD_SIGNAL_DUMPER_VARIABLES_TX_PCK,
+  VCD_SIGNAL_DUMPER_VARIABLES_RX_SEQ_NUM,
+  VCD_SIGNAL_DUMPER_VARIABLES_RX_SEQ_NUM_PRV,
+  VCD_SIGNAL_DUMPER_VARIABLES_TX_SEQ_NUM,
+  VCD_SIGNAL_DUMPER_VARIABLES_CNT,
+  VCD_SIGNAL_DUMPER_VARIABLES_DUMMY_DUMP,
+  VCD_SIGNAL_DUMPER_VARIABLE_ITTI_SEND_MSG,
+  VCD_SIGNAL_DUMPER_VARIABLE_ITTI_POLL_MSG,
+  VCD_SIGNAL_DUMPER_VARIABLE_ITTI_RECV_MSG,
+  VCD_SIGNAL_DUMPER_VARIABLE_ITTI_ALLOC_MSG,
+  VCD_SIGNAL_DUMPER_VARIABLE_MP_ALLOC,
+  VCD_SIGNAL_DUMPER_VARIABLE_MP_FREE,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE_INST_CNT_RX,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE_INST_CNT_TX,
+  VCD_SIGNAL_DUMPER_VARIABLES_DCI_INFO,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_BSR,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_BO,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_SCHEDULED,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_TIMING_ADVANCE,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_SR_ENERGY,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_SR_THRES,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_RSSI0,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_RSSI1,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_RSSI2,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_RSSI3,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_RSSI4,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_RSSI5,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_RSSI6,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_RSSI7,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_RES0,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_RES1,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_RES2,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_RES3,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_RES4,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_RES5,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_RES6,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_RES7,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_MCS0,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_MCS1,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_MCS2,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_MCS3,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_MCS4,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_MCS5,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_MCS6,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_MCS7,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_RB0,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_RB1,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_RB2,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_RB3,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_RB4,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_RB5,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_RB6,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_RB7,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_ROUND0,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_ROUND1,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_ROUND2,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_ROUND3,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_ROUND4,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_ROUND5,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_ROUND6,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_ROUND7,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_SFN0,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_SFN1,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_SFN2,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_SFN3,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_SFN4,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_SFN5,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_SFN6,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_SFN7,
+  VCD_SIGNAL_DUMPER_VARIABLES_SEND_IF4_SYMBOL,
+  VCD_SIGNAL_DUMPER_VARIABLES_RECV_IF4_SYMBOL,
+  VCD_SIGNAL_DUMPER_VARIABLES_SEND_IF5_PKT_ID,  
+  VCD_SIGNAL_DUMPER_VARIABLES_RECV_IF5_PKT_ID,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE_PDCP_FLUSH_SIZE,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE_PDCP_FLUSH_ERR,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_TRX_READ_NS,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_TRX_WRITE_NS,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_TRX_READ_NS_MISSING,
+  VCD_SIGNAL_DUMPER_VARIABLES_UE0_TRX_WRITE_NS_MISSING,
+  VCD_SIGNAL_DUMPER_VARIABLES_LAST,
+  VCD_SIGNAL_DUMPER_VARIABLES_END = VCD_SIGNAL_DUMPER_VARIABLES_LAST,
+} vcd_signal_dump_variables;
+
+typedef enum {
+  /* softmodem signals  */
+  VCD_SIGNAL_DUMPER_FUNCTIONS_RT_SLEEP=0,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_READ,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_READ_IF,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE_IF,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_eNB_PROC_RXTX0,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_eNB_PROC_RXTX1,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_THREAD_SYNCH,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_THREAD_RXTX0,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_THREAD_RXTX1,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_READ_SF9,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE_SF9,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SIGNAL_COND_RXTX0,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SIGNAL_COND_RXTX1,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_WAIT_COND_RXTX0,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_WAIT_COND_RXTX1,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_LOCK_MUTEX_RXTX_FOR_COND_WAIT0,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_LOCK_MUTEX_RXTX_FOR_COND_WAIT1,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_LOCK_MUTEX_RXTX_FOR_CNT_DECREMENT0,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_LOCK_MUTEX_RXTX_FOR_CNT_DECREMENT1,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_LOCK_MUTEX_RXTX_FOR_CNT_INCREMENT0,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_LOCK_MUTEX_RXTX_FOR_CNT_INCREMENT1,
+
+  /* RRH signals  */ 
+  VCD_SIGNAL_DUMPER_FUNCTIONS_eNB_TX,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_eNB_RX,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_eNB_TRX,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_eNB_TM,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_eNB_RX_SLEEP,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_eNB_TX_SLEEP,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_eNB_PROC_SLEEP,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_READ_RF,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE_RF,
+
+  /* PHY signals  */
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SYNCH,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SLOT_FEP,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_RRC_MEASUREMENTS,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_GAIN_CONTROL,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_ADJUST_SYNCH,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_MEASUREMENT_PROCEDURES,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_PDCCH_PROCEDURES,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_PBCH_PROCEDURES,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_ENB_TX,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_ENB_TX1,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_ENB_RX_COMMON,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_ENB_RX_COMMON1,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_ENB_RX_UESPEC,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_ENB_RX_UESPEC1,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_SLOT_FEP,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_UE_TX,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_UE_RX,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_UE_TX_ULSCH_UESPEC,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_UE_TX_PUCCH,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_UE_TX_ULSCH_COMMON,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_UE_TX_PRACH,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_UE_TX_ULSCH_RAR,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_ENB_LTE,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_UE_LTE,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PDSCH_THREAD,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_DLSCH_THREAD0,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_DLSCH_THREAD1,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_DLSCH_THREAD2,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_DLSCH_THREAD3,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_DLSCH_THREAD4,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_DLSCH_THREAD5,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_DLSCH_THREAD6,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_DLSCH_THREAD7,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_DLSCH_DECODING0,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_DLSCH_DECODING1,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_DLSCH_DECODING2,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_DLSCH_DECODING3,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_DLSCH_DECODING4,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_DLSCH_DECODING5,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_DLSCH_DECODING6,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_DLSCH_DECODING7,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_RX_PDCCH,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_DCI_DECODING,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_RX_PHICH,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PDSCH_PROC,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PDSCH_PROC_SI,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PDSCH_PROC_P,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PDSCH_PROC_RA,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_UE_CONFIG_SIB2,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_CONFIG_SIB1_ENB,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_CONFIG_SIB2_ENB,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_CONFIG_DEDICATED_ENB,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_UE_COMPUTE_PRACH,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_ENB_ULSCH_MSG3,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_ENB_ULSCH_DECODING0,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_ENB_ULSCH_DECODING1,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_ENB_ULSCH_DECODING2,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_ENB_ULSCH_DECODING3,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_ENB_ULSCH_DECODING4,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_ENB_ULSCH_DECODING5,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_ENB_ULSCH_DECODING6,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_ENB_ULSCH_DECODING7,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_ENB_SFGEN,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_ENB_PRACH_RX,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_ENB_PDCCH_TX,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_ENB_RS_TX,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_GENERATE_PRACH,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_ULSCH_MODULATION,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_ULSCH_ENCODING,
+#if 1 // add for debugging losing PDSCH immediately before and after reporting CQI
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_ULSCH_ENCODING_FILL_CQI,
+#endif
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_ULSCH_SCRAMBLING,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_DLSCH_MODULATION,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_DLSCH_ENCODING,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_DLSCH_ENCODING_W,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_DLSCH_SCRAMBLING,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_BEAM_PRECODING,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_OFDM_MODULATION,
+
+  /* MAC signals  */
+  VCD_SIGNAL_DUMPER_FUNCTIONS_MACPHY_INIT,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_MACPHY_EXIT,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_DLSCH_ULSCH_SCHEDULER,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_FILL_RAR,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_TERMINATE_RA_PROC,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_INITIATE_RA_PROC,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_CANCEL_RA_PROC,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_GET_DCI_SDU,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_GET_DLSCH_SDU,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_RX_SDU,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_MRBCH_PHY_SYNC_FAILURE,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_SR_INDICATION,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_DLSCH_PREPROCESSOR,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_SCHEDULE_DLSCH, // schedule_ue_spec
+  VCD_SIGNAL_DUMPER_FUNCTIONS_FILL_DLSCH_DCI,
+
+  VCD_SIGNAL_DUMPER_FUNCTIONS_OUT_OF_SYNC_IND,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_DECODE_SI,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_DECODE_PCCH,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_DECODE_CCCH,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_DECODE_BCCH,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SEND_SDU,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_GET_SDU,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_GET_RACH,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_PROCESS_RAR,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SCHEDULER,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_GET_SR,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SEND_MCH_SDU,
+
+  /* RLC signals  */
+  VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,
+  // VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_IND,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_MAC_RLC_STATUS_IND,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_MAC_RLC_DATA_REQ,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_MAC_RLC_DATA_IND,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_UM_TRY_REASSEMBLY,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_UM_CHECK_TIMER_DAR_TIME_OUT,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_UM_RECEIVE_PROCESS_DAR,
+
+  /* PDCP signals  */
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_RUN,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_DATA_REQ,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_DATA_IND,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_APPLY_SECURITY,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_VALIDATE_SECURITY,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_FIFO_READ,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_FIFO_READ_BUFFER,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_FIFO_FLUSH,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_FIFO_FLUSH_BUFFER,
+
+  /* RRC signals  */
+  VCD_SIGNAL_DUMPER_FUNCTIONS_RRC_RX_TX,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_RRC_MAC_CONFIG,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_RRC_UE_DECODE_SIB1,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_RRC_UE_DECODE_SI,
+
+  /* GTPV1U signals */
+  VCD_SIGNAL_DUMPER_FUNCTIONS_GTPV1U_ENB_TASK,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_GTPV1U_PROCESS_UDP_REQ,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_GTPV1U_PROCESS_TUNNEL_DATA_REQ,
+
+  /* UDP signals */
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UDP_ENB_TASK,
+
+  /* MISC signals  */
+  VCD_SIGNAL_DUMPER_FUNCTIONS_EMU_TRANSPORT,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_LOG_RECORD,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_ITTI_ENQUEUE_MESSAGE,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_ITTI_DUMP_ENQUEUE_MESSAGE,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_ITTI_DUMP_ENQUEUE_MESSAGE_MALLOC,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_ITTI_RELAY_THREAD,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_TEST,
+  
+  /* IF4/IF5 signals */
+  VCD_SIGNAL_DUMPER_FUNCTIONS_SEND_IF4,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_RECV_IF4,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_SEND_IF5,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_RECV_IF5,
+
+  VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_COMPR_IF,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_DECOMPR_IF,
+
+  VCD_SIGNAL_DUMPER_FUNCTIONS_LAST,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_END = VCD_SIGNAL_DUMPER_FUNCTIONS_LAST,
+} vcd_signal_dump_functions;
+
+typedef enum {
+  VCD_SIGNAL_DUMPER_MODULE_FREE = 0,
+
+  VCD_SIGNAL_DUMPER_MODULE_VARIABLES,
+  VCD_SIGNAL_DUMPER_MODULE_FUNCTIONS,
+  //     VCD_SIGNAL_DUMPER_MODULE_UE_PROCEDURES_FUNCTIONS,
+  VCD_SIGNAL_DUMPER_MODULE_LAST,
+  VCD_SIGNAL_DUMPER_MODULE_END = VCD_SIGNAL_DUMPER_MODULE_LAST,
+} vcd_signal_dumper_modules;
+
+typedef enum {
+  VCD_FUNCTION_OUT,
+  VCD_FUNCTION_IN,
+  VCD_FUNCTION_LAST,
+} vcd_signal_dump_in_out;
+
+typedef enum {
+  VCD_REAL, // REAL = variable
+  VCD_WIRE, // WIRE = Function
+} vcd_signal_type;
+
+/*!
+ * \brief Init function for the vcd dumper.
+ * @param None
+ */
+void vcd_signal_dumper_init(char* filename);
+/*!
+ * \brief Close file descriptor.
+ * @param None
+ */
+void vcd_signal_dumper_close(void);
+/*!
+ * \brief Create header for VCD file.
+ * @param None
+ */
+void vcd_signal_dumper_create_header(void);
+/*!
+ * \brief Dump state of a variable
+ * @param Name of the variable to dump (see the corresponding enum)
+ * @param Value of the variable to dump (type: unsigned long)
+ */
+void vcd_signal_dumper_dump_variable_by_name(vcd_signal_dump_variables variable_name,
+    unsigned long             value);
+/*!
+ * \brief Dump function usage
+ * @param Name Function name to dump (see the corresponding enum)
+ * @param State: either VCD_FUNCTION_START or VCD_FUNCTION_END
+ */
+void vcd_signal_dumper_dump_function_by_name(vcd_signal_dump_functions  function_name,
+    vcd_signal_dump_in_out     function_in_out);
+
+extern int ouput_vcd;
+
+#if T_TRACER
+
+#include "T.h"
+
+#define VCD_SIGNAL_DUMPER_INIT(x)         /* nothing */
+#define VCD_SIGNAL_DUMPER_CLOSE()         /* nothing */
+#define VCD_SIGNAL_DUMPER_CREATE_HEADER() /* nothing */
+#define VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(var, val) T_VCD_VARIABLE(var, val)
+#define VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(var, val) T_VCD_FUNCTION(var, val)
+
+#else /* T_TRACER */
+
+#if defined(ENABLE_VCD)
+   #define VCD_SIGNAL_DUMPER_INIT(aRgUmEnT)                   vcd_signal_dumper_init(aRgUmEnT)
+   #define VCD_SIGNAL_DUMPER_CLOSE()                          vcd_signal_dumper_close()
+   #define VCD_SIGNAL_DUMPER_CREATE_HEADER()                  vcd_signal_dumper_create_header()
+   #define VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(vAr1,vAr2) vcd_signal_dumper_dump_variable_by_name(vAr1,vAr2)
+   #define VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(vAr1,vAr2) vcd_signal_dumper_dump_function_by_name(vAr1,vAr2)
+#else
+   #define VCD_SIGNAL_DUMPER_INIT(aRgUmEnT)
+   #define VCD_SIGNAL_DUMPER_CLOSE()
+   #define VCD_SIGNAL_DUMPER_CREATE_HEADER()
+   #define VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(vAr1,vAr2)
+   #define VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(vAr1,vAr2)
+#endif
+
+#endif /* T_TRACER */
+
+#endif /* !defined (VCD_SIGNAL_DUMPER_H_) */
+