Merge remote-tracking branch 'origin/develop-SRS-MIMO' into develop-SRS-feedback

# Conflicts:
#	openair1/SCHED_NR/phy_procedures_nr_gNB.c

cmake_targets/tools/build_helper

@@ -197,8 +197,8 @@ check_warnings() {
 #argument:
 #    $1: log file
 check_errors() {
-  #we look for 'warning:' in the compilation log file
-  error_count=`grep "error:" "$1" | wc -l`
+  #we look for 'error:' in the compilation log file
+  error_count=`grep -c "error:" "$1"`
   if [ $error_count -gt 0 ]; then
     echo_error "ERROR: $error_count error. See $1"
   fi

executables/nr-gnb.c

@@ -466,7 +466,7 @@ void init_gNB_Tpool(int inst) {
     pushNotifiedFIFO(gNB->L1_tx_free,msgL1Tx); // to unblock the process in the beginning
   }
 
-  if (!get_softmodem_params()->emulate_l1) 
+  if ((!get_softmodem_params()->emulate_l1) && (!IS_SOFTMODEM_NOSTATS_BIT))
      threadCreate(&proc->L1_stats_thread,nrL1_stats_thread,(void*)gNB,"L1_stats",-1,OAI_PRIORITY_RT_LOW);
 
   threadCreate(&proc->pthread_tx_reorder, tx_reorder_thread, (void *)gNB, "thread_tx_reorder", -1, OAI_PRIORITY_RT_MAX);

executables/nr-ue.c

@@ -1109,8 +1109,10 @@ void init_NR_UE_threads(int nb_inst) {
 
     LOG_I(PHY,"Intializing UE Threads for instance %d (%p,%p)...\n",inst,PHY_vars_UE_g[inst],PHY_vars_UE_g[inst][0]);
     threadCreate(&threads[inst], UE_thread, (void *)UE, "UEthread", -1, OAI_PRIORITY_RT_MAX);
-    pthread_t stat_pthread;
-    threadCreate(&stat_pthread, nrL1_UE_stats_thread, UE, "L1_UE_stats", -1, OAI_PRIORITY_RT_LOW);
+    if (!IS_SOFTMODEM_NOSTATS_BIT) {
+      pthread_t stat_pthread;
+      threadCreate(&stat_pthread, nrL1_UE_stats_thread, UE, "L1_UE_stats", -1, OAI_PRIORITY_RT_LOW);
+    }
   }
 }
 

executables/softmodem-common.c

@@ -85,6 +85,7 @@ char *get_softmodem_function(uint64_t *sofmodemfunc_mask_ptr) {
 }
 
 void get_common_options(uint32_t execmask) {
+  int32_t stats_disabled = 0;
   uint32_t online_log_messages=0;
   uint32_t glog_level=0 ;
   uint32_t start_telnetsrv = 0, start_telnetclt = 0;
@@ -149,6 +150,8 @@ void get_common_options(uint32_t execmask) {
 
   if(worker_config != NULL)   set_worker_conf(worker_config);
   nfapi_setmode(nfapi_mode);
+  if (stats_disabled)
+    set_softmodem_optmask(SOFTMODEM_NOSTATS_BIT);
 }
 void softmodem_printresources(int sig, telnet_printfunc_t pf) {
   struct rusage usage;

executables/softmodem-common.h

@@ -101,6 +101,7 @@ extern "C"
 #define CONFIG_HLP_NFAPI         "Change the nFAPI mode for NR\n"
 #define CONFIG_L1_EMULATOR       "Run in L1 emulated mode (disable PHY layer)\n"
 #define CONFIG_HLP_CONTINUOUS_TX "perform continuous transmission, even in TDD mode (to work around USRP issues)\n"
+#define CONFIG_HLP_STATS_DISABLE "disable globally the stats generation and persistence"
 
 /*-----------------------------------------------------------------------------------------------------------------------------------------------------*/
 /*                                            command line parameters common to eNodeB and UE                                                          */
@@ -171,6 +172,7 @@ extern int usrp_tx_thread;
     {"non-stop",             CONFIG_HLP_NONSTOP,      PARAMFLAG_BOOL, iptr:&NON_STOP,                     defintval:0,           TYPE_INT,    0},                     \
     {"emulate-l1",           CONFIG_L1_EMULATOR,      PARAMFLAG_BOOL, iptr:&EMULATE_L1,                   defintval:0,           TYPE_INT,    0},                     \
     {"continuous-tx",        CONFIG_HLP_CONTINUOUS_TX,PARAMFLAG_BOOL, iptr:&CONTINUOUS_TX,                defintval:0,           TYPE_INT,    0},                     \
+    {"disable-stats",        CONFIG_HLP_STATS_DISABLE, PARAMFLAG_BOOL, iptr:&stats_disabled,               defintval:0,           TYPE_INT,    0},                     \
   }
 
 #define CONFIG_HLP_NSA           "Enable NSA mode \n"
@@ -217,6 +219,7 @@ extern int usrp_tx_thread;
 #define SOFTMODEM_GNB_BIT             (1<<21)
 #define SOFTMODEM_4GUE_BIT            (1<<22)
 #define SOFTMODEM_5GUE_BIT            (1<<23)
+#define SOFTMODEM_NOSTATS_BIT         (1<<24)
 #define SOFTMODEM_FUNC_BITS (SOFTMODEM_ENB_BIT | SOFTMODEM_GNB_BIT | SOFTMODEM_5GUE_BIT | SOFTMODEM_4GUE_BIT)
 #define MAPPING_SOFTMODEM_FUNCTIONS {{"enb",SOFTMODEM_ENB_BIT},{"gnb",SOFTMODEM_GNB_BIT},{"4Gue",SOFTMODEM_4GUE_BIT},{"5Gue",SOFTMODEM_5GUE_BIT}}
 
@@ -234,6 +237,7 @@ extern int usrp_tx_thread;
 #define IS_SOFTMODEM_GNB_BIT         ( get_softmodem_optmask() & SOFTMODEM_GNB_BIT)
 #define IS_SOFTMODEM_4GUE_BIT        ( get_softmodem_optmask() & SOFTMODEM_4GUE_BIT)
 #define IS_SOFTMODEM_5GUE_BIT        ( get_softmodem_optmask() & SOFTMODEM_5GUE_BIT)
+#define IS_SOFTMODEM_NOSTATS_BIT     ( get_softmodem_optmask() & SOFTMODEM_NOSTATS_BIT)
 
 typedef struct {
   uint64_t       optmask;

nfapi/oai_integration/nfapi_vnf.c

@@ -217,7 +217,7 @@ void oai_create_enb(void) {
   }
 
   // This will cause phy_config_request to be installed. That will result in RRC configuring the PHY
-  // that will result in eNB->configured being set to TRUE.
+  // that will result in eNB->configured being set to true.
   // See we need to wait for that to happen otherwise the NFAPI message exchanges won't contain the right parameter values
   if (RC.eNB[0][0]->if_inst==0 || RC.eNB[0][0]->if_inst->PHY_config_req==0 || RC.eNB[0][0]->if_inst->schedule_response==0) {
     NFAPI_TRACE(NFAPI_TRACE_INFO, "RC.eNB[0][0]->if_inst->PHY_config_req is not installed - install it\n");
@@ -267,7 +267,7 @@ void oai_create_gnb(void) {
 
 
   // This will cause phy_config_request to be installed. That will result in RRC configuring the PHY
-  // that will result in gNB->configured being set to TRUE.
+  // that will result in gNB->configured being set to true.
   // See we need to wait for that to happen otherwise the NFAPI message exchanges won't contain the right parameter values
   if (RC.gNB[0]->if_inst==0 || RC.gNB[0]->if_inst->NR_PHY_config_req==0 || RC.gNB[0]->if_inst->NR_Schedule_response==0) {
     NFAPI_TRACE(NFAPI_TRACE_INFO, "RC.gNB[0][0]->if_inst->NR_PHY_config_req is not installed - install it\n");

openair1/PHY/INIT/nr_init.c

@@ -613,30 +613,10 @@ int phy_init_nr_gNB(PHY_VARS_gNB *gNB,
 
   for (int id=0; id<NUMBER_OF_NR_SRS_MAX; id++) {
     gNB->nr_srs_info[id] = (nr_srs_info_t *)malloc16_clear(sizeof(nr_srs_info_t));
-    gNB->nr_srs_info[id]->k_0_p = (uint8_t**)malloc16_clear(MAX_NUM_NR_SRS_AP*sizeof(uint8_t*));
     gNB->nr_srs_info[id]->srs_generated_signal = (int32_t**)malloc16_clear(MAX_NUM_NR_SRS_AP*sizeof(int32_t*));
-    gNB->nr_srs_info[id]->srs_received_signal = (int32_t **)malloc16(Prx*sizeof(int32_t*));
-    gNB->nr_srs_info[id]->srs_ls_estimated_channel = (int32_t ***)malloc16(Prx*sizeof(int32_t**));
-    gNB->nr_srs_info[id]->srs_estimated_channel_freq = (int32_t ***)malloc16(Prx*sizeof(int32_t**));
-    gNB->nr_srs_info[id]->srs_estimated_channel_time = (int32_t ***)malloc16(Prx*sizeof(int32_t**));
-    gNB->nr_srs_info[id]->srs_estimated_channel_time_shifted = (int32_t ***)malloc16(Prx*sizeof(int32_t**));
     for(i=0; i<MAX_NUM_NR_SRS_AP;i++) {
-      gNB->nr_srs_info[id]->k_0_p[i] = (uint8_t*)malloc16_clear(MAX_NUM_NR_SRS_SYMBOLS*sizeof(uint8_t));
       gNB->nr_srs_info[id]->srs_generated_signal[i] = (int32_t*)malloc16_clear(fp->ofdm_symbol_size*MAX_NUM_NR_SRS_SYMBOLS*sizeof(int32_t));
     }
-    for (i=0;i<Prx;i++) {
-      gNB->nr_srs_info[id]->srs_received_signal[i] = (int32_t*)malloc16_clear(fp->ofdm_symbol_size*MAX_NUM_NR_SRS_SYMBOLS*sizeof(int32_t));
-      gNB->nr_srs_info[id]->srs_ls_estimated_channel[i] = (int32_t**)malloc16_clear(MAX_NUM_NR_SRS_AP*sizeof(int32_t*));
-      gNB->nr_srs_info[id]->srs_estimated_channel_freq[i] = (int32_t**)malloc16_clear(MAX_NUM_NR_SRS_AP*sizeof(int32_t*));
-      gNB->nr_srs_info[id]->srs_estimated_channel_time[i] = (int32_t**)malloc16_clear(MAX_NUM_NR_SRS_AP*sizeof(int32_t*));
-      gNB->nr_srs_info[id]->srs_estimated_channel_time_shifted[i] = (int32_t**)malloc16_clear(MAX_NUM_NR_SRS_AP*sizeof(int32_t*));
-      for (int j = 0; j < MAX_NUM_NR_SRS_AP; j++) {
-        gNB->nr_srs_info[id]->srs_ls_estimated_channel[i][j] = (int32_t*)malloc16_clear(fp->ofdm_symbol_size*MAX_NUM_NR_SRS_SYMBOLS*sizeof(int32_t));
-        gNB->nr_srs_info[id]->srs_estimated_channel_freq[i][j] = (int32_t*)malloc16_clear(fp->ofdm_symbol_size*MAX_NUM_NR_SRS_SYMBOLS*sizeof(int32_t));
-        gNB->nr_srs_info[id]->srs_estimated_channel_time[i][j] = (int32_t*)malloc16_clear(fp->ofdm_symbol_size*MAX_NUM_NR_SRS_SYMBOLS*sizeof(int32_t));
-        gNB->nr_srs_info[id]->srs_estimated_channel_time_shifted[i][j] = (int32_t*)malloc16_clear(fp->ofdm_symbol_size*MAX_NUM_NR_SRS_SYMBOLS*sizeof(int32_t));
-      }
-    }
   }
 
   generate_ul_reference_signal_sequences(SHRT_MAX);
@@ -794,30 +774,10 @@ void phy_free_nr_gNB(PHY_VARS_gNB *gNB)
   free_and_zero(gNB->nr_csi_rs_info);
 
   for (int id = 0; id < NUMBER_OF_NR_SRS_MAX; id++) {
-    for (int i = 0; i < Prx; i++) {
-      for (int j = 0; j < MAX_NUM_NR_SRS_AP; j++) {
-        free_and_zero(gNB->nr_srs_info[id]->srs_ls_estimated_channel[i][j]);
-        free_and_zero(gNB->nr_srs_info[id]->srs_estimated_channel_freq[i][j]);
-        free_and_zero(gNB->nr_srs_info[id]->srs_estimated_channel_time[i][j]);
-        free_and_zero(gNB->nr_srs_info[id]->srs_estimated_channel_time_shifted[i][j]);
-      }
-      free_and_zero(gNB->nr_srs_info[id]->srs_received_signal[i]);
-      free_and_zero(gNB->nr_srs_info[id]->srs_ls_estimated_channel[i]);
-      free_and_zero(gNB->nr_srs_info[id]->srs_estimated_channel_freq[i]);
-      free_and_zero(gNB->nr_srs_info[id]->srs_estimated_channel_time[i]);
-      free_and_zero(gNB->nr_srs_info[id]->srs_estimated_channel_time_shifted[i]);
-    }
-    for (int i = 0; i < MAX_NUM_NR_SRS_AP; i++) {
-      free_and_zero(gNB->nr_srs_info[id]->k_0_p[i]);
+    for(int i=0; i<MAX_NUM_NR_SRS_AP; i++) {
       free_and_zero(gNB->nr_srs_info[id]->srs_generated_signal[i]);
     }
-    free_and_zero(gNB->nr_srs_info[id]->k_0_p);
     free_and_zero(gNB->nr_srs_info[id]->srs_generated_signal);
-    free_and_zero(gNB->nr_srs_info[id]->srs_received_signal);
-    free_and_zero(gNB->nr_srs_info[id]->srs_ls_estimated_channel);
-    free_and_zero(gNB->nr_srs_info[id]->srs_estimated_channel_freq);
-    free_and_zero(gNB->nr_srs_info[id]->srs_estimated_channel_time);
-    free_and_zero(gNB->nr_srs_info[id]->srs_estimated_channel_time_shifted);
     free_and_zero(gNB->nr_srs_info[id]);
   }
 

openair1/PHY/INIT/nr_init_ue.c

@@ -377,10 +377,6 @@ int init_nr_ue_signal(PHY_VARS_NR_UE *ue, int nb_connected_gNB)
     }
 
     ue->nr_srs_info = (nr_srs_info_t *)malloc16_clear(sizeof(nr_srs_info_t));
-    ue->nr_srs_info->k_0_p = (uint8_t**)malloc16_clear(fp->nb_antennas_rx*sizeof(uint8_t*));
-    for (i=0; i<fp->nb_antennas_rx; i++) {
-      ue->nr_srs_info->k_0_p[i] = (uint8_t*)malloc16_clear(MAX_NUM_NR_SRS_SYMBOLS*sizeof(uint8_t));
-    }
 
     // RACH
     prach_vars[gNB_id]->prachF             = (int16_t *)malloc16_clear( sizeof(int)*(7*2*sizeof(int)*(fp->ofdm_symbol_size*12)) );
@@ -507,10 +503,6 @@ void term_nr_ue_signal(PHY_VARS_NR_UE *ue, int nb_connected_gNB)
     free_and_zero(ue->nr_csi_rs_info->csi_rs_estimated_channel_freq);
     free_and_zero(ue->nr_csi_rs_info);
 
-    for (int i = 0; i < fp->nb_antennas_rx; i++) {
-      free_and_zero(ue->nr_srs_info->k_0_p[i]);
-    }
-    free_and_zero(ue->nr_srs_info->k_0_p);
     free_and_zero(ue->nr_srs_info);
 
     free_and_zero(ue->csiim_vars[gNB_id]);

openair1/PHY/LTE_ESTIMATION/lte_ul_channel_estimation.c

@@ -41,10 +41,10 @@ extern int16_t *ul_ref_sigs_rx[30][2][34];
 
 int32_t lte_ul_channel_estimation(LTE_DL_FRAME_PARMS *frame_parms,
                                   L1_rxtx_proc_t *proc,
-                        				  LTE_eNB_ULSCH_t * ulsch,
-				                          int32_t **ul_ch_estimates,
-				                          int32_t **ul_ch_estimates_time,
-				                          int32_t **rxdataF_ext,
+				  LTE_eNB_ULSCH_t * ulsch,
+				  int32_t **ul_ch_estimates,
+				  int32_t **ul_ch_estimates_time,
+				  int32_t **rxdataF_ext,
                                   module_id_t UE_id,
                                   unsigned char l,
                                   unsigned char Ns) {
@@ -88,7 +88,7 @@ int32_t lte_ul_channel_estimation(LTE_DL_FRAME_PARMS *frame_parms,
   }
 
   uint16_t N_rb_alloc = ulsch->harq_processes[harq_pid]->nb_rb;
-  int32_t tmp_estimates[N_rb_alloc*12] __attribute__((aligned(16)));
+  int32_t tmp_estimates[N_rb_alloc*12] __attribute__((aligned(32)));
   Msc_RS = N_rb_alloc*12;
   cyclic_shift = (frame_parms->pusch_config_common.ul_ReferenceSignalsPUSCH.cyclicShift +
                   ulsch->harq_processes[harq_pid]->n_DMRS2 +
@@ -334,14 +334,14 @@ int32_t lte_ul_channel_estimation(LTE_DL_FRAME_PARMS *frame_parms,
             current_phase2 = cmin(abs(current_phase2),127);
             //          msg("sym: %d, current_phase1: %d, ru: %d + j%d, current_phase2: %d, ru: %d + j%d\n",k,current_phase1,ru1[2*current_phase1],ru1[2*current_phase1+1],current_phase2,ru2[2*current_phase2],ru2[2*current_phase2+1]);
             // rotate channel estimates by estimated phase
-            rotate_cpx_vector((int16_t *) ul_ch1,
-                              &ru1[2*current_phase1],
-                              (int16_t *) &ul_ch_estimates[aa][frame_parms->N_RB_UL*12*k],
+            rotate_cpx_vector((c16_t *) ul_ch1,
+                              (c16_t *)&ru1[2*current_phase1],
+                              (c16_t *) &ul_ch_estimates[aa][frame_parms->N_RB_UL*12*k],
                               Msc_RS,
                               15);
-            rotate_cpx_vector((int16_t *) ul_ch2,
-                              &ru2[2*current_phase2],
-                              (int16_t *) &tmp_estimates[0],
+            rotate_cpx_vector((c16_t *) ul_ch2,
+                              (c16_t *)&ru2[2*current_phase2],
+                              (c16_t *) tmp_estimates,
                               Msc_RS,
                               15);
             // Combine the two rotated estimates
@@ -657,14 +657,14 @@ int32_t lte_ul_channel_estimation_RRU(LTE_DL_FRAME_PARMS *frame_parms,
           current_phase2 = cmin(abs(current_phase2),127);
           //          msg("sym: %d, current_phase1: %d, ru: %d + j%d, current_phase2: %d, ru: %d + j%d\n",k,current_phase1,ru1[2*current_phase1],ru1[2*current_phase1+1],current_phase2,ru2[2*current_phase2],ru2[2*current_phase2+1]);
           // rotate channel estimates by estimated phase
-          rotate_cpx_vector((int16_t *) ul_ch1,
-                            &ru1[2*current_phase1],
-                            (int16_t *) &ul_ch_estimates[aa][frame_parms->N_RB_UL*12*k],
+          rotate_cpx_vector((c16_t *) ul_ch1,
+                            (c16_t *) &ru1[2*current_phase1],
+                            (c16_t *) &ul_ch_estimates[aa][frame_parms->N_RB_UL*12*k],
                             Msc_RS,
                             15);
-          rotate_cpx_vector((int16_t *) ul_ch2,
-                            &ru2[2*current_phase2],
-                            (int16_t *) &tmp_estimates[0],
+          rotate_cpx_vector((c16_t *) ul_ch2,
+                            (c16_t *) &ru2[2*current_phase2],
+                            (c16_t *) &tmp_estimates[0],
                             Msc_RS,
                             15);
           // Combine the two rotated estimates

openair1/PHY/LTE_TRANSPORT/dci_tools.c

@@ -1997,7 +1997,7 @@ int get_narrowband_index(int N_RB_UL,int rb) {
 void fill_ulsch(PHY_VARS_eNB *eNB,int UE_id,nfapi_ul_config_ulsch_pdu *ulsch_pdu,int frame,int subframe) {
   uint8_t harq_pid;
   //uint8_t UE_id;
-  boolean_t new_ulsch = (find_ulsch(ulsch_pdu->ulsch_pdu_rel8.rnti,eNB,SEARCH_EXIST)==-1) ? TRUE : FALSE;
+  const bool new_ulsch = find_ulsch(ulsch_pdu->ulsch_pdu_rel8.rnti,eNB,SEARCH_EXIST) == -1;
   //AssertFatal((UE_id=find_ulsch(ulsch_pdu->ulsch_pdu_rel8.rnti,eNB,SEARCH_EXIST_OR_FREE))>=0,
   //        "No existing/free UE ULSCH for rnti %x\n",ulsch_pdu->ulsch_pdu_rel8.rnti);
   LTE_eNB_ULSCH_t *ulsch=eNB->ulsch[UE_id];
@@ -2063,7 +2063,7 @@ void fill_ulsch(PHY_VARS_eNB *eNB,int UE_id,nfapi_ul_config_ulsch_pdu *ulsch_pdu
 
   if ((ulsch->harq_processes[harq_pid]->status == SCH_IDLE) ||
       (ulsch->harq_processes[harq_pid]->ndi    != ulsch_pdu->ulsch_pdu_rel8.new_data_indication) ||
-      (new_ulsch == TRUE)) {
+      (new_ulsch == true)) {
     ulsch->harq_processes[harq_pid]->status        = ACTIVE;
     ulsch->harq_processes[harq_pid]->TBS           = ulsch_pdu->ulsch_pdu_rel8.size<<3;
     ulsch->harq_processes[harq_pid]->Msc_initial   = 12*ulsch_pdu->ulsch_pdu_rel8.number_of_resource_blocks;

openair1/PHY/LTE_TRANSPORT/defs_NB_IoT.h

@@ -509,7 +509,7 @@ typedef struct {
   /// Position of first CCE of the dci
   int                   firstCCE;
   /// flag to indicate that this is a RA response
-  boolean_t      ra_flag;
+  bool                  ra_flag;
   /// rnti
   rnti_t                rnti;
   /// Format

openair1/PHY/MODULATION/nr_modulation.c

@@ -618,20 +618,20 @@ void init_symbol_rotation(NR_DL_FRAME_PARMS *fp) {
 
     double f0 = f[ll];
     double Ncpm1 = Ncp0;
-    int16_t *symbol_rotation = fp->symbol_rotation[ll];
+    c16_t *symbol_rotation = fp->symbol_rotation[ll];
 
     double tl = 0;
     double poff = 2 * M_PI * ((Ncp0 * Tc)) * f0;
     double exp_re = cos(poff);
     double exp_im = sin(-poff);
-    symbol_rotation[0] = (int16_t)floor(exp_re * 32767);
-    symbol_rotation[1] = (int16_t)floor(exp_im * 32767);
+    symbol_rotation[0].r = (int16_t)floor(exp_re * 32767);
+    symbol_rotation[0].i = (int16_t)floor(exp_im * 32767);
     LOG_I(PHY, "Doing symbol rotation calculation for gNB TX/RX, f0 %f Hz, Nsymb %d\n", f0, nsymb);
     LOG_I(PHY, "Symbol rotation %d/%d => (%d,%d)\n",
       0,
       nsymb,
-      symbol_rotation[0],
-      symbol_rotation[1]);
+      symbol_rotation[0].r,
+      symbol_rotation[0].i);
 
     for (int l = 1; l < nsymb; l++) {
 
@@ -646,15 +646,15 @@ void init_symbol_rotation(NR_DL_FRAME_PARMS *fp) {
       poff = 2 * M_PI * (tl + (Ncp * Tc)) * f0;
       exp_re = cos(poff);
       exp_im = sin(-poff);
-      symbol_rotation[l<<1] = (int16_t)floor(exp_re * 32767);
-      symbol_rotation[1 + (l<<1)] = (int16_t)floor(exp_im * 32767);
+      symbol_rotation[l].r = (int16_t)floor(exp_re * 32767);
+      symbol_rotation[l].i = (int16_t)floor(exp_im * 32767);
 
       LOG_I(PHY, "Symbol rotation %d/%d => tl %f (%d,%d) (%f)\n",
         l,
         nsymb,
         tl,
-        symbol_rotation[l<<1],
-        symbol_rotation[1 + (l<<1)],
+        symbol_rotation[l].r,
+        symbol_rotation[l].i,
         (poff / 2 / M_PI) - floor(poff / 2 / M_PI));
 
       Ncpm1 = Ncp;
@@ -670,13 +670,13 @@ void init_timeshift_rotation(NR_DL_FRAME_PARMS *fp)
     double poff = -i * 2.0 * M_PI * sample_offset / fp->ofdm_symbol_size;
     double exp_re = cos(poff);
     double exp_im = sin(-poff);
-    fp->timeshift_symbol_rotation[i*2] = (int16_t)round(exp_re * 32767);
-    fp->timeshift_symbol_rotation[i*2+1] = (int16_t)round(exp_im * 32767);
+    fp->timeshift_symbol_rotation[i].r = (int16_t)round(exp_re * 32767);
+    fp->timeshift_symbol_rotation[i].i = (int16_t)round(exp_im * 32767);
 
     if (i < 10)
       LOG_I(PHY,"Timeshift symbol rotation %d => (%d,%d) %f\n",i,
-            fp->timeshift_symbol_rotation[i*2],
-            fp->timeshift_symbol_rotation[i*2+1],
+            fp->timeshift_symbol_rotation[i].r,
+            fp->timeshift_symbol_rotation[i].i,
             poff);
   }
 }

openair1/PHY/MODULATION/ofdm_mod.c

@@ -46,18 +46,18 @@ void normal_prefix_mod(int32_t *txdataF,int32_t *txdata,uint8_t nsymb,LTE_DL_FRA
 
   
   PHY_ofdm_mod(txdataF,        // input
-	       txdata,         // output
-	       frame_parms->ofdm_symbol_size,                
+               txdata,         // output
+               frame_parms->ofdm_symbol_size,                
 
-	       1,                 // number of symbols
-	       frame_parms->nb_prefix_samples0,               // number of prefix samples
-	       CYCLIC_PREFIX);
+               1,                 // number of symbols
+               frame_parms->nb_prefix_samples0,               // number of prefix samples
+               CYCLIC_PREFIX);
   PHY_ofdm_mod(txdataF+frame_parms->ofdm_symbol_size,        // input
-	       txdata+OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES0,         // output
-	       frame_parms->ofdm_symbol_size,                
-	       nsymb-1,
-	       frame_parms->nb_prefix_samples,               // number of prefix samples
-	       CYCLIC_PREFIX);
+               txdata+OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES0,         // output
+               frame_parms->ofdm_symbol_size,                
+               nsymb-1,
+               frame_parms->nb_prefix_samples,               // number of prefix samples
+               CYCLIC_PREFIX);
   
 
   
@@ -341,14 +341,14 @@ void do_OFDM_mod(int32_t **txdataF, int32_t **txdata, uint32_t frame,uint16_t ne
 }
 
 void apply_nr_rotation(NR_DL_FRAME_PARMS *fp,
-		       int16_t* trxdata,
-		       int slot,
-		       int first_symbol,
-		       int nsymb,
-		       int length) {
+                       int16_t* trxdata,
+                       int slot,
+                       int first_symbol,
+                       int nsymb,
+                       int length) {
   int symb_offset = (slot%fp->slots_per_subframe)*fp->symbols_per_slot;
 
-  int16_t *symbol_rotation = fp->symbol_rotation[0];
+  c16_t *symbol_rotation = fp->symbol_rotation[0];
 
   for (int sidx=0;sidx<nsymb;sidx++) {
 
@@ -357,14 +357,14 @@ void apply_nr_rotation(NR_DL_FRAME_PARMS *fp,
       slot,
       sidx + first_symbol + symb_offset,
       length,
-      symbol_rotation[2 * (sidx + first_symbol + symb_offset)],
-      symbol_rotation[1 + 2 * (sidx + first_symbol + symb_offset)]);
+      symbol_rotation[sidx + first_symbol + symb_offset].r,
+      symbol_rotation[sidx + first_symbol + symb_offset].i);
 
-    rotate_cpx_vector(trxdata + (sidx * length * 2),
-                      &symbol_rotation[2 * (sidx + first_symbol + symb_offset)],
-                      trxdata + (sidx * length * 2),
+    rotate_cpx_vector(((c16_t*) trxdata) + sidx * length,
+                      symbol_rotation + sidx + first_symbol + symb_offset,
+                      ((c16_t*) trxdata) + sidx * length,
                       length,
                       15);
   }
 }
-		       
+                       

openair1/PHY/MODULATION/slot_fep_nr.c

@@ -98,25 +98,25 @@ int nr_slot_fep(PHY_VARS_NR_UE *ue,
     stop_meas(&ue->rx_dft_stats);
 
     int symb_offset = (Ns%frame_parms->slots_per_subframe)*frame_parms->symbols_per_slot;
-    int32_t rot2 = ((uint32_t*)frame_parms->symbol_rotation[0])[symbol+symb_offset];
-    ((int16_t*)&rot2)[1]=-((int16_t*)&rot2)[1];
+    c16_t rot2 = frame_parms->symbol_rotation[0][symbol+symb_offset];
+    rot2.i=-rot2.i;
 
 #ifdef DEBUG_FEP
     //  if (ue->frame <100)
     printf("slot_fep: slot %d, symbol %d rx_offset %u, rotation symbol %d %d.%d\n", Ns,symbol, rx_offset,
-	   symbol+symb_offset,((int16_t*)&rot2)[0],((int16_t*)&rot2)[1]);
+	   symbol+symb_offset,rot2.r,rot2.i);
 #endif
 
-    rotate_cpx_vector((int16_t *)&common_vars->common_vars_rx_data_per_thread[proc->thread_id].rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],
-		      (int16_t*)&rot2,
-		      (int16_t *)&common_vars->common_vars_rx_data_per_thread[proc->thread_id].rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],
+    rotate_cpx_vector((c16_t *)&common_vars->common_vars_rx_data_per_thread[proc->thread_id].rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],
+		      &rot2,
+		      (c16_t *)&common_vars->common_vars_rx_data_per_thread[proc->thread_id].rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],
 		      frame_parms->ofdm_symbol_size,
 		      15);
 
-    int16_t *shift_rot = frame_parms->timeshift_symbol_rotation;
+    c16_t *shift_rot = frame_parms->timeshift_symbol_rotation;
 
     multadd_cpx_vector((int16_t *)&common_vars->common_vars_rx_data_per_thread[proc->thread_id].rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],
-          shift_rot,
+          (int16_t *)shift_rot,
           (int16_t *)&common_vars->common_vars_rx_data_per_thread[proc->thread_id].rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],
           1,
           frame_parms->ofdm_symbol_size,
@@ -214,18 +214,18 @@ int nr_slot_fep_init_sync(PHY_VARS_NR_UE *ue,
     stop_meas(&ue->rx_dft_stats);
 
     int symb_offset = (Ns%frame_parms->slots_per_subframe)*frame_parms->symbols_per_slot;
-    int32_t rot2 = ((uint32_t*)frame_parms->symbol_rotation[0])[symbol + symb_offset];
-    ((int16_t*)&rot2)[1]=-((int16_t*)&rot2)[1];
+    c16_t rot2 = frame_parms->symbol_rotation[0][symbol + symb_offset];
+    rot2.i=-rot2.i;
 
 #ifdef DEBUG_FEP
     //  if (ue->frame <100)
     printf("slot_fep: slot %d, symbol %d rx_offset %u, rotation symbol %d %d.%d\n", Ns,symbol, rx_offset,
-	   symbol+symb_offset,((int16_t*)&rot2)[0],((int16_t*)&rot2)[1]);
+	   symbol+symb_offset,rot2.r,rot2.i);
 #endif
 
-    rotate_cpx_vector((int16_t *)&common_vars->common_vars_rx_data_per_thread[proc->thread_id].rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],
-		      (int16_t*)&rot2,
-		      (int16_t *)&common_vars->common_vars_rx_data_per_thread[proc->thread_id].rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],
+    rotate_cpx_vector((c16_t *)&common_vars->common_vars_rx_data_per_thread[proc->thread_id].rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],
+		      &rot2,
+		      (c16_t *)&common_vars->common_vars_rx_data_per_thread[proc->thread_id].rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],
 		      frame_parms->ofdm_symbol_size,
 		      15);
   }
@@ -310,19 +310,19 @@ void apply_nr_rotation_ul(NR_DL_FRAME_PARMS *frame_parms,
 
   for (int symbol=first_symbol;symbol<nsymb;symbol++) {
     
-    uint32_t rot2 = ((uint32_t*)frame_parms->symbol_rotation[1])[symbol + symb_offset];
-    ((int16_t*)&rot2)[1]=-((int16_t*)&rot2)[1];
-    LOG_D(PHY,"slot %d, symb_offset %d rotating by %d.%d\n",slot,symb_offset,((int16_t*)&rot2)[0],((int16_t*)&rot2)[1]);
-    rotate_cpx_vector((int16_t *)&rxdataF[soffset+(frame_parms->ofdm_symbol_size*symbol)],
-		      (int16_t*)&rot2,
-		      (int16_t *)&rxdataF[soffset+(frame_parms->ofdm_symbol_size*symbol)],
+    c16_t rot2 = frame_parms->symbol_rotation[1][symbol + symb_offset];
+    rot2.i=-rot2.i;
+    LOG_D(PHY,"slot %d, symb_offset %d rotating by %d.%d\n",slot,symb_offset,rot2.r,rot2.i);
+    rotate_cpx_vector((c16_t *)&rxdataF[soffset+(frame_parms->ofdm_symbol_size*symbol)],
+		      &rot2,
+		      (c16_t *)&rxdataF[soffset+(frame_parms->ofdm_symbol_size*symbol)],
 		      length,
 		      15);
 
-    int16_t *shift_rot = frame_parms->timeshift_symbol_rotation;
+    c16_t *shift_rot = frame_parms->timeshift_symbol_rotation;
 
     multadd_cpx_vector((int16_t *)&rxdataF[soffset+(frame_parms->ofdm_symbol_size*symbol)],
-          shift_rot,
+          (int16_t *)shift_rot,
           (int16_t *)&rxdataF[soffset+(frame_parms->ofdm_symbol_size*symbol)],
           1,
           length,

openair1/PHY/NR_ESTIMATION/nr_measurements_gNB.c

@@ -68,15 +68,15 @@ int nr_est_timing_advance_pusch(PHY_VARS_gNB* gNB, int UE_id)
 }
 
 int nr_est_timing_advance_srs(const NR_DL_FRAME_PARMS *frame_parms,
-                              const int32_t **srs_estimated_channel_time) {
+                              const int32_t srs_estimated_channel_time[][frame_parms->ofdm_symbol_size]) {
   int timing_advance = 0;
   int max_val = 0;
 
   for (int i = 0; i < frame_parms->ofdm_symbol_size; i++) {
     int temp = 0;
     for (int aa = 0; aa < frame_parms->nb_antennas_rx; aa++) {
-      int Re = ((int16_t*)srs_estimated_channel_time[aa])[(i<<1)];
-      int Im = ((int16_t*)srs_estimated_channel_time[aa])[1+(i<<1)];
+      int Re = ((c16_t*)srs_estimated_channel_time[aa])[i].r;
+      int Im = ((c16_t*)srs_estimated_channel_time[aa])[i].i;
       temp += (Re*Re/2) + (Im*Im/2);
     }
     if (temp > max_val) {

openair1/PHY/NR_ESTIMATION/nr_ul_channel_estimation.c

@@ -855,7 +855,6 @@ void nr_pusch_ptrs_processing(PHY_VARS_gNB *gNB,
                               uint32_t nb_re_pusch)
 {
   //#define DEBUG_UL_PTRS 1
-  int16_t *phase_per_symbol = NULL;
   int32_t *ptrs_re_symbol   = NULL;
   int8_t   ret = 0;
 
@@ -872,20 +871,20 @@ void nr_pusch_ptrs_processing(PHY_VARS_gNB *gNB,
   uint8_t  *ptrsReOffset    = &rel15_ul->pusch_ptrs.ptrs_ports_list[0].ptrs_re_offset;
   /* loop over antennas */
   for (int aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
-    phase_per_symbol = (int16_t*)gNB->pusch_vars[ulsch_id]->ptrs_phase_per_slot[aarx];
+    c16_t *phase_per_symbol = (c16_t*)gNB->pusch_vars[ulsch_id]->ptrs_phase_per_slot[aarx];
     ptrs_re_symbol = &gNB->pusch_vars[ulsch_id]->ptrs_re_per_slot;
     *ptrs_re_symbol = 0;
-    phase_per_symbol[(2*symbol)+1] = 0; // Imag
+    phase_per_symbol[symbol].i = 0;
     /* set DMRS estimates to 0 angle with magnitude 1 */
     if(is_dmrs_symbol(symbol,*dmrsSymbPos)) {
       /* set DMRS real estimation to 32767 */
-      phase_per_symbol[2*symbol]=(int16_t)((1<<15)-1); // 32767
+      phase_per_symbol[symbol].r=INT16_MAX; // 32767
 #ifdef DEBUG_UL_PTRS
-      printf("[PHY][PTRS]: DMRS Symbol %d -> %4d + j*%4d\n", symbol, phase_per_symbol[2*symbol],phase_per_symbol[(2*symbol)+1]);
+      printf("[PHY][PTRS]: DMRS Symbol %d -> %4d + j*%4d\n", symbol, phase_per_symbol[symbol].r,phase_per_symbol[symbol].i);
 #endif
     }
     else {// real ptrs value is set to 0
-      phase_per_symbol[2*symbol] = 0; // Real
+      phase_per_symbol[symbol].r = 0;
     }
 
     if(symbol == *startSymbIndex) {
@@ -910,7 +909,7 @@ void nr_pusch_ptrs_processing(PHY_VARS_gNB *gNB,
                              symbol,frame_parms->ofdm_symbol_size,
                              (int16_t*)&gNB->pusch_vars[ulsch_id]->rxdataF_comp[aarx][(symbol * nb_re_pusch)],
                              gNB->nr_gold_pusch_dmrs[rel15_ul->scid][nr_tti_rx][symbol],
-                             &phase_per_symbol[2* symbol],
+                             (int16_t*)&phase_per_symbol[symbol],
                              ptrs_re_symbol);
     }
     /* For last OFDM symbol at each antenna perform interpolation and compensation for the slot*/
@@ -920,7 +919,7 @@ void nr_pusch_ptrs_processing(PHY_VARS_gNB *gNB,
       /*------------------------------------------------------------------------------------------------------- */
       /* If L-PTRS is > 0 then we need interpolation */
       if(*L_ptrs > 0) {
-        ret = nr_ptrs_process_slot(*dmrsSymbPos, *ptrsSymbPos, phase_per_symbol, *startSymbIndex, *nbSymb);
+        ret = nr_ptrs_process_slot(*dmrsSymbPos, *ptrsSymbPos, (int16_t*)phase_per_symbol, *startSymbIndex, *nbSymb);
         if(ret != 0) {
           LOG_W(PHY,"[PTRS] Compensation is skipped due to error in PTRS slot processing !!\n");
         }
@@ -939,11 +938,11 @@ void nr_pusch_ptrs_processing(PHY_VARS_gNB *gNB,
         /* Skip rotation if the slot processing is wrong */
         if((!is_dmrs_symbol(i,*dmrsSymbPos)) && (ret == 0)) {
 #ifdef DEBUG_UL_PTRS
-          printf("[PHY][UL][PTRS]: Rotate Symbol %2d with  %d + j* %d\n", i, phase_per_symbol[2* i],phase_per_symbol[(2* i) +1]);
+          printf("[PHY][UL][PTRS]: Rotate Symbol %2d with  %d + j* %d\n", i, phase_per_symbol[i].r,phase_per_symbol[i].i);
 #endif
-          rotate_cpx_vector((int16_t*)&gNB->pusch_vars[ulsch_id]->rxdataF_comp[aarx][(i * rel15_ul->rb_size * NR_NB_SC_PER_RB)],
-                            &phase_per_symbol[2* i],
-                            (int16_t*)&gNB->pusch_vars[ulsch_id]->rxdataF_comp[aarx][(i * rel15_ul->rb_size * NR_NB_SC_PER_RB)],
+          rotate_cpx_vector((c16_t*)&gNB->pusch_vars[ulsch_id]->rxdataF_comp[aarx][(i * rel15_ul->rb_size * NR_NB_SC_PER_RB)],
+                            &phase_per_symbol[i],
+                            (c16_t*)&gNB->pusch_vars[ulsch_id]->rxdataF_comp[aarx][(i * rel15_ul->rb_size * NR_NB_SC_PER_RB)],
                             ((*nb_rb) * NR_NB_SC_PER_RB), 15);
         }// if not DMRS Symbol
       }// symbol loop
@@ -967,10 +966,11 @@ int nr_srs_channel_estimation(const PHY_VARS_gNB *gNB,
                               const nfapi_nr_srs_pdu_t *srs_pdu,
                               const nr_srs_info_t *nr_srs_info,
                               const int32_t **srs_generated_signal,
-                              const int32_t **srs_received_signal,
-                              int32_t ***srs_estimated_channel_freq,
-                              int32_t ***srs_estimated_channel_time,
-                              int32_t ***srs_estimated_channel_time_shifted,
+                              int32_t srs_received_signal[][gNB->frame_parms.ofdm_symbol_size*(1<<srs_pdu->num_symbols)],
+                              int32_t srs_ls_estimated_channel[][MAX_NUM_NR_SRS_AP][gNB->frame_parms.ofdm_symbol_size*(1<<srs_pdu->num_symbols)],
+                              int32_t srs_estimated_channel_freq[][MAX_NUM_NR_SRS_AP][gNB->frame_parms.ofdm_symbol_size*(1<<srs_pdu->num_symbols)],
+                              int32_t srs_estimated_channel_time[][MAX_NUM_NR_SRS_AP][gNB->frame_parms.ofdm_symbol_size],
+                              int32_t srs_estimated_channel_time_shifted[][MAX_NUM_NR_SRS_AP][gNB->frame_parms.ofdm_symbol_size],
                               uint32_t *signal_power,
                               uint32_t *noise_power_per_rb,
                               uint32_t *noise_power,
@@ -982,8 +982,6 @@ int nr_srs_channel_estimation(const PHY_VARS_gNB *gNB,
 #endif
 
   const NR_DL_FRAME_PARMS *frame_parms = &gNB->frame_parms;
-  int32_t ***srs_ls_estimated_channel = nr_srs_info->srs_ls_estimated_channel;
-
   const uint64_t subcarrier_offset = frame_parms->first_carrier_offset + srs_pdu->bwp_start*NR_NB_SC_PER_RB;
 
   uint8_t N_ap = 1<<srs_pdu->num_ant_ports;
@@ -1030,11 +1028,11 @@ int nr_srs_channel_estimation(const PHY_VARS_gNB *gNB,
 
           for (int cdm_idx = 0; cdm_idx < fd_cdm; cdm_idx++) {
 
-            int16_t generated_real = srs_generated_signal[p_index][subcarrier_cdm] & 0xFFFF;
-            int16_t generated_imag = (srs_generated_signal[p_index][subcarrier_cdm] >> 16) & 0xFFFF;
+            int16_t generated_real = ((c16_t*)srs_generated_signal[p_index])[subcarrier_cdm].r;
+            int16_t generated_imag = ((c16_t*)srs_generated_signal[p_index])[subcarrier_cdm].i;
 
-            int16_t received_real = srs_received_signal[ant][subcarrier_cdm] & 0xFFFF;
-            int16_t received_imag = (srs_received_signal[ant][subcarrier_cdm] >> 16) & 0xFFFF;
+            int16_t received_real = ((c16_t*)srs_received_signal[ant])[subcarrier_cdm].r;
+            int16_t received_imag = ((c16_t*)srs_received_signal[ant])[subcarrier_cdm].i;
 
             // We know that nr_srs_info->srs_generated_signal_bits bits are enough to represent the generated_real and generated_imag.
             // So we only need a nr_srs_info->srs_generated_signal_bits shift to ensure that the result fits into 16 bits.
@@ -1120,10 +1118,10 @@ int nr_srs_channel_estimation(const PHY_VARS_gNB *gNB,
       }
       uint16_t base_idx = ant*N_ap*M_sc_b_SRS + p_index*M_sc_b_SRS;
       for (int k = 0; k < M_sc_b_SRS; k++) {
-        ch_real[base_idx+k] = (int16_t)(srs_estimated_channel_freq[ant][p_index][subcarrier] & 0xFFFF);
-        ch_imag[base_idx+k] = (int16_t)((srs_estimated_channel_freq[ant][p_index][subcarrier] >> 16) & 0xFFFF);
-        noise_real[base_idx+k] = abs((int16_t)(srs_ls_estimated_channel[ant][p_index][subcarrier] & 0xFFFF) - ch_real[base_idx+k]);
-        noise_imag[base_idx+k] = abs((int16_t)((srs_ls_estimated_channel[ant][p_index][subcarrier] >> 16) & 0xFFFF) - ch_imag[base_idx+k]);
+        ch_real[base_idx+k] = ((c16_t*)srs_estimated_channel_freq[ant][p_index])[subcarrier].r;
+        ch_imag[base_idx+k] = ((c16_t*)srs_estimated_channel_freq[ant][p_index])[subcarrier].i;
+        noise_real[base_idx+k] = abs(((c16_t*)srs_ls_estimated_channel[ant][p_index])[subcarrier].r - ch_real[base_idx+k]);
+        noise_imag[base_idx+k] = abs(((c16_t*)srs_ls_estimated_channel[ant][p_index])[subcarrier].i - ch_imag[base_idx+k]);
         subcarrier += K_TC;
         if (subcarrier >= frame_parms->ofdm_symbol_size) {
           subcarrier=subcarrier-frame_parms->ofdm_symbol_size;

openair1/PHY/NR_ESTIMATION/nr_ul_estimation.h

@@ -56,7 +56,7 @@ void nr_gnb_measurements(PHY_VARS_gNB *gNB, uint8_t ulsch_id, unsigned char harq
 int nr_est_timing_advance_pusch(PHY_VARS_gNB* phy_vars_gNB, int UE_id);
 
 int nr_est_timing_advance_srs(const NR_DL_FRAME_PARMS *frame_parms,
-                              const int32_t **srs_estimated_channel_time);
+                              const int32_t srs_estimated_channel_time[][frame_parms->ofdm_symbol_size]);
 
 void nr_pusch_ptrs_processing(PHY_VARS_gNB *gNB,
                               NR_DL_FRAME_PARMS *frame_parms,
@@ -72,10 +72,11 @@ int nr_srs_channel_estimation(const PHY_VARS_gNB *gNB,
                               const nfapi_nr_srs_pdu_t *srs_pdu,
                               const nr_srs_info_t *nr_srs_info,
                               const int32_t **srs_generated_signal,
-                              const int32_t **srs_received_signal,
-                              int32_t ***srs_estimated_channel_freq,
-                              int32_t ***srs_estimated_channel_time,
-                              int32_t ***srs_estimated_channel_time_shifted,
+                              int32_t srs_received_signal[][gNB->frame_parms.ofdm_symbol_size*(1<<srs_pdu->num_symbols)],
+                              int32_t srs_ls_estimated_channel[][MAX_NUM_NR_SRS_AP][gNB->frame_parms.ofdm_symbol_size*(1<<srs_pdu->num_symbols)],
+                              int32_t srs_estimated_channel_freq[][MAX_NUM_NR_SRS_AP][gNB->frame_parms.ofdm_symbol_size*(1<<srs_pdu->num_symbols)],
+                              int32_t srs_estimated_channel_time[][MAX_NUM_NR_SRS_AP][gNB->frame_parms.ofdm_symbol_size],
+                              int32_t srs_estimated_channel_time_shifted[][MAX_NUM_NR_SRS_AP][gNB->frame_parms.ofdm_symbol_size],
                               uint32_t *signal_power,
                               uint32_t *noise_power_per_rb,
                               uint32_t *noise_power,

openair1/PHY/NR_TRANSPORT/nr_transport_proto.h

@@ -330,7 +330,7 @@ int nr_get_srs_signal(PHY_VARS_gNB *gNB,
                       int slot,
                       nfapi_nr_srs_pdu_t *srs_pdu,
                       nr_srs_info_t *nr_srs_info,
-                      int32_t **srs_received_signal);
+                      int32_t srs_received_signal[][gNB->frame_parms.ofdm_symbol_size*(1<<srs_pdu->num_symbols)]);
 
 void init_prach_list(PHY_VARS_gNB *gNB);
 void init_prach_ru_list(RU_t *ru);

openair1/PHY/NR_TRANSPORT/srs_rx.c

@@ -100,7 +100,7 @@ int nr_get_srs_signal(PHY_VARS_gNB *gNB,
                       int slot,
                       nfapi_nr_srs_pdu_t *srs_pdu,
                       nr_srs_info_t *nr_srs_info,
-                      int32_t **srs_received_signal) {
+                      int32_t srs_received_signal[][gNB->frame_parms.ofdm_symbol_size*(1<<srs_pdu->num_symbols)]) {
 
 #ifdef SRS_DEBUG
   LOG_I(NR_PHY,"Calling %s function\n", __FUNCTION__);

openair1/PHY/NR_UE_ESTIMATION/nr_dl_channel_estimation.c

@@ -1657,7 +1657,6 @@ void nr_pdsch_ptrs_processing(PHY_VARS_NR_UE *ue,
                               RX_type_t rx_type)
 {
   //#define DEBUG_DL_PTRS 1
-  int16_t *phase_per_symbol = NULL;
   int32_t *ptrs_re_symbol = NULL;
   int8_t   ret = 0;
   /* harq specific variables */
@@ -1701,20 +1700,20 @@ void nr_pdsch_ptrs_processing(PHY_VARS_NR_UE *ue,
   }
   /* loop over antennas */
   for (int aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
-    phase_per_symbol = (int16_t*)pdsch_vars[gNB_id]->ptrs_phase_per_slot[aarx];
+    c16_t *phase_per_symbol = (c16_t*)pdsch_vars[gNB_id]->ptrs_phase_per_slot[aarx];
     ptrs_re_symbol = (int32_t*)pdsch_vars[gNB_id]->ptrs_re_per_slot[aarx];
     ptrs_re_symbol[symbol] = 0;
-    phase_per_symbol[(2*symbol)+1] = 0; // Imag
+    phase_per_symbol[symbol].i = 0; // Imag
     /* set DMRS estimates to 0 angle with magnitude 1 */
     if(is_dmrs_symbol(symbol,*dmrsSymbPos)) {
       /* set DMRS real estimation to 32767 */
-      phase_per_symbol[2*symbol]=(int16_t)((1<<15)-1); // 32767
+      phase_per_symbol[symbol].r=INT16_MAX; // 32767
 #ifdef DEBUG_DL_PTRS
-      printf("[PHY][PTRS]: DMRS Symbol %d -> %4d + j*%4d\n", symbol, phase_per_symbol[2*symbol],phase_per_symbol[(2*symbol)+1]);
+      printf("[PHY][PTRS]: DMRS Symbol %d -> %4d + j*%4d\n", symbol, phase_per_symbol[symbol].r,phase_per_symbol[symbol].i);
 #endif
     }
     else { // real ptrs value is set to 0
-      phase_per_symbol[2*symbol] = 0; // Real
+      phase_per_symbol[symbol].r = 0; // Real
     }
 
     if(dlsch0_harq->status == ACTIVE) {
@@ -1740,7 +1739,7 @@ void nr_pdsch_ptrs_processing(PHY_VARS_NR_UE *ue,
                                symbol,frame_parms->ofdm_symbol_size,
                                (int16_t*)&pdsch_vars[gNB_id]->rxdataF_comp0[aarx][(symbol * nb_re_pdsch)],
                                ue->nr_gold_pdsch[gNB_id][nr_slot_rx][symbol][0],
-                               &phase_per_symbol[2* symbol],
+                               (int16_t*)&phase_per_symbol[symbol],
                                &ptrs_re_symbol[symbol]);
       }
     }// HARQ 0
@@ -1752,7 +1751,7 @@ void nr_pdsch_ptrs_processing(PHY_VARS_NR_UE *ue,
       /*------------------------------------------------------------------------------------------------------- */
       /* If L-PTRS is > 0 then we need interpolation */
       if(*L_ptrs > 0) {
-        ret = nr_ptrs_process_slot(*dmrsSymbPos, *ptrsSymbPos, phase_per_symbol, *startSymbIndex, *nbSymb);
+        ret = nr_ptrs_process_slot(*dmrsSymbPos, *ptrsSymbPos, (int16_t*)phase_per_symbol, *startSymbIndex, *nbSymb);
         if(ret != 0) {
           LOG_W(PHY,"[PTRS] Compensation is skipped due to error in PTRS slot processing !!\n");
         }
@@ -1771,11 +1770,11 @@ void nr_pdsch_ptrs_processing(PHY_VARS_NR_UE *ue,
         /* Skip rotation if the slot processing is wrong */
         if((!is_dmrs_symbol(i,*dmrsSymbPos)) && (ret == 0)) {
 #ifdef DEBUG_DL_PTRS
-          printf("[PHY][DL][PTRS]: Rotate Symbol %2d with  %d + j* %d\n", i, phase_per_symbol[2* i],phase_per_symbol[(2* i) +1]);
+          printf("[PHY][DL][PTRS]: Rotate Symbol %2d with  %d + j* %d\n", i, phase_per_symbol[i].r,phase_per_symbol[i].i);
 #endif
-          rotate_cpx_vector((int16_t*)&pdsch_vars[gNB_id]->rxdataF_comp0[aarx][(i * (*nb_rb) * NR_NB_SC_PER_RB)],
-                            &phase_per_symbol[2* i],
-                            (int16_t*)&pdsch_vars[gNB_id]->rxdataF_comp0[aarx][(i * (*nb_rb) * NR_NB_SC_PER_RB)],
+          rotate_cpx_vector((c16_t*)&pdsch_vars[gNB_id]->rxdataF_comp0[aarx][(i * (*nb_rb) * NR_NB_SC_PER_RB)],
+                            &phase_per_symbol[i],
+                            (c16_t*)&pdsch_vars[gNB_id]->rxdataF_comp0[aarx][(i * (*nb_rb) * NR_NB_SC_PER_RB)],
                             ((*nb_rb) * NR_NB_SC_PER_RB), 15);
         }// if not DMRS Symbol
       }// symbol loop

openair1/PHY/NR_UE_TRANSPORT/nr_transport_ue.h

@@ -342,7 +342,7 @@ typedef struct {
   /// Position of first CCE of the dci
   int firstCCE;
   /// flag to indicate that this is a RA response
-  boolean_t ra_flag;
+  bool ra_flag;
   /// rnti
   rnti_t rnti;
   /// rnti type

openair1/PHY/NR_UE_TRANSPORT/nr_ulsch_ue.c

@@ -597,17 +597,15 @@ uint8_t nr_ue_pusch_common_procedures(PHY_VARS_NR_UE *UE,
   int symb_offset = (slot%frame_parms->slots_per_subframe)*frame_parms->symbols_per_slot;
   for(ap = 0; ap < n_antenna_ports; ap++) {
     for (int s=0;s<NR_NUMBER_OF_SYMBOLS_PER_SLOT;s++){
+      c16_t rot=((c16_t*)frame_parms->symbol_rotation[1])[s + symb_offset];
+      LOG_D(PHY,"rotating txdataF symbol %d (%d) => (%d.%d)\n",
+	    s,
+	    s + symb_offset,
+	    rot.r, rot.i);
 
-      LOG_D(PHY,"In %s: rotating txdataF symbol %d (%d) => (%d.%d)\n",
-        __FUNCTION__,
-        s,
-        s + symb_offset,
-        frame_parms->symbol_rotation[1][2 * (s + symb_offset)],
-        frame_parms->symbol_rotation[1][1 + (2 * (s + symb_offset))]);
-
-      rotate_cpx_vector((int16_t *)&txdataF[ap][frame_parms->ofdm_symbol_size * s],
-                        &frame_parms->symbol_rotation[1][2 * (s + symb_offset)],
-                        (int16_t *)&txdataF[ap][frame_parms->ofdm_symbol_size * s],
+      rotate_cpx_vector((c16_t *)&txdataF[ap][frame_parms->ofdm_symbol_size * s],
+                        &rot,
+                        (c16_t *)&txdataF[ap][frame_parms->ofdm_symbol_size * s],
                         frame_parms->ofdm_symbol_size,
                         15);
     }

openair1/PHY/TOOLS/calibration_scope.c

@@ -34,7 +34,7 @@ typedef struct OAIgraph {
   int h;
   int waterFallh;
   double *waterFallAvg;
-  boolean_t initDone;
+  bool initDone;
   int iteration;
   void (*funct) (struct OAIgraph *graph, calibData_t *);
 } OAIgraph_t;
@@ -159,7 +159,7 @@ static void oai_xygraph_getbuff(OAIgraph_t *graph, float **x, float **y, int len
   *y=old_y;
 }
 
-static void oai_xygraph(OAIgraph_t *graph, float *x, float *y, int len, int layer, boolean_t NoAutoScale) {
+static void oai_xygraph(OAIgraph_t *graph, float *x, float *y, int len, int layer, bool NoAutoScale) {
   fl_redraw_object(graph->graph);
 
   if ( NoAutoScale && graph->iteration%NoAutoScale == 0) {

openair1/PHY/TOOLS/cmult_sv.c

@@ -144,207 +144,10 @@ void multadd_real_four_symbols_vector_complex_scalar(int16_t *x,
   _m_empty();
 
 }
-
-/*
-int rotate_cpx_vector(int16_t *x,
-                      int16_t *alpha,
-                      int16_t *y,
-                      uint32_t N,
-                      uint16_t output_shift,
-                      uint8_t format)
-{
-  // Multiply elementwise two complex vectors of N elements
-  // x        - input 1    in the format  |Re0  Im0 Re0 Im0|,......,|Re(N-1)  Im(N-1) Re(N-1) Im(N-1)|
-  //            We assume x1 with a dynamic of 15 bit maximum
-  //
-  // alpha      - input 2    in the format  |Re0 Im0|
-  //            We assume x2 with a dynamic of 15 bit maximum
-  //
-  // y        - output     in the format  |Re0  Im0 Re0 Im0|,......,|Re(N-1)  Im(N-1) Re(N-1) Im(N-1)|
-  //
-  // N        - the size f the vectors (this function does N cpx mpy. WARNING: N>=4;
-  //
-  // output_shift - shift at output to return in Q1.15
-  // format - 0 means alpha is in shuffled format, 1 means x is in shuffled format
-
-  uint32_t i;                 // loop counter
-
-  register __m128i m0,m1;
-
-
-
-  __m128i *x_128;
-  __m128i *y_128;
-
-
-  shift = _mm_cvtsi32_si128(output_shift);
-  x_128 = (__m128i *)&x[0];
-
-  if (format==0) {  // alpha is in shuffled format for complex multiply
-    ((int16_t *)&alpha_128)[0] = alpha[0];
-    ((int16_t *)&alpha_128)[1] = -alpha[1];
-    ((int16_t *)&alpha_128)[2] = alpha[1];
-    ((int16_t *)&alpha_128)[3] = alpha[0];
-    ((int16_t *)&alpha_128)[4] = alpha[0];
-    ((int16_t *)&alpha_128)[5] = -alpha[1];
-    ((int16_t *)&alpha_128)[6] = alpha[1];
-    ((int16_t *)&alpha_128)[7] = alpha[0];
-  } else { // input is in shuffled format for complex multiply
-    ((int16_t *)&alpha_128)[0] = alpha[0];
-    ((int16_t *)&alpha_128)[1] = alpha[1];
-    ((int16_t *)&alpha_128)[2] = alpha[0];
-    ((int16_t *)&alpha_128)[3] = alpha[1];
-    ((int16_t *)&alpha_128)[4] = alpha[0];
-    ((int16_t *)&alpha_128)[5] = alpha[1];
-    ((int16_t *)&alpha_128)[6] = alpha[0];
-    ((int16_t *)&alpha_128)[7] = alpha[1];
-  }
-
-  y_128 = (__m128i *)&y[0];
-
-  //  _mm_empty();
-  //  return(0);
-
-  // we compute 4 cpx multiply for each loop
-  for(i=0; i<(N>>3); i++) {
-
-    m0 = _mm_madd_epi16(x_128[0],alpha_128); //pmaddwd_r2r(mm1,mm0);         // 1- compute x1[0]*x2[0]
-    m0 = _mm_sra_epi32(m0,shift);        // 1- shift right by shift in order to  compensate for the input amplitude
-    m1=m0;
-    m0 = _mm_packs_epi32(m1,m0);        // 1- pack in a 128 bit register [re im re im]
-    y_128[0] = _mm_unpacklo_epi32(m0,m0);        // 1- pack in a 128 bit register [re im re im]
-    m0 = _mm_madd_epi16(x_128[1],alpha_128); //pmaddwd_r2r(mm1,mm0);         // 1- compute x1[0]*x2[0]
-    m0 = _mm_sra_epi32(m0,shift);        // 1- shift right by shift in order to  compensate for the input amplitude
-    m1 = m0;
-    m1 = _mm_packs_epi32(m1,m0);        // 1- pack in a 128 bit register [re im re im]
-    y_128[1] = _mm_unpacklo_epi32(m1,m1);        // 1- pack in a 128 bit register [re im re im]
-    m0 = _mm_madd_epi16(x_128[2],alpha_128); //pmaddwd_r2r(mm1,mm0);         // 1- compute x1[0]*x2[0]
-    m0 = _mm_sra_epi32(m0,shift);        // 1- shift right by shift in order to  compensate for the input amplitude
-    m1 = m0;
-    m1 = _mm_packs_epi32(m1,m0);        // 1- pack in a 128 bit register [re im re im]
-    y_128[2] = _mm_unpacklo_epi32(m1,m1);        // 1- pack in a 128 bit register [re im re im]
-    m0 = _mm_madd_epi16(x_128[3],alpha_128); //pmaddwd_r2r(mm1,mm0);         // 1- compute x1[0]*x2[0]
-    m0 = _mm_sra_epi32(m0,shift);        // 1- shift right by shift in order to  compensate for the input amplitude
-    m1 = m0;
-    m1 = _mm_packs_epi32(m1,m0);        // 1- pack in a 128 bit register [re im re im]
-    y_128[3] = _mm_unpacklo_epi32(m1,m1);        // 1- pack in a 128 bit register [re im re im]
-    if (format==1) {  // Put output in proper format (Re,-Im,Im,Re), shuffle = (0,1,3,2) = 0x1e
-
-      y_128[0] = _mm_shufflelo_epi16(y_128[0],0x1e);
-      y_128[0] = _mm_shufflehi_epi16(y_128[0],0x1e);
-      ((int16_t*)&y_128[0])[1] = -((int16_t*)&y_128[0])[1];
-      ((int16_t*)&y_128[0])[5] = -((int16_t*)&y_128[0])[5];
-      y_128[1] = _mm_shufflelo_epi16(y_128[1],0x1e);
-      y_128[1] = _mm_shufflehi_epi16(y_128[1],0x1e);
-      ((int16_t*)&y_128[1])[1] = -((int16_t*)&y_128[1])[1];
-      ((int16_t*)&y_128[1])[5] = -((int16_t*)&y_128[1])[5];
-      y_128[2] = _mm_shufflelo_epi16(y_128[2],0x1e);
-      y_128[2] = _mm_shufflehi_epi16(y_128[2],0x1e);
-      ((int16_t*)&y_128[2])[1] = -((int16_t*)&y_128[2])[1];
-      ((int16_t*)&y_128[2])[5] = -((int16_t*)&y_128[2])[5];
-      y_128[3] = _mm_shufflelo_epi16(y_128[3],0x1e);
-      y_128[3] = _mm_shufflehi_epi16(y_128[3],0x1e);
-      ((int16_t*)&y_128[3])[1] = -((int16_t*)&y_128[3])[1];
-      ((int16_t*)&y_128[3])[5] = -((int16_t*)&y_128[3])[5];
-    }
-
-
-    x_128+=4;
-    y_128 +=4;
-  }
-
-
-  _mm_empty();
-  _m_empty();
-
-  return(0);
-}
-
-int rotate_cpx_vector2(int16_t *x,
-                       int16_t *alpha,
-                       int16_t *y,
-                       uint32_t N,
-                       uint16_t output_shift,
-                       uint8_t format)
-{
-  // Multiply elementwise two complex vectors of N elements
-  // x        - input 1    in the format  |Re0  Im0 Re0 Im0|,......,|Re(N-1)  Im(N-1) Re(N-1) Im(N-1)|
-  //            We assume x1 with a dynamic of 15 bit maximum
-  //
-  // alpha      - input 2    in the format  |Re0 Im0|
-  //            We assume x2 with a dynamic of 15 bit maximum
-  //
-  // y        - output     in the format  |Re0  Im0 Re0 Im0|,......,|Re(N-1)  Im(N-1) Re(N-1) Im(N-1)|
-  //
-  // N        - the size f the vectors (this function does N cpx mpy. WARNING: N>=4;
-  //
-  // log2_amp - increase the output amplitude by a factor 2^log2_amp (default is 0)
-  //            WARNING: log2_amp>0 can cause overflow!!
-
-  uint32_t i;                 // loop counter
-
-  register __m128i m0,m1;
-
-
-  __m128i *x_128;
-  __m128i *y_128;
-
-
-  shift = _mm_cvtsi32_si128(output_shift);
-  x_128 = (__m128i *)&x[0];
-
-  if (format==0) {  // alpha is in shuffled format for complex multiply
-    ((int16_t *)&alpha_128)[0] = alpha[0];
-    ((int16_t *)&alpha_128)[1] = -alpha[1];
-    ((int16_t *)&alpha_128)[2] = alpha[1];
-    ((int16_t *)&alpha_128)[3] = alpha[0];
-    ((int16_t *)&alpha_128)[4] = alpha[0];
-    ((int16_t *)&alpha_128)[5] = -alpha[1];
-    ((int16_t *)&alpha_128)[6] = alpha[1];
-    ((int16_t *)&alpha_128)[7] = alpha[0];
-  } else { // input is in shuffled format for complex multiply
-    ((int16_t *)&alpha_128)[0] = alpha[0];
-    ((int16_t *)&alpha_128)[1] = alpha[1];
-    ((int16_t *)&alpha_128)[2] = alpha[0];
-    ((int16_t *)&alpha_128)[3] = alpha[1];
-    ((int16_t *)&alpha_128)[4] = alpha[0];
-    ((int16_t *)&alpha_128)[5] = alpha[1];
-    ((int16_t *)&alpha_128)[6] = alpha[0];
-    ((int16_t *)&alpha_128)[7] = alpha[1];
-  }
-
-  y_128 = (__m128i *)&y[0];
-
-  // we compute 4 cpx multiply for each loop
-  for(i=0; i<(N>>1); i++) {
-
-
-    m0 = _mm_madd_epi16(x_128[i],alpha_128); //pmaddwd_r2r(mm1,mm0);         // 1- compute x1[0]*x2[0]
-    m0 = _mm_sra_epi32(m0,shift);        // 1- shift right by shift in order to  compensate for the input amplitude
-    m1=m0;
-    m1 = _mm_packs_epi32(m1,m0);        // 1- pack in a 128 bit register [re im re im]
-    y_128[i] = _mm_unpacklo_epi32(m1,m1);        // 1- pack in a 128 bit register [re im re im]
-    if (format==1) {  // Put output in proper format (Re,-Im,Im,Re), shuffle = (0,1,3,2) = 0x1e
-
-      y_128[i] = _mm_shufflelo_epi16(y_128[i],0x1e);
-      y_128[i] = _mm_shufflehi_epi16(y_128[i],0x1e);
-      ((int16_t*)&y_128[i])[1] = -((int16_t*)&y_128[i])[1];
-      ((int16_t*)&y_128[i])[5] = -((int16_t*)&y_128[i])[5];
-    }
-  }
-
-
-  _mm_empty();
-  _m_empty();
-
-
-  return(0);
-}
-*/
-
-int rotate_cpx_vector(int16_t *x,
-                      int16_t *alpha,
-                      int16_t *y,
+#ifdef __AVX2__
+void rotate_cpx_vector(c16_t *x,
+                      c16_t *alpha,
+                      c16_t *y,
                       uint32_t N,
                       uint16_t output_shift)
 {
@@ -372,28 +175,28 @@ int rotate_cpx_vector(int16_t *x,
   __m128i shift = _mm_cvtsi32_si128(output_shift);
   register simd_q15_t m0,m1,m2,m3;
 
-  ((int16_t *)&alpha_128)[0] = alpha[0];
-  ((int16_t *)&alpha_128)[1] = -alpha[1];
-  ((int16_t *)&alpha_128)[2] = alpha[1];
-  ((int16_t *)&alpha_128)[3] = alpha[0];
-  ((int16_t *)&alpha_128)[4] = alpha[0];
-  ((int16_t *)&alpha_128)[5] = -alpha[1];
-  ((int16_t *)&alpha_128)[6] = alpha[1];
-  ((int16_t *)&alpha_128)[7] = alpha[0];
+  ((int16_t *)&alpha_128)[0] = alpha->r;
+  ((int16_t *)&alpha_128)[1] = -alpha->i;
+  ((int16_t *)&alpha_128)[2] = alpha->i;
+  ((int16_t *)&alpha_128)[3] = alpha->r;
+  ((int16_t *)&alpha_128)[4] = alpha->r;
+  ((int16_t *)&alpha_128)[5] = -alpha->i;
+  ((int16_t *)&alpha_128)[6] = alpha->i;
+  ((int16_t *)&alpha_128)[7] = alpha->r;
 #elif defined(__arm__)
   int32x4_t shift;
   int32x4_t ab_re0,ab_re1,ab_im0,ab_im1,re32,im32;
   int16_t reflip[8]  __attribute__((aligned(16))) = {1,-1,1,-1,1,-1,1,-1};
   int32x4x2_t xtmp;
 
-  ((int16_t *)&alpha_128)[0] = alpha[0];
-  ((int16_t *)&alpha_128)[1] = alpha[1];
-  ((int16_t *)&alpha_128)[2] = alpha[0];
-  ((int16_t *)&alpha_128)[3] = alpha[1];
-  ((int16_t *)&alpha_128)[4] = alpha[0];
-  ((int16_t *)&alpha_128)[5] = alpha[1];
-  ((int16_t *)&alpha_128)[6] = alpha[0];
-  ((int16_t *)&alpha_128)[7] = alpha[1];
+  ((int16_t *)&alpha_128)[0] = alpha->r;
+  ((int16_t *)&alpha_128)[1] = alpha->i;
+  ((int16_t *)&alpha_128)[2] = alpha->r;
+  ((int16_t *)&alpha_128)[3] = alpha->i;
+  ((int16_t *)&alpha_128)[4] = alpha->r;
+  ((int16_t *)&alpha_128)[5] = alpha->i;
+  ((int16_t *)&alpha_128)[6] = alpha->r;
+  ((int16_t *)&alpha_128)[7] = alpha->i;
   int16x8_t bflip = vrev32q_s16(alpha_128);
   int16x8_t bconj = vmulq_s16(alpha_128,*(int16x8_t *)reflip);
   shift = vdupq_n_s32(-output_shift);
@@ -439,9 +242,9 @@ int rotate_cpx_vector(int16_t *x,
   _mm_empty();
   _m_empty();
 
-  return(0);
+  return;
 }
-
+#endif
 /*
 int mult_vector32_scalar(int16_t *x1,
                          int x2,
@@ -536,7 +339,7 @@ main ()
   int16_t input[256] __attribute__((aligned(16)));
   int16_t input2[256] __attribute__((aligned(16)));
   int16_t output[256] __attribute__((aligned(16)));
-  int16_t alpha[2];
+  c16_t alpha;
 
   int i;
 
@@ -574,8 +377,8 @@ main ()
   input2[14] = 1000;
   input2[15] = 2000;
 
-  alpha[0]=32767;
-  alpha[1]=0;
+  alpha->r=32767;
+  alpha->i=0;
 
   //mult_cpx_vector(input,input2,output,L,0);
   rotate_cpx_vector_norep(input,alpha,input,L,15);

openair1/PHY/TOOLS/nr_phy_scope.c

@@ -60,7 +60,7 @@ typedef struct OAIgraph {
   int h;
   int waterFallh;
   double *waterFallAvg;
-  boolean_t initDone;
+  bool initDone;
   int iteration;
   void (*gNBfunct) (struct OAIgraph *graph, scopeData_t *p, int UE_id);
   void (*nrUEfunct)(scopeGraphData_t **data, struct OAIgraph *graph, PHY_VARS_NR_UE *phy_vars_ue, int eNB_id, int UE_id);
@@ -208,7 +208,7 @@ static void oai_xygraph_getbuff(OAIgraph_t *graph, float **x, float **y, int len
   *y=old_y;
 }
 
-static void oai_xygraph(OAIgraph_t *graph, float *x, float *y, int len, int layer, boolean_t NoAutoScale) {
+static void oai_xygraph(OAIgraph_t *graph, float *x, float *y, int len, int layer, bool NoAutoScale) {
   fl_redraw_object(graph->graph);
 
   if ( NoAutoScale && graph->iteration%NoAutoScale == 0) {

openair1/PHY/TOOLS/tools_defs.h

@@ -37,6 +37,7 @@ extern "C" {
 #include <stdint.h>
 #include <assert.h>
 #include "PHY/sse_intrin.h"
+#include "common/utils/assertions.h"
 
 #define CEILIDIV(a,b) ((a+b-1)/b)
 #define ROUNDIDIV(a,b) (((a<<1)+b)/(b<<1))
@@ -109,15 +110,6 @@ void multadd_complex_vector_real_scalar(int16_t *x,
                                         uint8_t zero_flag,
                                         uint32_t N);
 
-int rotate_cpx_vector(int16_t *x,
-                      int16_t *alpha,
-                      int16_t *y,
-                      uint32_t N,
-                      uint16_t output_shift);
-
-
-
-
 /*!\fn void init_fft(uint16_t size,uint8_t logsize,uint16_t *rev)
 \brief Initialize the FFT engine for a given size
 @param size Size of the FFT
@@ -466,7 +458,7 @@ idft_size_idx_t get_idft(int ofdm_symbol_size)
 }
 
 
-/*!\fn int32_t rotate_cpx_vector(int16_t *x,int16_t *alpha,int16_t *y,uint32_t N,uint16_t output_shift)
+/*!\fn int32_t rotate_cpx_vector(c16_t *x,c16_t *alpha,c16_t *y,uint32_t N,uint16_t output_shift)
 This function performs componentwise multiplication of a vector with a complex scalar.
 @param x Vector input (Q1.15)  in the format  |Re0  Im0|,......,|Re(N-1) Im(N-1)|
 @param alpha Scalar input (Q1.15) in the format  |Re0 Im0|
@@ -476,11 +468,11 @@ This function performs componentwise multiplication of a vector with a complex s
 
 The function implemented is : \f$\mathbf{y} = \alpha\mathbf{x}\f$
 */
-int32_t rotate_cpx_vector(int16_t *x,
-                          int16_t *alpha,
-                          int16_t *y,
-                          uint32_t N,
-                          uint16_t output_shift);
+void rotate_cpx_vector(c16_t *x,
+                       c16_t *alpha,
+                       c16_t *y,
+                       uint32_t N,
+                       uint16_t output_shift);
 
 
 //cadd_sv.c

openair1/PHY/defs_common.h

@@ -755,7 +755,7 @@ typedef struct {
   /// Position of first CCE of the dci
   int firstCCE;
   /// flag to indicate that this is a RA response
-  boolean_t ra_flag;
+  bool ra_flag;
   /// rnti
   rnti_t rnti;
   /// harq_pid
@@ -776,7 +776,7 @@ typedef struct {
   /// Position of first CCE of the dci
   int firstCCE;
   /// flag to indicate that this is a RA response
-  boolean_t ra_flag;
+  bool ra_flag;
   /// rnti
   rnti_t rnti;
   /// Format
@@ -807,7 +807,7 @@ typedef struct {
   /// Position of first CCE of the dci
   int firstCCE;
   /// flag to indicate that this is a RA response
-  boolean_t ra_flag;
+  bool ra_flag;
   /// rnti
   rnti_t rnti;
   /// Format

openair1/PHY/defs_nr_common.h

@@ -241,19 +241,9 @@ typedef struct {
 } NR_PRACH_RESOURCES_t;
 
 typedef struct {
-  uint8_t **k_0_p;
+  uint8_t k_0_p[MAX_NUM_NR_SRS_AP][MAX_NUM_NR_SRS_SYMBOLS];
   uint8_t srs_generated_signal_bits;
   int32_t **srs_generated_signal;
-  int32_t **srs_received_signal;
-  int32_t ***srs_ls_estimated_channel;
-  int32_t ***srs_estimated_channel_freq;
-  int32_t ***srs_estimated_channel_time;
-  int32_t ***srs_estimated_channel_time_shifted;
-  uint32_t signal_power;
-  uint32_t noise_power_per_rb[273];
-  uint32_t noise_power;
-  int8_t snr_per_rb[273];
-  int8_t snr;
 } nr_srs_info_t;
 
 typedef struct {
@@ -363,10 +353,10 @@ struct NR_DL_FRAME_PARMS {
   lte_prefix_type_t Ncp;
   /// sequence which is computed based on carrier frequency and numerology to rotate/derotate each OFDM symbol according to Section 5.3 in 38.211
   /// First dimension is for the direction of the link (0 DL, 1 UL)
-  int16_t symbol_rotation[2][224*2];
+  c16_t symbol_rotation[2][224];
   /// sequence used to compensate the phase rotation due to timeshifted OFDM symbols
   /// First dimenstion is for different CP lengths
-  int16_t timeshift_symbol_rotation[4096*2] __attribute__ ((aligned (16)));
+  c16_t timeshift_symbol_rotation[4096*2] __attribute__ ((aligned (16)));
   /// shift of pilot position in one RB
   uint8_t nushift;
   /// SRS configuration from TS 38.331 RRC

openair1/SCHED_NR/phy_procedures_nr_gNB.c

@@ -657,7 +657,8 @@ int fill_srs_channel_matrix(uint8_t *channel_matrix,
                             const uint16_t num_ue_srs_ports,
                             const uint16_t prg_size,
                             const uint16_t num_prgs,
-                            const NR_DL_FRAME_PARMS *frame_parms) {
+                            const NR_DL_FRAME_PARMS *frame_parms,
+                            const int32_t srs_estimated_channel_freq[][MAX_NUM_NR_SRS_AP][frame_parms->ofdm_symbol_size*(1<<srs_pdu->num_symbols)]) {
 
   const uint64_t subcarrier_offset = frame_parms->first_carrier_offset + srs_pdu->bwp_start*NR_NB_SC_PER_RB;
   const uint16_t step = prg_size*NR_NB_SC_PER_RB;
@@ -675,7 +676,7 @@ int fill_srs_channel_matrix(uint8_t *channel_matrix,
 
       for(int pI = 0; pI < num_prgs; pI++) {
 
-        c16_t *srs_estimated_channel16 = (c16_t *)&nr_srs_info->srs_estimated_channel_freq[gI][uI][subcarrier];
+        c16_t *srs_estimated_channel16 = (c16_t *)&srs_estimated_channel_freq[gI][uI][subcarrier];
         uint16_t index = uI*num_gnb_antenna_elements*num_prgs + gI*num_prgs + pI;
 
         if (normalized_iq_representation == 0) {
@@ -702,6 +703,7 @@ int phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx) {
   /* those variables to log T_GNB_PHY_PUCCH_PUSCH_IQ only when we try to decode */
   int pucch_decode_done = 0;
   int pusch_decode_done = 0;
+  int phy_procedures_errors = 0;
 
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_gNB_UESPEC_RX,1);
   LOG_D(PHY,"phy_procedures_gNB_uespec_RX frame %d, slot %d\n",frame_rx,slot_rx);
@@ -841,7 +843,8 @@ int phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx) {
           if (no_sig) {
             LOG_D(PHY, "PUSCH not detected in frame %d, slot %d\n", frame_rx, slot_rx);
             nr_fill_indication(gNB, frame_rx, slot_rx, ULSCH_id, harq_pid, 1,1);
-            return 1;
+            phy_procedures_errors++;
+            continue;
           }
           gNB->pusch_vars[ULSCH_id]->ulsch_power_tot=0;
           gNB->pusch_vars[ULSCH_id]->ulsch_noise_power_tot=0;
@@ -865,7 +868,8 @@ int phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx) {
                /* in case of phy_test mode, we still want to decode to measure execution time. 
                   Therefore, we don't yet call nr_fill_indication, it will be called later */
                nr_fill_indication(gNB,frame_rx, slot_rx, ULSCH_id, harq_pid, 1,1);
-               return 1;
+               phy_procedures_errors++;
+               continue;
              }
           } else {
             LOG_D(PHY, "PUSCH detected in %d.%d (%d,%d,%d)\n",frame_rx,slot_rx,
@@ -896,14 +900,26 @@ int phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx) {
 
         LOG_D(NR_PHY, "(%d.%d) gNB is waiting for SRS, id = %i\n", frame_rx, slot_rx, i);
 
+        NR_DL_FRAME_PARMS *frame_parms = &gNB->frame_parms;
         nfapi_nr_srs_pdu_t *srs_pdu = &srs->srs_pdu;
+        uint8_t N_symb_SRS = 1<<srs_pdu->num_symbols;
+        int32_t srs_received_signal[frame_parms->nb_antennas_rx][frame_parms->ofdm_symbol_size*N_symb_SRS];
+        int32_t srs_ls_estimated_channel[frame_parms->nb_antennas_rx][MAX_NUM_NR_SRS_AP][frame_parms->ofdm_symbol_size*N_symb_SRS];
+        int32_t srs_estimated_channel_freq[frame_parms->nb_antennas_rx][MAX_NUM_NR_SRS_AP][frame_parms->ofdm_symbol_size*N_symb_SRS];
+        int32_t srs_estimated_channel_time[frame_parms->nb_antennas_rx][MAX_NUM_NR_SRS_AP][frame_parms->ofdm_symbol_size];
+        int32_t srs_estimated_channel_time_shifted[frame_parms->nb_antennas_rx][MAX_NUM_NR_SRS_AP][frame_parms->ofdm_symbol_size];
+        uint32_t noise_power_per_rb[srs_pdu->bwp_size];
+        int8_t snr_per_rb[srs_pdu->bwp_size];
+        uint32_t signal_power;
+        uint32_t noise_power;
+        int8_t snr;
 
         // At least currently, the configuration is constant, so it is enough to generate the sequence just once.
         if(gNB->nr_srs_info[i]->srs_generated_signal_bits == 0) {
-          generate_srs_nr(srs_pdu, &gNB->frame_parms, gNB->nr_srs_info[i]->srs_generated_signal, 0, gNB->nr_srs_info[i], AMP, frame_rx, slot_rx);
+          generate_srs_nr(srs_pdu, frame_parms, gNB->nr_srs_info[i]->srs_generated_signal, 0, gNB->nr_srs_info[i], AMP, frame_rx, slot_rx);
         }
 
-        const int srs_est = nr_get_srs_signal(gNB,frame_rx,slot_rx,srs_pdu, gNB->nr_srs_info[i], gNB->nr_srs_info[i]->srs_received_signal);
+        const int srs_est = nr_get_srs_signal(gNB,frame_rx,slot_rx, srs_pdu, gNB->nr_srs_info[i], srs_received_signal);
 
         if (srs_est >= 0) {
           nr_srs_channel_estimation(gNB,
@@ -911,23 +927,24 @@ int phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx) {
                                     slot_rx,
                                     srs_pdu,
                                     gNB->nr_srs_info[i],
-                                    (const int32_t **)gNB->nr_srs_info[i]->srs_generated_signal,
-                                    (const int32_t **)gNB->nr_srs_info[i]->srs_received_signal,
-                                    gNB->nr_srs_info[i]->srs_estimated_channel_freq,
-                                    gNB->nr_srs_info[i]->srs_estimated_channel_time,
-                                    gNB->nr_srs_info[i]->srs_estimated_channel_time_shifted,
-                                    &gNB->nr_srs_info[i]->signal_power,
-                                    gNB->nr_srs_info[i]->noise_power_per_rb,
-                                    &gNB->nr_srs_info[i]->noise_power,
-                                    gNB->nr_srs_info[i]->snr_per_rb,
-                                    &gNB->nr_srs_info[i]->snr);
+                                    (const int32_t **) gNB->nr_srs_info[i]->srs_generated_signal,
+                                    srs_received_signal,
+                                    srs_ls_estimated_channel,
+                                    srs_estimated_channel_freq,
+                                    srs_estimated_channel_time,
+                                    srs_estimated_channel_time_shifted,
+                                    &signal_power,
+                                    noise_power_per_rb,
+                                    &noise_power,
+                                    snr_per_rb,
+                                    &snr);
         }
 
         T(T_GNB_PHY_UL_FREQ_CHANNEL_ESTIMATE, T_INT(0), T_INT(srs_pdu->rnti), T_INT(frame_rx), T_INT(0), T_INT(0),
-          T_BUFFER(gNB->nr_srs_info[i]->srs_estimated_channel_freq[0][0], gNB->frame_parms.ofdm_symbol_size*sizeof(int32_t)));
+          T_BUFFER(srs_estimated_channel_freq[0][0], frame_parms->ofdm_symbol_size*sizeof(int32_t)));
 
         T(T_GNB_PHY_UL_TIME_CHANNEL_ESTIMATE, T_INT(0), T_INT(srs_pdu->rnti), T_INT(frame_rx), T_INT(0), T_INT(0),
-          T_BUFFER(gNB->nr_srs_info[i]->srs_estimated_channel_time_shifted[0][0], gNB->frame_parms.ofdm_symbol_size*sizeof(int32_t)));
+          T_BUFFER(srs_estimated_channel_time_shifted[0][0], frame_parms->ofdm_symbol_size*sizeof(int32_t)));
 
         const uint16_t num_srs = gNB->UL_INFO.srs_ind.number_of_pdus;
         gNB->UL_INFO.srs_ind.pdu_list = &gNB->srs_pdu_list[0];
@@ -935,8 +952,8 @@ int phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx) {
         gNB->UL_INFO.srs_ind.slot = slot_rx;
         gNB->srs_pdu_list[num_srs].handle = srs_pdu->handle;
         gNB->srs_pdu_list[num_srs].rnti = srs_pdu->rnti;
-        gNB->srs_pdu_list[num_srs].timing_advance_offset = srs_est >= 0 ? nr_est_timing_advance_srs(&gNB->frame_parms,
-                                                                                                    (const int32_t **)gNB->nr_srs_info[i]->srs_estimated_channel_time[0]) : 0xFFFF;
+        gNB->srs_pdu_list[num_srs].timing_advance_offset = srs_est >= 0 ? nr_est_timing_advance_srs(frame_parms,
+                                                                                                    srs_estimated_channel_time[0]) : 0xFFFF;
         gNB->srs_pdu_list[num_srs].timing_advance_offset_nsec = srs_est >= 0 ? (int16_t)(( ((int32_t)gNB->srs_pdu_list[num_srs].timing_advance_offset-31) * ((int32_t)TC_NSEC_x32768) ) >> 15) : 0xFFFF;
         switch (srs_pdu->srs_parameters_v4.usage) {
           case 0:
@@ -982,13 +999,13 @@ int phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx) {
             nfapi_nr_srs_beamforming_report_t nr_srs_beamforming_report;
             nr_srs_beamforming_report.prg_size = srs_pdu->beamforming.prg_size;
             nr_srs_beamforming_report.num_symbols = 1<<srs_pdu->num_symbols;
-            nr_srs_beamforming_report.wide_band_snr = srs_est >= 0 ? (gNB->nr_srs_info[i]->snr + 64)<<1 : 0xFF; // 0xFF will be set if this field is invalid
+            nr_srs_beamforming_report.wide_band_snr = srs_est >= 0 ? (snr + 64)<<1 : 0xFF; // 0xFF will be set if this field is invalid
             nr_srs_beamforming_report.num_reported_symbols = 1<<srs_pdu->num_symbols;
             nr_srs_beamforming_report.prgs = (nfapi_nr_srs_reported_symbol_t*) calloc(1, nr_srs_beamforming_report.num_reported_symbols*sizeof(nfapi_nr_srs_reported_symbol_t));
             fill_srs_reported_symbol_list(&nr_srs_beamforming_report.prgs[0],
                                           srs_pdu,
-                                          gNB->frame_parms.N_RB_UL,
-                                          gNB->nr_srs_info[i]->snr_per_rb,
+                                          frame_parms->N_RB_UL,
+                                          snr_per_rb,
                                           srs_est);
 
 #ifdef SRS_IND_DEBUG
@@ -1027,7 +1044,8 @@ int phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx) {
                                     nr_srs_normalized_channel_iq_matrix.num_ue_srs_ports,
                                     nr_srs_normalized_channel_iq_matrix.prg_size,
                                     nr_srs_normalized_channel_iq_matrix.num_prgs,
-                                    &gNB->frame_parms);
+                                    &gNB->frame_parms,
+                                    srs_estimated_channel_freq);
 
 #ifdef SRS_IND_DEBUG
             LOG_I(NR_PHY, "nr_srs_normalized_channel_iq_matrix.normalized_iq_representation = %i\n", nr_srs_normalized_channel_iq_matrix.normalized_iq_representation);
@@ -1088,5 +1106,5 @@ int phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx) {
   }
 
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_gNB_UESPEC_RX,0);
-  return 0;
+  return phy_procedures_errors;
 }

openair1/SCHED_UE/phy_procedures_lte_ue.c

@@ -460,7 +460,7 @@ void ue_compute_srs_occasion(PHY_VARS_UE *ue,
       is_pucch2_subframe = (is_ri_TXOp(ue,proc,eNB_id) && (ue->cqi_report_config[eNB_id].CQI_ReportPeriodic.ri_ConfigIndex>0)) || is_pucch2_subframe;
 
       // check ACK/SR transmission
-      if(frame_parms->soundingrs_ul_config_common.ackNackSRS_SimultaneousTransmission == FALSE) {
+      if(frame_parms->soundingrs_ul_config_common.ackNackSRS_SimultaneousTransmission == false) {
         if(is_SR_TXOp(ue,proc,eNB_id)) {
           uint32_t SR_payload = 0;
 

openair1/SIMULATION/NR_UE_PHY/unit_tests/src/pucch_uci_test.c

@@ -165,7 +165,7 @@ void common_pucch_configuration(PHY_VARS_NR_UE *ue, uint8_t gNB_id, int pucch_in
 int test_pucch_basic_error(PHY_VARS_NR_UE *ue, int gNB_id, UE_nr_rxtx_proc_t *proc)
 {
   int v_return = 0;
-  bool reset_harq = FALSE;
+  bool reset_harq = false;
 
   printf("%s", tst_separator);
 
@@ -175,7 +175,7 @@ int test_pucch_basic_error(PHY_VARS_NR_UE *ue, int gNB_id, UE_nr_rxtx_proc_t *pr
 
   common_pucch_configuration(ue, gNB_id, TST_PUCCH_COMMON_CONFIG_INDEX_KO);
 
-  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != FALSE) {
+  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != false) {
     v_return = -1;
   }
 
@@ -186,7 +186,7 @@ int test_pucch_basic_error(PHY_VARS_NR_UE *ue, int gNB_id, UE_nr_rxtx_proc_t *pr
 
   printf("\n  => Test : Error due to acknownlegment not set \n");
 
-  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != FALSE) {
+  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != false) {
     v_return = -1;
   }
 
@@ -194,7 +194,7 @@ int test_pucch_basic_error(PHY_VARS_NR_UE *ue, int gNB_id, UE_nr_rxtx_proc_t *pr
 
   printf("\n  => Test : Error due to DAI not set \n");
 
-  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != FALSE) {
+  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != false) {
     v_return = -1;
   }
 
@@ -202,7 +202,7 @@ int test_pucch_basic_error(PHY_VARS_NR_UE *ue, int gNB_id, UE_nr_rxtx_proc_t *pr
 
   harq_status->vDAI_DL = NR_DL_MAX_DAI + 1;
 
-  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != FALSE) {
+  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != false) {
     v_return = -1;
   }
 
@@ -210,7 +210,7 @@ int test_pucch_basic_error(PHY_VARS_NR_UE *ue, int gNB_id, UE_nr_rxtx_proc_t *pr
 
   harq_status->vDAI_DL = 0;
 
-  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != FALSE) {
+  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != false) {
     v_return = -1;
   }
 
@@ -218,7 +218,7 @@ int test_pucch_basic_error(PHY_VARS_NR_UE *ue, int gNB_id, UE_nr_rxtx_proc_t *pr
 
   harq_status->send_harq_status = 1;  /* ack ready to be send */
 
-  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != FALSE) {
+  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != false) {
     v_return = -1;
   }
 
@@ -228,7 +228,7 @@ int test_pucch_basic_error(PHY_VARS_NR_UE *ue, int gNB_id, UE_nr_rxtx_proc_t *pr
 
   harq_status->vDAI_DL = 1;
 
-  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != FALSE) {
+  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != false) {
     v_return = -1;
   }
 
@@ -236,7 +236,7 @@ int test_pucch_basic_error(PHY_VARS_NR_UE *ue, int gNB_id, UE_nr_rxtx_proc_t *pr
 
   printf("\n  => Test : Error due to PUCCH format with multiple cells not already implemented \n");
 
-  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != FALSE) {
+  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != false) {
     v_return = -1;
   }
 
@@ -260,7 +260,7 @@ int test_pucch_basic_error(PHY_VARS_NR_UE *ue, int gNB_id, UE_nr_rxtx_proc_t *pr
 int test_pucch_common_config_single_transport_block(PHY_VARS_NR_UE *ue, int gNB_id, UE_nr_rxtx_proc_t *proc)
 {
   int v_return = 0;
-  bool reset_harq = FALSE;
+  bool reset_harq = false;
 
   printf("%s", tst_separator);
 
@@ -273,7 +273,7 @@ int test_pucch_common_config_single_transport_block(PHY_VARS_NR_UE *ue, int gNB_
 
   printf("\n  => Test : PUCCH format from common config in prach mode: one positive downlink ACKnowledgment \n");
 
-  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != TRUE) {
+  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != true) {
    v_return = -1;
   }
 
@@ -281,7 +281,7 @@ int test_pucch_common_config_single_transport_block(PHY_VARS_NR_UE *ue, int gNB_
 
   printf("\n  => Test : PUCCH format from common config in prach mode: one negative downlink ACKnowledgment \n");
 
-  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != TRUE) {
+  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != true) {
    v_return = -1;
   }
 
@@ -304,7 +304,7 @@ int test_pucch_common_config_single_transport_block(PHY_VARS_NR_UE *ue, int gNB_
 
   printf("\n  => Test : PUCCH format from common config in dedicated mode: two positive downlink ACKnowledgments \n");
 
-  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != TRUE) {
+  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != true) {
     v_return = -1;
   }
 
@@ -312,7 +312,7 @@ int test_pucch_common_config_single_transport_block(PHY_VARS_NR_UE *ue, int gNB_
 
   printf("\n  => Test : PUCCH format from common config in dedicated mode: one positive and one negative downlink ACKnowledgments \n");
 
-  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != TRUE) {
+  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != true) {
     v_return = -1;
   }
 
@@ -320,22 +320,22 @@ int test_pucch_common_config_single_transport_block(PHY_VARS_NR_UE *ue, int gNB_
 
   printf("\n  => Test : PUCCH format from common config in dedicated mode: two negative downlink ACKnowledgments \n");
 
-  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != TRUE) {
+  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != true) {
     v_return = -1;
   }
 
   harq_status->ack = DL_ACK;
-  reset_harq = TRUE;
+  reset_harq = true;
 
   printf("\n  => Test : PUCCH format from common config in dedicated mode: no resource is found \n");
 
-  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != FALSE) {
+  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != false) {
     v_return = -1;
   }
 
   printf("\n  => Test : PUCCH format from common config in dedicated mode: no PUCCH after reset of pending harq ACKnowledgments \n");
 
-  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != FALSE) {
+  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != false) {
     v_return = -1;
   }
 
@@ -362,7 +362,7 @@ void init_pucch_dedicated_configuration(PHY_VARS_NR_UE *ue, uint8_t gNB_id)
   int i,j;
 
   /* set cell group parameters which are supported */
-  ue->cell_group_config.physicalCellGroupConfig.harq_ACK_SpatialBundlingPUCCH = FALSE;
+  ue->cell_group_config.physicalCellGroupConfig.harq_ACK_SpatialBundlingPUCCH = false;
   ue->cell_group_config.physicalCellGroupConfig.pdsch_HARQ_ACK_Codebook = dynamic;
 
   ue->PDSCH_ServingCellConfig.codeBlockGroupTransmission = NULL;
@@ -554,7 +554,7 @@ int test_pucch_dedicated_single_transport_block(PHY_VARS_NR_UE *ue, int gNB_id,
 #define   TST_NB_STEP_SINGLE_TRANSPORT_BLOCK      (4)
 
   int v_return = 0;
-  int reset_harq = FALSE;
+  int reset_harq = false;
   int dl_harq_pid[TST_NB_STEP_SINGLE_TRANSPORT_BLOCK] = {TST_DL_HARQ_PID_FIRST, TST_DL_HARQ_PID_SECOND, TST_DL_HARQ_PID_THIRD, TST_DL_HARQ_PID_FOURTH };
   int pucch_resource_indicator[TST_NB_STEP_SINGLE_TRANSPORT_BLOCK][2] = { { 0, 4 }, { 1, 0 } , { 1, 3 } , { 5, 7 } };
   NR_UE_HARQ_STATUS_t *harq_status;
@@ -575,7 +575,7 @@ int test_pucch_dedicated_single_transport_block(PHY_VARS_NR_UE *ue, int gNB_id,
 
   printf("\n  => Test : PUCCH format from dedicated config : pucch resource indicator is invalid \n");
 
-  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != FALSE) {
+  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != false) {
     v_return = -1;
   }
 
@@ -595,14 +595,14 @@ int test_pucch_dedicated_single_transport_block(PHY_VARS_NR_UE *ue, int gNB_id,
 
       /* reset ack context on last test */
       if ((i == (TST_NB_STEP_SINGLE_TRANSPORT_BLOCK-1)) && (j == 1)) {
-        reset_harq = TRUE;
+        reset_harq = true;
       }
 
       harq_status->pucch_resource_indicator = pucch_resource_indicator[i][j];
 
       printf("\n  => Test : PUCCH format from dedicated config with 1 transport block : with %d downlink ACKnowledgments and pucch resource indicator %d \n", i+1, pucch_resource_indicator[i][j]);
 
-      if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != TRUE) {
+      if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != true) {
         v_return = -1;
       }
     }
@@ -627,11 +627,11 @@ int test_pucch_dedicated_single_transport_block(PHY_VARS_NR_UE *ue, int gNB_id,
     harq_status->pucch_resource_indicator = pucch_resource_indicator[i][0];
   }
 
-  reset_harq = TRUE;
+  reset_harq = true;
 
   printf("\n  => Test : PUCCH format from dedicated config with 1 transport block and missed PDSCH : with %d downlink ACKnowledgments and pucch resource indicator %d \n", i+1, pucch_resource_indicator[3][0]);
 
-  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != TRUE) {
+  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != true) {
     v_return = -1;
   }
 
@@ -659,7 +659,7 @@ int test_pucch_dedicated_two_transport_blocks(PHY_VARS_NR_UE *ue, int gNB_id, UE
 #define   TST_NB_STEP_TWO_TRANSPORT_BLOCKS      (4)
 
   int v_return = 0;
-  int reset_harq = FALSE;
+  int reset_harq = false;
   int dl_harq_pid[TST_NB_STEP_TWO_TRANSPORT_BLOCKS] = {TST_DL_HARQ_PID_FIRST, TST_DL_HARQ_PID_SECOND, TST_DL_HARQ_PID_THIRD, TST_DL_HARQ_PID_FOURTH };
   int pucch_resource_indicator[TST_NB_STEP_TWO_TRANSPORT_BLOCKS][2] = { { 0, 1 }, { 3, 7 } , { 2 , 4 } , { 4 , 6 } };
   NR_UE_HARQ_STATUS_t *harq_status;
@@ -694,7 +694,7 @@ int test_pucch_dedicated_two_transport_blocks(PHY_VARS_NR_UE *ue, int gNB_id, UE
 
       /* reset ack context on last test */
       if ((i == (TST_NB_STEP_TWO_TRANSPORT_BLOCKS-1)) && (j == 1)) {
-        reset_harq = TRUE;
+        reset_harq = true;
       }
 
       harq_status = &ue->dlsch[proc->thread_id][gNB_id][0]->harq_processes[dl_harq_pid[i]].harq_ack;
@@ -703,7 +703,7 @@ int test_pucch_dedicated_two_transport_blocks(PHY_VARS_NR_UE *ue, int gNB_id, UE
 
       printf("\n  => Test : PUCCH format from dedicated config with 2 transport blocks : with %d downlink ACKnowledgments and pucch resource indicator %d \n", i+1, pucch_resource_indicator[i][j]);
 
-      if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != TRUE) {
+      if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != true) {
         printf("Test fail \n");
         v_return = -1;
       }
@@ -714,7 +714,7 @@ int test_pucch_dedicated_two_transport_blocks(PHY_VARS_NR_UE *ue, int gNB_id, UE
   /* some transport blocks have been missed and they need to be nack by UE in order to be retransmitted by the network */
   /* here first and third block receptions have been missed */
 
-  reset_harq = TRUE;
+  reset_harq = true;
 
   for (int i = 1; i < TST_NB_STEP_TWO_TRANSPORT_BLOCKS; i = i + 1) {
 
@@ -743,7 +743,7 @@ int test_pucch_dedicated_two_transport_blocks(PHY_VARS_NR_UE *ue, int gNB_id, UE
 
   printf("\n  => Test : PUCCH format from dedicated config with 2 transport blocks and 1 missed PDSCH : with %d downlink ACKnowledgments and pucch resource indicator %d \n", 4, pucch_resource_indicator[3][0]);
 
-  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != TRUE) {
+  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != true) {
     printf("Test fail \n");
     v_return = -1;
   }
@@ -775,7 +775,7 @@ int test_pucch_dedicated_two_transport_blocks(PHY_VARS_NR_UE *ue, int gNB_id, UE
     }
   }
 
-  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != TRUE) {
+  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != true) {
    printf("Test fail \n");
    v_return = -1;
   }
@@ -907,7 +907,7 @@ int test_sr_alone_dedicated(PHY_VARS_NR_UE *ue, int gNB_id, UE_nr_rxtx_proc_t *p
 
   tst_scheduling_request_payload = 0;
 
-  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != FALSE) {
+  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != false) {
    printf("Test fail \n");
    v_return = -1;
   }
@@ -916,7 +916,7 @@ int test_sr_alone_dedicated(PHY_VARS_NR_UE *ue, int gNB_id, UE_nr_rxtx_proc_t *p
 
   tst_scheduling_request_payload = 1;
 
-  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != TRUE) {
+  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != true) {
     printf("Test fail \n");
     v_return = -1;
   }
@@ -929,7 +929,7 @@ int test_sr_alone_dedicated(PHY_VARS_NR_UE *ue, int gNB_id, UE_nr_rxtx_proc_t *p
 
   tst_scheduling_request_payload = 1;
 
-  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != TRUE) {
+  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != true) {
     printf("Test fail \n");
     v_return = -1;
   }
@@ -958,7 +958,7 @@ int test_sr_alone_dedicated(PHY_VARS_NR_UE *ue, int gNB_id, UE_nr_rxtx_proc_t *p
 int test_sr_ack_dedicated(PHY_VARS_NR_UE *ue, int gNB_id, UE_nr_rxtx_proc_t *proc)
 {
   int v_return = 0;
-  int reset_harq = 0;
+  bool reset_harq = false;
   int sr_config_id = 0;
   int sr_resource_id = 0;
   int sr_offset = 0;
@@ -988,7 +988,7 @@ int test_sr_ack_dedicated(PHY_VARS_NR_UE *ue, int gNB_id, UE_nr_rxtx_proc_t *pro
 
   tst_scheduling_request_payload = 0;  /* set sr payload */
 
-  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != TRUE) {
+  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != true) {
     printf("Test fail \n");
     v_return = -1;
   }
@@ -997,7 +997,7 @@ int test_sr_ack_dedicated(PHY_VARS_NR_UE *ue, int gNB_id, UE_nr_rxtx_proc_t *pro
 
   tst_scheduling_request_payload = 1;  /* set sr payload */
 
-  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != TRUE) {
+  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != true) {
    printf("Test fail \n");
    v_return = -1;
   }
@@ -1006,7 +1006,7 @@ int test_sr_ack_dedicated(PHY_VARS_NR_UE *ue, int gNB_id, UE_nr_rxtx_proc_t *pro
 
   harq_status->pucch_resource_indicator = pucch_resource_indicator[1];
 
-  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != TRUE) {
+  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != true) {
     printf("Test fail \n");
     v_return = -1;
   }
@@ -1027,7 +1027,7 @@ int test_sr_ack_dedicated(PHY_VARS_NR_UE *ue, int gNB_id, UE_nr_rxtx_proc_t *pro
 
   tst_scheduling_request_payload = 1;  /* set sr payload */
 
-  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != TRUE) {
+  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != true) {
     printf("Test fail \n");
     v_return = -1;
   }
@@ -1035,9 +1035,9 @@ int test_sr_ack_dedicated(PHY_VARS_NR_UE *ue, int gNB_id, UE_nr_rxtx_proc_t *pro
   printf("\n  => Test : PUCCH format from dedicated config with a positive scheduling request and two positive acks \n");
 
   harq_status->pucch_resource_indicator = pucch_resource_indicator[1];
-  reset_harq = TRUE;
+  reset_harq = true;
 
-  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != TRUE) {
+  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != true) {
    printf("Test fail \n");
    v_return = -1;
   }
@@ -1065,7 +1065,7 @@ int test_sr_ack_dedicated(PHY_VARS_NR_UE *ue, int gNB_id, UE_nr_rxtx_proc_t *pro
 int test_csi_dedicated(PHY_VARS_NR_UE *ue, int gNB_id, UE_nr_rxtx_proc_t *proc)
 {
   int v_return = 0;
-  int reset_harq = FALSE;
+  int reset_harq = false;
   int sr_config_id = 0;
   int sr_resource_id = 0;
   int sr_offset = 0;
@@ -1079,7 +1079,7 @@ int test_csi_dedicated(PHY_VARS_NR_UE *ue, int gNB_id, UE_nr_rxtx_proc_t *proc)
 
   printf("\n  => Test : PUCCH format from dedicated config with CSI alone \n");
 
-  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != TRUE) {
+  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != true) {
     printf("Test fail \n");
     v_return = -1;
   }
@@ -1102,7 +1102,7 @@ int test_csi_dedicated(PHY_VARS_NR_UE *ue, int gNB_id, UE_nr_rxtx_proc_t *proc)
 
   ue->pucch_config_dedicated_nr[gNB_id].formatConfig[2-1]->simultaneousHARQ_ACK_CSI = enable_feature; /* format 2 */
 
-  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != TRUE) {
+  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != true) {
     printf("Test fail \n");
     v_return = -1;
   }
@@ -1115,9 +1115,9 @@ int test_csi_dedicated(PHY_VARS_NR_UE *ue, int gNB_id, UE_nr_rxtx_proc_t *proc)
 
   tst_scheduling_request_payload = 0;  /* set sr payload */
 
-  reset_harq = TRUE;
+  reset_harq = true;
 
-  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != TRUE) {
+  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != true) {
     printf("Test fail \n");
     v_return = -1;
   }
@@ -1126,7 +1126,7 @@ int test_csi_dedicated(PHY_VARS_NR_UE *ue, int gNB_id, UE_nr_rxtx_proc_t *proc)
 
   harq_status->pucch_resource_indicator = pucch_resource_indicator[4];
 
-  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != TRUE) {
+  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != true) {
     printf("Test fail \n");
     v_return = -1;
   }
@@ -1135,7 +1135,7 @@ int test_csi_dedicated(PHY_VARS_NR_UE *ue, int gNB_id, UE_nr_rxtx_proc_t *proc)
 
   printf("\n  => Test : PUCCH format from dedicated config with positive SR and CSI \n");
 
-  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != TRUE) {
+  if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != true) {
     printf("Test fail \n");
     v_return = -1;
   }

openair2/COMMON/commonDef.h

@@ -43,27 +43,6 @@ Description Contains global common definitions
 #include <stddef.h>
 #include <stdbool.h>
 
-/* boolean_t is also defined in openair2/COMMON/platform_types.h
- * let's protect potential redefinition
- */
-
-#ifndef _BOOLEAN_T_DEFINED_
-#define _BOOLEAN_T_DEFINED_
-
-typedef signed char        boolean_t;
-
-#if !defined(TRUE)
-#define TRUE               (boolean_t)0x01
-#endif
-
-#if !defined(FALSE)
-#define FALSE              (boolean_t)0x00
-#endif
-
-#define BOOL_NOT(b) (b^TRUE)
-
-#endif /* _BOOLEAN_T_DEFINED_ */
-
 #define NAS_UE_ID_FMT "0x%06x"
 
 /****************************************************************************/

openair2/COMMON/mac_rlc_primitives.h

@@ -145,7 +145,7 @@ struct mac_tx_tb_management {
 struct mac_rx_tb_management {
   unsigned char             *data_ptr;
   tb_size_t                  tb_size;      // in bits
-  boolean_t                  valid_checksum;
+  bool                       valid_checksum;
   unsigned char              first_bit;    // 0 if data starts on byte boundary(b7), 1 if b6, 2 if b5, etc
 };
 

openair2/COMMON/platform_types.h

@@ -32,35 +32,12 @@
 
 #if !defined(NAS_NETLINK)
 #include <stdint.h>
+#include <stdbool.h>
 #else
 #include <linux/types.h>
 typedef void * intptr_t;
 #endif
 
-//-----------------------------------------------------------------------------
-// GENERIC TYPES
-//-----------------------------------------------------------------------------
-
-/* boolean_t is also defined in openair2/COMMON/commonDef.h,
- * let's protect potential redefinition
- */
-#ifndef _BOOLEAN_T_DEFINED_
-  #define _BOOLEAN_T_DEFINED_
-
-  typedef signed char        boolean_t;
-
-  #if !defined(TRUE)
-    #define TRUE               (boolean_t)0x01
-  #endif
-
-  #if !defined(FALSE)
-    #define FALSE              (boolean_t)0x00
-  #endif
-
-  #define BOOL_NOT(b) (b^TRUE)
-
-#endif /* _BOOLEAN_T_DEFINED_ */
-
 //-----------------------------------------------------------------------------
 // GENERIC ACCESS STRATUM TYPES
 //-----------------------------------------------------------------------------
@@ -77,25 +54,25 @@ typedef int16_t               smodule_id_t;
 typedef long              rb_id_t;
 typedef long              srb_id_t;
 
-typedef boolean_t             MBMS_flag_t;
-#define  MBMS_FLAG_NO         FALSE
-#define  MBMS_FLAG_YES        TRUE
+typedef bool MBMS_flag_t;
+#define MBMS_FLAG_NO  false
+#define MBMS_FLAG_YES true
 
-typedef boolean_t             eNB_flag_t;
-#define  ENB_FLAG_NO          FALSE
-#define  ENB_FLAG_YES         TRUE
+typedef bool eNB_flag_t;
+#define ENB_FLAG_NO  false
+#define ENB_FLAG_YES true
 
-typedef boolean_t             gNB_flag_t;
-#define  GNB_FLAG_NO          FALSE
-#define  GNB_FLAG_YES         TRUE
+typedef bool gNB_flag_t;
+#define GNB_FLAG_NO  false
+#define GNB_FLAG_YES true
 
-typedef boolean_t             srb_flag_t;
-#define  SRB_FLAG_NO          FALSE
-#define  SRB_FLAG_YES         TRUE
+typedef bool srb_flag_t;
+#define SRB_FLAG_NO  false
+#define SRB_FLAG_YES true
 
-typedef boolean_t             sl_discovery_flag_t;
-#define  SL_DISCOVERY_FLAG_NO          FALSE
-#define  SL_DISCOVERY_FLAG_YES         TRUE
+typedef bool sl_discovery_flag_t;
+#define SL_DISCOVERY_FLAG_NO  false
+#define SL_DISCOVERY_FLAG_YES true
 
 typedef enum link_direction_e {
   UNKNOWN_DIR          = 0,
@@ -152,8 +129,8 @@ typedef uint16_t           rlc_usn_t;
 typedef int32_t            rlc_buffer_occupancy_t;
 typedef signed int         rlc_op_status_t;
 
-#define  SDU_CONFIRM_NO          FALSE
-#define  SDU_CONFIRM_YES         TRUE
+#define  SDU_CONFIRM_NO          false
+#define  SDU_CONFIRM_YES         true
 //-----------------------------------------------------------------------------
 // PDCP TYPES
 //-----------------------------------------------------------------------------
@@ -242,7 +219,7 @@ typedef struct protocol_ctxt_s {
   frame_t     frame;         /*!< \brief  LTE frame number.*/
   sub_frame_t subframe;      /*!< \brief  LTE sub frame number.*/
   eNB_index_t eNB_index;     /*!< \brief  valid for UE indicating the index of connected eNB(s)      */
-  boolean_t		brOption;
+  bool        brOption;
 } protocol_ctxt_t;
 // warning time hardcoded
 #define PROTOCOL_CTXT_TIME_MILLI_SECONDS(CtXt_h) ((CtXt_h)->frame*10+(CtXt_h)->subframe)

openair2/ENB_APP/enb_config.c

@@ -583,9 +583,9 @@ int RCconfig_RRC(uint32_t i, eNB_RRC_INST *rrc, int macrlc_has_f1) {
                              "Failed to parse eNB configuration file %s, enb %u define %s: ENABLE,DISABLE!\n",
                              RC.config_file_name, i, ENB_CONFIG_STRING_PRACH_HIGH_SPEED);
               else if (strcmp(ccparams_lte.prach_high_speed, "ENABLE") == 0) {
-                RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].prach_high_speed = TRUE;
+                RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].prach_high_speed = true;
               } else if (strcmp(ccparams_lte.prach_high_speed, "DISABLE") == 0) {
-                RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].prach_high_speed = FALSE;
+                RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].prach_high_speed = false;
               } else
                 AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %u unknown value \"%s\" for prach_config choice: ENABLE,DISABLE !\n",
@@ -689,9 +689,9 @@ int RCconfig_RRC(uint32_t i, eNB_RRC_INST *rrc, int macrlc_has_f1) {
                              "Failed to parse eNB configuration file %s, enb %u define %s: ENABLE,DISABLE!\n",
                              RC.config_file_name, i, ENB_CONFIG_STRING_PUSCH_ENABLE64QAM);
               else if (strcmp(ccparams_lte.pusch_enable64QAM, "ENABLE") == 0) {
-                RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].pusch_enable64QAM = TRUE;
+                RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].pusch_enable64QAM = true;
               } else if (strcmp(ccparams_lte.pusch_enable64QAM, "DISABLE") == 0) {
-                RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].pusch_enable64QAM = FALSE;
+                RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].pusch_enable64QAM = false;
               } else
                 AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %u unknown value \"%s\" for pusch_enable64QAM choice: ENABLE,DISABLE!\n",
@@ -702,9 +702,9 @@ int RCconfig_RRC(uint32_t i, eNB_RRC_INST *rrc, int macrlc_has_f1) {
                              "Failed to parse eNB configuration file %s, enb %u define %s: ENABLE,DISABLE!\n",
                              RC.config_file_name, i, ENB_CONFIG_STRING_PUSCH_GROUP_HOPPING_EN);
               else if (strcmp(ccparams_lte.pusch_groupHoppingEnabled, "ENABLE") == 0) {
-                RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].pusch_groupHoppingEnabled = TRUE;
+                RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].pusch_groupHoppingEnabled = true;
               } else if (strcmp(ccparams_lte.pusch_groupHoppingEnabled, "DISABLE") == 0) {
-                RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].pusch_groupHoppingEnabled= FALSE;
+                RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].pusch_groupHoppingEnabled= false;
               } else
                 AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %u unknown value \"%s\" for pusch_groupHoppingEnabled choice: ENABLE,DISABLE!\n",
@@ -723,9 +723,9 @@ int RCconfig_RRC(uint32_t i, eNB_RRC_INST *rrc, int macrlc_has_f1) {
                              "Failed to parse eNB configuration file %s, enb %u define %s: ENABLE,DISABLE!\n",
                              RC.config_file_name, i, ENB_CONFIG_STRING_PUSCH_SEQUENCE_HOPPING_EN);
               else if (strcmp(ccparams_lte.pusch_sequenceHoppingEnabled, "ENABLE") == 0) {
-                RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].pusch_sequenceHoppingEnabled = TRUE;
+                RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].pusch_sequenceHoppingEnabled = true;
               } else if (strcmp(ccparams_lte.pusch_sequenceHoppingEnabled, "DISABLE") == 0) {
-                RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].pusch_sequenceHoppingEnabled = FALSE;
+                RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].pusch_sequenceHoppingEnabled = false;
               } else
                 AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %u unknown value \"%s\" for pusch_sequenceHoppingEnabled choice: ENABLE,DISABLE!\n",
@@ -766,15 +766,15 @@ int RCconfig_RRC(uint32_t i, eNB_RRC_INST *rrc, int macrlc_has_f1) {
                      RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].phich_duration,ccparams_lte.phich_duration);
 
               if (strcmp(ccparams_lte.srs_enable, "ENABLE") == 0) {
-                RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].srs_enable= TRUE;
+                RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].srs_enable= true;
               } else if (strcmp(ccparams_lte.srs_enable, "DISABLE") == 0) {
-                RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].srs_enable= FALSE;
+                RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].srs_enable= false;
               } else
                 AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %u unknown value \"%s\" for srs_BandwidthConfig choice: ENABLE,DISABLE !\n",
                              RC.config_file_name, i, ccparams_lte.srs_enable);
 
-              if (RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].srs_enable== TRUE) {
+              if (RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].srs_enable== true) {
                 RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].srs_BandwidthConfig= ccparams_lte.srs_BandwidthConfig;
 
                 if ((ccparams_lte.srs_BandwidthConfig < 0) ||
@@ -791,18 +791,18 @@ int RCconfig_RRC(uint32_t i, eNB_RRC_INST *rrc, int macrlc_has_f1) {
                                RC.config_file_name, i, ccparams_lte.srs_SubframeConfig);
 
                 if (strcmp(ccparams_lte.srs_ackNackST, "ENABLE") == 0) {
-                  RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].srs_ackNackST= TRUE;
+                  RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].srs_ackNackST= true;
                 } else if (strcmp(ccparams_lte.srs_ackNackST, "DISABLE") == 0) {
-                  RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].srs_ackNackST= FALSE;
+                  RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].srs_ackNackST= false;
                 } else
                   AssertFatal (0,
                                "Failed to parse eNB configuration file %s, enb %u unknown value \"%s\" for srs_BandwidthConfig choice: ENABLE,DISABLE !\n",
                                RC.config_file_name, i, ccparams_lte.srs_ackNackST);
 
                 if (strcmp(ccparams_lte.srs_MaxUpPts, "ENABLE") == 0) {
-                  RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].srs_MaxUpPts= TRUE;
+                  RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].srs_MaxUpPts= true;
                 } else if (strcmp(ccparams_lte.srs_MaxUpPts, "DISABLE") == 0) {
-                  RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].srs_MaxUpPts= FALSE;
+                  RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].srs_MaxUpPts= false;
                 } else
                   AssertFatal (0,
                                "Failed to parse eNB configuration file %s, enb %u unknown value \"%s\" for srs_MaxUpPts choice: ENABLE,DISABLE !\n",
@@ -921,7 +921,7 @@ int RCconfig_RRC(uint32_t i, eNB_RRC_INST *rrc, int macrlc_has_f1) {
                              RC.config_file_name, i, ccparams_lte.rach_numberOfRA_Preambles);
 
               if (strcmp(ccparams_lte.rach_preamblesGroupAConfig, "ENABLE") == 0) {
-                RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].rach_preamblesGroupAConfig= TRUE;
+                RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].rach_preamblesGroupAConfig= true;
                 RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].rach_sizeOfRA_PreamblesGroupA= (ccparams_lte.rach_sizeOfRA_PreamblesGroupA/4)-1;
 
                 if ((ccparams_lte.rach_numberOfRA_Preambles <4) ||
@@ -976,7 +976,7 @@ int RCconfig_RRC(uint32_t i, eNB_RRC_INST *rrc, int macrlc_has_f1) {
                                "Failed to parse eNB configuration file %s, enb %u unknown value \"%s\" for rach_messagePowerOffsetGroupB choice: minusinfinity,dB0,dB5,dB8,dB10,dB12,dB15,dB18!\n",
                                RC.config_file_name, i, ccparams_lte.rach_messagePowerOffsetGroupB);
               } else if (strcmp(ccparams_lte.rach_preamblesGroupAConfig, "DISABLE") == 0) {
-                RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].rach_preamblesGroupAConfig= FALSE;
+                RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].rach_preamblesGroupAConfig= false;
               } else
                 AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %u unknown value \"%s\" for rach_preamblesGroupAConfig choice: ENABLE,DISABLE !\n",
@@ -1254,9 +1254,9 @@ int RCconfig_RRC(uint32_t i, eNB_RRC_INST *rrc, int macrlc_has_f1) {
                              "Failed to parse eNB configuration file %s, enb %u define %s: TRUE,FALSE!\n",
                              RC.config_file_name, i, ENB_CONFIG_STRING_MBMS_DEDICATED_SERVING_CELL);
               else if (strcmp(ccparams_lte.mbms_dedicated_serving_cell, "ENABLE") == 0) {
-                RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].mbms_dedicated_serving_cell = TRUE;
+                RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].mbms_dedicated_serving_cell = true;
               } else  if (strcmp(ccparams_lte.mbms_dedicated_serving_cell, "DISABLE") == 0) {
-                RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].mbms_dedicated_serving_cell  = FALSE;
+                RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig[j].mbms_dedicated_serving_cell  = false;
               } else {
                 AssertFatal (0,
                              "Failed to parse eNB configuration file %s, enb %u unknown value \"%s\" for mbms_dedicated_serving_cell choice: TRUE or FALSE !\n",

openair2/ENB_APP/enb_config_eMTC.c

@@ -61,18 +61,18 @@ void fill_eMTC_configuration(MessageDef *msg_p,  ccparams_eMTC_t *eMTCconfig, in
 
 
   if (!strcmp(eMTCconfig->cellSelectionInfoCE_r13, "ENABLE")) {
-    RRC_CONFIGURATION_REQ(msg_p).cellSelectionInfoCE_r13[cc_idx] = TRUE;
+    RRC_CONFIGURATION_REQ(msg_p).cellSelectionInfoCE_r13[cc_idx] = true;
     RRC_CONFIGURATION_REQ(msg_p).q_RxLevMinCE_r13[cc_idx]= eMTCconfig->q_RxLevMinCE_r13;
     //                            RRC_CONFIGURATION_REQ(msg_p).q_QualMinRSRQ_CE_r13[cc_idx]= calloc(1, sizeof(long));
     //                            *RRC_CONFIGURATION_REQ(msg_p).q_QualMinRSRQ_CE_r13[cc_idx]= q_QualMinRSRQ_CE_r13;
   } else {
-    RRC_CONFIGURATION_REQ(msg_p).cellSelectionInfoCE_r13[cc_idx] = FALSE;
+    RRC_CONFIGURATION_REQ(msg_p).cellSelectionInfoCE_r13[cc_idx] = false;
   }
 
 
 
   if (!strcmp(eMTCconfig->bandwidthReducedAccessRelatedInfo_r13, "ENABLE")) {
-    RRC_CONFIGURATION_REQ(msg_p).bandwidthReducedAccessRelatedInfo_r13[cc_idx] = TRUE;
+    RRC_CONFIGURATION_REQ(msg_p).bandwidthReducedAccessRelatedInfo_r13[cc_idx] = true;
 
 
 
@@ -106,7 +106,7 @@ void fill_eMTC_configuration(MessageDef *msg_p,  ccparams_eMTC_t *eMTCconfig, in
     }
 
   } else {
-    RRC_CONFIGURATION_REQ(msg_p).bandwidthReducedAccessRelatedInfo_r13[cc_idx] = FALSE;
+    RRC_CONFIGURATION_REQ(msg_p).bandwidthReducedAccessRelatedInfo_r13[cc_idx] = false;
   }
 
   char schedulingInfoBrPath[MAX_OPTNAME_SIZE * 2];
@@ -127,10 +127,10 @@ void fill_eMTC_configuration(MessageDef *msg_p,  ccparams_eMTC_t *eMTCconfig, in
 
   RRC_CONFIGURATION_REQ(msg_p).fdd_DownlinkOrTddSubframeBitmapBR_r13[cc_idx] = CALLOC(1, sizeof(BOOLEAN_t));
   if (!strcmp(eMTCconfig->fdd_DownlinkOrTddSubframeBitmapBR_r13, "subframePattern40-r13")) {
-    *RRC_CONFIGURATION_REQ(msg_p).fdd_DownlinkOrTddSubframeBitmapBR_r13[cc_idx] = FALSE;
+    *RRC_CONFIGURATION_REQ(msg_p).fdd_DownlinkOrTddSubframeBitmapBR_r13[cc_idx] = false;
     RRC_CONFIGURATION_REQ(msg_p).fdd_DownlinkOrTddSubframeBitmapBR_val_r13[cc_idx] = eMTCconfig->fdd_DownlinkOrTddSubframeBitmapBR_val_r13;
   } else {
-    *RRC_CONFIGURATION_REQ(msg_p).fdd_DownlinkOrTddSubframeBitmapBR_r13[cc_idx] = TRUE;
+    *RRC_CONFIGURATION_REQ(msg_p).fdd_DownlinkOrTddSubframeBitmapBR_r13[cc_idx] = true;
     RRC_CONFIGURATION_REQ(msg_p).fdd_DownlinkOrTddSubframeBitmapBR_val_r13[cc_idx] = eMTCconfig->fdd_DownlinkOrTddSubframeBitmapBR_val_r13;
   }
 
@@ -156,18 +156,18 @@ void fill_eMTC_configuration(MessageDef *msg_p,  ccparams_eMTC_t *eMTCconfig, in
 
   if (!strcmp(eMTCconfig->freqHoppingParametersDL_r13, "ENABLE"))
     {
-      RRC_CONFIGURATION_REQ(msg_p).freqHoppingParametersDL_r13[cc_idx] = TRUE;
+      RRC_CONFIGURATION_REQ(msg_p).freqHoppingParametersDL_r13[cc_idx] = true;
 
       if (!strcmp(eMTCconfig->interval_DLHoppingConfigCommonModeA_r13, "interval-TDD-r13"))
-	RRC_CONFIGURATION_REQ(msg_p).interval_DLHoppingConfigCommonModeA_r13[cc_idx] = FALSE;
+	RRC_CONFIGURATION_REQ(msg_p).interval_DLHoppingConfigCommonModeA_r13[cc_idx] = false;
       else
-	RRC_CONFIGURATION_REQ(msg_p).interval_DLHoppingConfigCommonModeA_r13[cc_idx] = TRUE;
+	RRC_CONFIGURATION_REQ(msg_p).interval_DLHoppingConfigCommonModeA_r13[cc_idx] = true;
       RRC_CONFIGURATION_REQ(msg_p).interval_DLHoppingConfigCommonModeA_r13_val[cc_idx] = eMTCconfig->interval_DLHoppingConfigCommonModeA_r13_val;
 
       if (!strcmp(eMTCconfig->interval_DLHoppingConfigCommonModeB_r13, "interval-TDD-r13"))
-	RRC_CONFIGURATION_REQ(msg_p).interval_DLHoppingConfigCommonModeB_r13[cc_idx] = FALSE;
+	RRC_CONFIGURATION_REQ(msg_p).interval_DLHoppingConfigCommonModeB_r13[cc_idx] = false;
       else
-	RRC_CONFIGURATION_REQ(msg_p).interval_DLHoppingConfigCommonModeB_r13[cc_idx] = TRUE;
+	RRC_CONFIGURATION_REQ(msg_p).interval_DLHoppingConfigCommonModeB_r13[cc_idx] = true;
       RRC_CONFIGURATION_REQ(msg_p).interval_DLHoppingConfigCommonModeB_r13_val[cc_idx] = eMTCconfig->interval_DLHoppingConfigCommonModeB_r13_val;
 
       RRC_CONFIGURATION_REQ(msg_p).mpdcch_pdsch_HoppingNB_r13[cc_idx] = calloc(1, sizeof(long));
@@ -188,7 +188,7 @@ void fill_eMTC_configuration(MessageDef *msg_p,  ccparams_eMTC_t *eMTCconfig, in
     }
   else
     {
-      RRC_CONFIGURATION_REQ(msg_p).freqHoppingParametersDL_r13[cc_idx] = FALSE;
+      RRC_CONFIGURATION_REQ(msg_p).freqHoppingParametersDL_r13[cc_idx] = false;
     }
 
   /** ------------------------------SIB2/3 BR------------------------------------------ */
@@ -213,9 +213,9 @@ void fill_eMTC_configuration(MessageDef *msg_p,  ccparams_eMTC_t *eMTCconfig, in
 		 "Failed to parse eNB configuration file %s, enb %d define %s: ENABLE,DISABLE!\n",
 		 config_fname, cell_idx,ENB_CONFIG_STRING_PRACH_HIGH_SPEED);
   else if (strcmp(eMTCconfig->ccparams.prach_high_speed, "ENABLE") == 0) {
-    RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig_BR[cc_idx].prach_high_speed = TRUE;
+    RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig_BR[cc_idx].prach_high_speed = true;
   } else if (strcmp(eMTCconfig->ccparams.prach_high_speed, "DISABLE") == 0) {
-    RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig_BR[cc_idx].prach_high_speed = FALSE;
+    RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig_BR[cc_idx].prach_high_speed = false;
   } else
     AssertFatal (0,
 		 "Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for prach_config choice: ENABLE,DISABLE !\n",
@@ -310,9 +310,9 @@ void fill_eMTC_configuration(MessageDef *msg_p,  ccparams_eMTC_t *eMTCconfig, in
 		 "Failed to parse eNB configuration file %s, enb %d define %s: ENABLE,DISABLE!\n",
 		 config_fname, cell_idx,ENB_CONFIG_STRING_PUSCH_ENABLE64QAM);
   else if (strcmp(eMTCconfig->ccparams.pusch_enable64QAM, "ENABLE") == 0) {
-    RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig_BR[cc_idx].pusch_enable64QAM = TRUE;
+    RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig_BR[cc_idx].pusch_enable64QAM = true;
   }  else if (strcmp(eMTCconfig->ccparams.pusch_enable64QAM, "DISABLE") == 0) {
-    RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig_BR[cc_idx].pusch_enable64QAM = FALSE;
+    RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig_BR[cc_idx].pusch_enable64QAM = false;
   } else
     AssertFatal (0,
 		 "Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for pusch_enable64QAM choice: ENABLE,DISABLE!\n",
@@ -323,9 +323,9 @@ void fill_eMTC_configuration(MessageDef *msg_p,  ccparams_eMTC_t *eMTCconfig, in
 		 "Failed to parse eNB configuration file %s, enb %d define %s: ENABLE,DISABLE!\n",
 		 config_fname, cell_idx,ENB_CONFIG_STRING_PUSCH_GROUP_HOPPING_EN);
   else if (strcmp(eMTCconfig->ccparams.pusch_groupHoppingEnabled, "ENABLE") == 0) {
-    RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig_BR[cc_idx].pusch_groupHoppingEnabled = TRUE;
+    RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig_BR[cc_idx].pusch_groupHoppingEnabled = true;
   }  else if (strcmp(eMTCconfig->ccparams.pusch_groupHoppingEnabled, "DISABLE") == 0) {
-    RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig_BR[cc_idx].pusch_groupHoppingEnabled= FALSE;
+    RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig_BR[cc_idx].pusch_groupHoppingEnabled= false;
   } else
     AssertFatal (0,
 		 "Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for pusch_groupHoppingEnabled choice: ENABLE,DISABLE!\n",
@@ -343,9 +343,9 @@ void fill_eMTC_configuration(MessageDef *msg_p,  ccparams_eMTC_t *eMTCconfig, in
 		 "Failed to parse eNB configuration file %s, enb %d define %s: ENABLE,DISABLE!\n",
 		 config_fname, cell_idx,ENB_CONFIG_STRING_PUSCH_SEQUENCE_HOPPING_EN);
   else if (strcmp(eMTCconfig->ccparams.pusch_sequenceHoppingEnabled, "ENABLE") == 0) {
-    RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig_BR[cc_idx].pusch_sequenceHoppingEnabled = TRUE;
+    RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig_BR[cc_idx].pusch_sequenceHoppingEnabled = true;
   }  else if (strcmp(eMTCconfig->ccparams.pusch_sequenceHoppingEnabled, "DISABLE") == 0) {
-    RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig_BR[cc_idx].pusch_sequenceHoppingEnabled = FALSE;
+    RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig_BR[cc_idx].pusch_sequenceHoppingEnabled = false;
   } else
     AssertFatal (0,
 		 "Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for pusch_sequenceHoppingEnabled choice: ENABLE,DISABLE!\n",
@@ -385,15 +385,15 @@ void fill_eMTC_configuration(MessageDef *msg_p,  ccparams_eMTC_t *eMTCconfig, in
 	 RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig_BR[cc_idx].phich_duration,eMTCconfig->ccparams.phich_duration);
 
   if (strcmp(eMTCconfig->ccparams.srs_enable, "ENABLE") == 0) {
-    RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig_BR[cc_idx].srs_enable= TRUE;
+    RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig_BR[cc_idx].srs_enable= true;
   } else if (strcmp(eMTCconfig->ccparams.srs_enable, "DISABLE") == 0) {
-    RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig_BR[cc_idx].srs_enable= FALSE;
+    RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig_BR[cc_idx].srs_enable= false;
   } else
     AssertFatal (0,
 		 "Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for srs_BandwidthConfig choice: ENABLE,DISABLE !\n",
 		 config_fname, cell_idx,eMTCconfig->ccparams.srs_enable);
 
-  if (RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig_BR[cc_idx].srs_enable== TRUE) {
+  if (RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig_BR[cc_idx].srs_enable== true) {
     RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig_BR[cc_idx].srs_BandwidthConfig= eMTCconfig->ccparams.srs_BandwidthConfig;
 
     if ((eMTCconfig->ccparams.srs_BandwidthConfig < 0) || (eMTCconfig->ccparams.srs_BandwidthConfig >7))
@@ -408,18 +408,18 @@ void fill_eMTC_configuration(MessageDef *msg_p,  ccparams_eMTC_t *eMTCconfig, in
 		   config_fname, cell_idx,eMTCconfig->ccparams.srs_SubframeConfig);
 
     if (strcmp(eMTCconfig->ccparams.srs_ackNackST, "ENABLE") == 0) {
-      RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig_BR[cc_idx].srs_ackNackST= TRUE;
+      RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig_BR[cc_idx].srs_ackNackST= true;
     } else if (strcmp(eMTCconfig->ccparams.srs_ackNackST, "DISABLE") == 0) {
-      RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig_BR[cc_idx].srs_ackNackST= FALSE;
+      RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig_BR[cc_idx].srs_ackNackST= false;
     } else
       AssertFatal (0,
 		   "Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for srs_BandwidthConfig choice: ENABLE,DISABLE !\n",
 		   config_fname, cell_idx,eMTCconfig->ccparams.srs_ackNackST);
 
     if (strcmp(eMTCconfig->ccparams.srs_MaxUpPts, "ENABLE") == 0) {
-      RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig_BR[cc_idx].srs_MaxUpPts= TRUE;
+      RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig_BR[cc_idx].srs_MaxUpPts= true;
     } else if (strcmp(eMTCconfig->ccparams.srs_MaxUpPts, "DISABLE") == 0) {
-      RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig_BR[cc_idx].srs_MaxUpPts= FALSE;
+      RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig_BR[cc_idx].srs_MaxUpPts= false;
     } else
       AssertFatal (0,
 		   "Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for srs_MaxUpPts choice: ENABLE,DISABLE !\n",
@@ -535,7 +535,7 @@ void fill_eMTC_configuration(MessageDef *msg_p,  ccparams_eMTC_t *eMTCconfig, in
 		 config_fname, cell_idx,eMTCconfig->ccparams.rach_numberOfRA_Preambles);
 
   if (strcmp(eMTCconfig->ccparams.rach_preamblesGroupAConfig, "ENABLE") == 0) {
-    RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig_BR[cc_idx].rach_preamblesGroupAConfig= TRUE;
+    RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig_BR[cc_idx].rach_preamblesGroupAConfig= true;
     RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig_BR[cc_idx].rach_sizeOfRA_PreamblesGroupA= (eMTCconfig->ccparams.rach_sizeOfRA_PreamblesGroupA/4)-1;
 
     if ((eMTCconfig->ccparams.rach_numberOfRA_Preambles <4) || (eMTCconfig->ccparams.rach_numberOfRA_Preambles>60) || ((eMTCconfig->ccparams.rach_numberOfRA_Preambles&3)!=0))
@@ -588,7 +588,7 @@ void fill_eMTC_configuration(MessageDef *msg_p,  ccparams_eMTC_t *eMTCconfig, in
 		   "Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for rach_messagePowerOffsetGroupB choice: minusinfinity,dB0,dB5,dB8,dB10,dB12,dB15,dB18!\n",
 		   config_fname, cell_idx,eMTCconfig->ccparams.rach_messagePowerOffsetGroupB);
   } else if (strcmp(eMTCconfig->ccparams.rach_preamblesGroupAConfig, "DISABLE") == 0) {
-    RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig_BR[cc_idx].rach_preamblesGroupAConfig= FALSE;
+    RRC_CONFIGURATION_REQ (msg_p).radioresourceconfig_BR[cc_idx].rach_preamblesGroupAConfig= false;
   } else
     AssertFatal (0,
 		 "Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for rach_preamblesGroupAConfig choice: ENABLE,DISABLE !\n",
@@ -847,14 +847,14 @@ void fill_eMTC_configuration(MessageDef *msg_p,  ccparams_eMTC_t *eMTCconfig, in
 
 
   if (!strcmp(eMTCconfig->prach_ConfigCommon_v1310, "ENABLE")) {
-    RRC_CONFIGURATION_REQ(msg_p).radioresourceconfig_BR[cc_idx].prach_ConfigCommon_v1310 = TRUE;
+    RRC_CONFIGURATION_REQ(msg_p).radioresourceconfig_BR[cc_idx].prach_ConfigCommon_v1310 = true;
 
     RRC_CONFIGURATION_REQ(msg_p).radioresourceconfig_BR[cc_idx].mpdcch_startSF_CSS_RA_r13 = calloc(1, sizeof(BOOLEAN_t));
 
     if (!strcmp(eMTCconfig->mpdcch_startSF_CSS_RA_r13, "tdd-r13")) {
-      *RRC_CONFIGURATION_REQ(msg_p).radioresourceconfig_BR[cc_idx].mpdcch_startSF_CSS_RA_r13 = FALSE;
+      *RRC_CONFIGURATION_REQ(msg_p).radioresourceconfig_BR[cc_idx].mpdcch_startSF_CSS_RA_r13 = false;
     } else {
-      *RRC_CONFIGURATION_REQ(msg_p).radioresourceconfig_BR[cc_idx].mpdcch_startSF_CSS_RA_r13 = TRUE;
+      *RRC_CONFIGURATION_REQ(msg_p).radioresourceconfig_BR[cc_idx].mpdcch_startSF_CSS_RA_r13 = true;
     }
 
     if (!strcmp(eMTCconfig->mpdcch_startSF_CSS_RA_r13_val, "v1")) {
@@ -882,7 +882,7 @@ void fill_eMTC_configuration(MessageDef *msg_p,  ccparams_eMTC_t *eMTCconfig, in
     RRC_CONFIGURATION_REQ(msg_p).radioresourceconfig_BR[cc_idx].prach_HoppingOffset_r13 = calloc(1, sizeof(long));
     *RRC_CONFIGURATION_REQ(msg_p).radioresourceconfig_BR[cc_idx].prach_HoppingOffset_r13 = eMTCconfig->prach_HoppingOffset_r13;
   } else {
-    RRC_CONFIGURATION_REQ(msg_p).radioresourceconfig_BR[cc_idx].prach_ConfigCommon_v1310 = FALSE;
+    RRC_CONFIGURATION_REQ(msg_p).radioresourceconfig_BR[cc_idx].prach_ConfigCommon_v1310 = false;
   }
 
 
@@ -1169,7 +1169,7 @@ void fill_eMTC_configuration(MessageDef *msg_p,  ccparams_eMTC_t *eMTCconfig, in
 
 
   /** PCCH CONFIG V1310 */
-  RRC_CONFIGURATION_REQ(msg_p).pcch_config_v1310[cc_idx] = TRUE;
+  RRC_CONFIGURATION_REQ(msg_p).pcch_config_v1310[cc_idx] = true;
   RRC_CONFIGURATION_REQ(msg_p).paging_narrowbands_r13[cc_idx] = eMTCconfig->paging_narrowbands_r13;
   RRC_CONFIGURATION_REQ(msg_p).mpdcch_numrepetition_paging_r13[cc_idx] = eMTCconfig->mpdcch_numrepetition_paging_r13;
 
@@ -1220,7 +1220,7 @@ void fill_eMTC_configuration(MessageDef *msg_p,  ccparams_eMTC_t *eMTCconfig, in
 
 
   /** SIB2 FREQ HOPPING PARAMETERS R13 */
-  RRC_CONFIGURATION_REQ(msg_p).sib2_freq_hoppingParameters_r13_exists[cc_idx] = TRUE;
+  RRC_CONFIGURATION_REQ(msg_p).sib2_freq_hoppingParameters_r13_exists[cc_idx] = true;
 
   char sib2FreqHoppingParametersR13Path[MAX_OPTNAME_SIZE*2 + 16];
   sprintf(sib2FreqHoppingParametersR13Path, "%s.%s", brparamspath, ENB_CONFIG_STRING_SIB2_FREQ_HOPPINGPARAMETERS_R13);

openair2/ENB_APP/flexran_agent_ran_api.c

@@ -127,7 +127,7 @@ int flexran_get_mac_ue_id_rnti(mid_t mod_id, rnti_t rnti) {
 
   /* get the (active) UE with RNTI i */
   for (n = 0; n < MAX_MOBILES_PER_ENB; ++n) {
-    if (RC.mac[mod_id]->UE_info.active[n] == TRUE
+    if (RC.mac[mod_id]->UE_info.active[n] == true
         && rnti == UE_RNTI(mod_id, n)) {
       return n;
     }
@@ -143,7 +143,7 @@ int flexran_get_mac_ue_id(mid_t mod_id, int i) {
 
   /* get the (i+1)'th active UE */
   for (n = 0; n < MAX_MOBILES_PER_ENB; ++n) {
-    if (RC.mac[mod_id]->UE_info.active[n] == TRUE) {
+    if (RC.mac[mod_id]->UE_info.active[n] == true) {
       if (i == 0)
         return n;
 
@@ -580,7 +580,7 @@ uint8_t flexran_get_n_SB(mid_t mod_id, uint8_t cc_id) {
 Protocol__FlexQam flexran_get_enable64QAM(mid_t mod_id, uint8_t cc_id) {
   if (!phy_is_present(mod_id, cc_id)) return 0;
 
-  if (RC.eNB[mod_id][cc_id]->frame_parms.pusch_config_common.enable64QAM == TRUE)
+  if (RC.eNB[mod_id][cc_id]->frame_parms.pusch_config_common.enable64QAM == true)
     return PROTOCOL__FLEX_QAM__FLEQ_MOD_64QAM;
   else
     return PROTOCOL__FLEX_QAM__FLEQ_MOD_16QAM;
@@ -3585,7 +3585,7 @@ int flexran_set_new_plmn_id(mid_t mod_id, int CC_id, size_t n_plmn, Protocol__Fl
                          int CC_id,
                          BOOLEAN_t brOption,
                          RrcConfigurationReq *configuration);
-  carrier->sizeof_SIB1 = do_SIB1(carrier, mod_id, CC_id, FALSE, conf);
+  carrier->sizeof_SIB1 = do_SIB1(carrier, mod_id, CC_id, false, conf);
   if (carrier->sizeof_SIB1 < 0)
     return -1337; /* SIB1 encoding failed, hell will probably break loose */
 

openair2/F1AP/dummy_enb.c

@@ -32,18 +32,18 @@ void apply_macrlc_config(gNB_RRC_INST *rrc,
   abort();
 }
 
-boolean_t sdap_data_req(protocol_ctxt_t *ctxt_p,
-                        const srb_flag_t srb_flag,
-                        const rb_id_t rb_id,
-                        const mui_t mui,
-                        const confirm_t confirm,
-                        const sdu_size_t sdu_buffer_size,
-                        unsigned char *const sdu_buffer,
-                        const pdcp_transmission_mode_t pt_mode,
-                        const uint32_t *sourceL2Id,
-                        const uint32_t *destinationL2Id,
-                        const uint8_t qfi,
-                        const boolean_t rqi,
-                        const int pdusession_id) {
+bool sdap_data_req(protocol_ctxt_t *ctxt_p,
+                   const srb_flag_t srb_flag,
+                   const rb_id_t rb_id,
+                   const mui_t mui,
+                   const confirm_t confirm,
+                   const sdu_size_t sdu_buffer_size,
+                   unsigned char *const sdu_buffer,
+                   const pdcp_transmission_mode_t pt_mode,
+                   const uint32_t *sourceL2Id,
+                   const uint32_t *destinationL2Id,
+                   const uint8_t qfi,
+                   const bool rqi,
+                   const int pdusession_id) {
 abort();
 }

openair2/F1AP/f1ap_common.h

@@ -363,13 +363,6 @@
   # error "You are compiling f1ap with the wrong version of ASN1C"
 #endif
 
-#ifndef FALSE
-  #define FALSE (0)
-#endif
-#ifndef TRUE
-  #define TRUE  (!FALSE)
-#endif
-
 #define F1AP_UE_ID_FMT  "0x%06"PRIX32
 
 #include "assertions.h"

openair2/F1AP/f1ap_du_rrc_message_transfer.c

@@ -509,7 +509,7 @@ int DU_handle_DL_RRC_MESSAGE_TRANSFER(instance_t       instance,
 
   LOG_I(F1AP, "Received DL RRC Transfer on srb_id %ld\n", srb_id);
   rlc_op_status_t    rlc_status;
-  boolean_t          ret             = TRUE;
+  bool               ret             = true;
   mem_block_t       *pdcp_pdu_p      = NULL;
   pdcp_pdu_p = get_free_mem_block(rrc_dl_sdu_len, __func__);
 
@@ -539,27 +539,27 @@ int DU_handle_DL_RRC_MESSAGE_TRANSFER(instance_t       instance,
     switch (rlc_status) {
       case RLC_OP_STATUS_OK:
         //LOG_I(F1AP, "Data sending request over RLC succeeded!\n");
-        ret=TRUE;
+        ret=true;
         break;
 
       case RLC_OP_STATUS_BAD_PARAMETER:
         LOG_W(F1AP, "Data sending request over RLC failed with 'Bad Parameter' reason!\n");
-        ret= FALSE;
+        ret= false;
         break;
 
       case RLC_OP_STATUS_INTERNAL_ERROR:
         LOG_W(F1AP, "Data sending request over RLC failed with 'Internal Error' reason!\n");
-        ret= FALSE;
+        ret= false;
         break;
 
       case RLC_OP_STATUS_OUT_OF_RESSOURCES:
         LOG_W(F1AP, "Data sending request over RLC failed with 'Out of Resources' reason!\n");
-        ret= FALSE;
+        ret= false;
         break;
 
       default:
         LOG_W(F1AP, "RLC returned an unknown status code after PDCP placed the order to send some data (Status Code:%d)\n", rlc_status);
-        ret= FALSE;
+        ret= false;
         break;
     } // switch case
 
@@ -667,9 +667,9 @@ int DU_send_UL_RRC_MESSAGE_TRANSFER(instance_t instance,
 
           UE_sched_ctrl_t *UE_scheduling_control = &(RC.mac[instance]->UE_info.UE_sched_ctrl[UE_id_mac]);
 
-          if (UE_scheduling_control->cdrx_waiting_ack == TRUE) {
-            UE_scheduling_control->cdrx_waiting_ack = FALSE;
-            UE_scheduling_control->cdrx_configured = TRUE; // Set to TRUE when RRC Connection Reconfiguration Complete is received
+          if (UE_scheduling_control->cdrx_waiting_ack == true) {
+            UE_scheduling_control->cdrx_waiting_ack = false;
+            UE_scheduling_control->cdrx_configured = true; // Set to TRUE when RRC Connection Reconfiguration Complete is received
             LOG_I(F1AP, "CDRX configuration activated after RRC Connection Reconfiguration Complete reception\n");
           }
 

openair2/F1AP/f1ap_du_ue_context_management.c

@@ -42,16 +42,16 @@
 #include "openair2/LAYER2/NR_MAC_gNB/nr_mac_gNB.h"
 #include <openair3/ocp-gtpu/gtp_itf.h>
 
-boolean_t lteDURecvCb( protocol_ctxt_t  *ctxt_pP,
-                       const srb_flag_t     srb_flagP,
-                       const rb_id_t        rb_idP,
-                       const mui_t          muiP,
-                       const confirm_t      confirmP,
-                       const sdu_size_t     sdu_buffer_sizeP,
-                       unsigned char *const sdu_buffer_pP,
-                       const pdcp_transmission_mode_t modeP,
-                       const uint32_t *sourceL2Id,
-                       const uint32_t *destinationL2Id) {
+bool lteDURecvCb(protocol_ctxt_t  *ctxt_pP,
+                 const srb_flag_t     srb_flagP,
+                 const rb_id_t        rb_idP,
+                 const mui_t          muiP,
+                 const confirm_t      confirmP,
+                 const sdu_size_t     sdu_buffer_sizeP,
+                 unsigned char *const sdu_buffer_pP,
+                 const pdcp_transmission_mode_t modeP,
+                 const uint32_t *sourceL2Id,
+                 const uint32_t *destinationL2Id) {
   // The buffer comes from the stack in gtp-u thread, we have a make a separate buffer to enqueue in a inter-thread message queue
   mem_block_t *sdu=get_free_mem_block(sdu_buffer_sizeP, __func__);
   memcpy(sdu->data,  sdu_buffer_pP,  sdu_buffer_sizeP);
@@ -704,7 +704,7 @@ int DU_send_UE_CONTEXT_RELEASE_REQUEST(instance_t instance,
       LOG_E(F1AP,"Not found rnti: %x\n", rnti);
   } else {
     for (int n = 0; n < MAX_MOBILES_PER_ENB; ++n) {
-      if (RC.mac[instance]->UE_info.active[n] == TRUE
+      if (RC.mac[instance]->UE_info.active[n] == true
           && rnti == UE_RNTI(instance, n)) {
         UE_out_of_sync = RC.mac[instance]->UE_info.UE_sched_ctrl[n].ul_out_of_sync;
         break;
@@ -856,7 +856,7 @@ int DU_handle_UE_CONTEXT_RELEASE_COMMAND(instance_t       instance,
 
   if(RC.rrc && RC.rrc[instance]->node_type == ngran_eNB_DU){
     for (int n = 0; n < MAX_MOBILES_PER_ENB; ++n) {
-      if (RC.mac[instance]->UE_info.active[n] == TRUE
+      if (RC.mac[instance]->UE_info.active[n] == true
           && rnti == UE_RNTI(instance, n)) {
         UE_out_of_sync = RC.mac[instance]->UE_info.UE_sched_ctrl[n].ul_out_of_sync;
         break;

openair2/GNB_APP/MACRLC_nr_paramdef.h

@@ -97,7 +97,7 @@
 {CONFIG_STRING_MACRLC_ULSCH_MAX_FRAME_INACTIVITY,        NULL,     0,          uptr:NULL,           defintval:10,              TYPE_UINT,     0},        \
 {CONFIG_STRING_MACRLC_PUSCHTARGETSNRX10,                 NULL,     0,          iptr:NULL,           defintval:200,             TYPE_INT,      0},        \
 {CONFIG_STRING_MACRLC_PUCCHTARGETSNRX10,                 NULL,     0,          iptr:NULL,           defintval:150,             TYPE_INT,      0},        \
-{CONFIG_STRING_MACRLC_UL_PRBBLACK_SNR_THRESHOLD,         NULL,     0,          iptr:NULL,           defintval:10,              TYPE_INT,      0},        \
+{CONFIG_STRING_MACRLC_UL_PRBBLACK_SNR_THRESHOLD, "SNR threshold to decide whether a PRB will be blacklisted or not",     0,          iptr:NULL,           defintval:10,              TYPE_INT,      0},        \
 {CONFIG_STRING_MACRLC_PUCCHFAILURETHRES,                 NULL,     0,          iptr:NULL,           defintval:10,              TYPE_INT,      0},        \
 {CONFIG_STRING_MACRLC_PUSCHFAILURETHRES,                 NULL,     0,          iptr:NULL,           defintval:10,              TYPE_INT,      0},        \
 {CONFIG_STRING_MACRLC_DL_BLER_TARGET_UPPER,   "Upper threshold of BLER to decrease DL MCS",   0, dblptr:NULL,  defdblval:0.15,  TYPE_DOUBLE,  0},        \

openair2/LAYER2/MAC/config.c

@@ -1104,7 +1104,7 @@ void eNB_Config_Local_DRX(instance_t Mod_id,
 
   /* Get struct to modify */
   UE_scheduling_control = &(UE_info_mac->UE_sched_ctrl[UE_id]);
-  UE_scheduling_control->cdrx_configured = FALSE; // will be set to true when no error
+  UE_scheduling_control->cdrx_configured = false; // will be set to true when no error
 
   /* Check drx_Configuration */
   if (drx_Configuration == NULL) {
@@ -1119,9 +1119,9 @@ void eNB_Config_Local_DRX(instance_t Mod_id,
   }
 
   /* Modify scheduling control structure according to DRX configuration: doesn't support every configurations! */  
-  UE_scheduling_control->cdrx_configured = FALSE; // will be set to true when receiving RRC Reconfiguration Complete
-  UE_scheduling_control->cdrx_waiting_ack = TRUE; // waiting for RRC Reconfiguration Complete message
-  UE_scheduling_control->in_active_time = FALSE;
+  UE_scheduling_control->cdrx_configured = false; // will be set to true when receiving RRC Reconfiguration Complete
+  UE_scheduling_control->cdrx_waiting_ack = true; // waiting for RRC Reconfiguration Complete message
+  UE_scheduling_control->in_active_time = false;
   UE_scheduling_control->dci0_ongoing_timer = 0;
   UE_scheduling_control->on_duration_timer = 0;
   struct LTE_DRX_Config__setup *choiceSetup = &drx_Configuration->choice.setup;
@@ -1297,13 +1297,13 @@ void eNB_Config_Local_DRX(instance_t Mod_id,
   }
 
   if (choiceSetup->shortDRX == NULL) {
-    UE_scheduling_control->in_short_drx_cycle = FALSE;
+    UE_scheduling_control->in_short_drx_cycle = false;
     UE_scheduling_control->drx_shortCycle_timer_value = 0;
     UE_scheduling_control->short_drx_cycle_duration = 0;
     UE_scheduling_control->drx_shortCycle_timer = 0;
     UE_scheduling_control->drx_shortCycle_timer_thres = -1;
   } else {
-    UE_scheduling_control->in_short_drx_cycle = FALSE;
+    UE_scheduling_control->in_short_drx_cycle = false;
     UE_scheduling_control->drx_shortCycle_timer_value = (uint8_t) choiceSetup->shortDRX->drxShortCycleTimer;
 
     switch (choiceSetup->shortDRX->shortDRX_Cycle) {
@@ -1380,7 +1380,7 @@ void eNB_Config_Local_DRX(instance_t Mod_id,
     UE_scheduling_control->drx_shortCycle_timer_thres = UE_scheduling_control->drx_shortCycle_timer_value * UE_scheduling_control->short_drx_cycle_duration;
   }
 
-  UE_scheduling_control->in_long_drx_cycle = FALSE;
+  UE_scheduling_control->in_long_drx_cycle = false;
   UE_scheduling_control->drx_longCycle_timer = 0;
 
   switch (choiceSetup->longDRX_CycleStartOffset.present) {

openair2/LAYER2/MAC/defs_NB_IoT.h

@@ -243,7 +243,6 @@ typedef struct {
   // -1:No UE in list
   int tail;
   int num_UEs;
-  //boolean_t active[MAX_MAX_MOBILES_PER_ENB_NB_IoT];
 
 } UE_list_NB_IoT_t;
 
@@ -403,7 +402,7 @@ typedef struct schedule_result{
   // pointer to DCI
   void *DCI_pdu;
   // when all the procedure related to this DCI, enable this flag
-  boolean_t DCI_release;
+  bool DCI_release;
   // Indicate the channel which to transmit
   channel_NB_IoT_t channel;
   // rnti
@@ -452,7 +451,7 @@ typedef enum ce_level_e{
 /*! \brief eNB template for the Random access information */
 typedef struct RA_TEMPLATE_NB_IoT_s{
 
-  boolean_t active;
+  bool active;
   uint32_t msg3_retransmit_count;
   uint32_t msg4_retransmit_count;
   uint16_t ta;
@@ -461,8 +460,8 @@ typedef struct RA_TEMPLATE_NB_IoT_s{
   rnti_t ue_rnti;
   rnti_t ra_rnti;
   struct RA_TEMPLATE_NB_IoT_s *next, *prev;
-  boolean_t wait_msg4_ack;
-  boolean_t wait_msg3_ack;
+  bool wait_msg4_ack;
+  bool wait_msg3_ack;
   uint8_t rar_buffer[7];
 
 } RA_TEMPLATE_NB_IoT;
@@ -530,7 +529,7 @@ typedef  struct {
   uint32_t       pdus_in_buffer;  /*!< \brief Number of PDUs buffered in RLC protocol instance (OBSOLETE). */
   uint32_t       head_sdu_creation_time;           /*!< \brief Head SDU creation time. */
   uint32_t       head_sdu_remaining_size_to_send;  /*!< \brief remaining size of sdu: could be the total size or the remaining size of already segmented sdu */
-  boolean_t      head_sdu_is_segmented;     /*!< \brief 0 if head SDU has not been segmented, 1 if already segmented */
+  bool           head_sdu_is_segmented;     /*!< \brief 0 if head SDU has not been segmented, 1 if already segmented */
 } mac_rlc_status_resp_NB_IoT_t;
 
 // global variables

openair2/LAYER2/MAC/eNB_scheduler.c

@@ -135,7 +135,7 @@ void schedule_SRS(module_id_t module_idP,
           UE_scheduling_control = &(UE_info->UE_sched_ctrl[UE_id]);
 
           /* Test if Active Time not running since 6+ subframes */
-          if (UE_scheduling_control->cdrx_configured == TRUE && UE_scheduling_control->in_active_time == FALSE) {
+          if (UE_scheduling_control->cdrx_configured == true && UE_scheduling_control->in_active_time == false) {
             /*
              * TODO: 6+ subframes condition not checked here
              */
@@ -204,7 +204,7 @@ void schedule_CSI(module_id_t module_idP,
     cc = &eNB->common_channels[CC_id];
 
     for (UE_id = 0; UE_id < MAX_MOBILES_PER_ENB; UE_id++) {
-      if (UE_info->active[UE_id] == FALSE) {
+      if (UE_info->active[UE_id] == false) {
         continue;
       }
 
@@ -223,9 +223,9 @@ void schedule_CSI(module_id_t module_idP,
       */
       UE_scheduling_control = &(UE_info->UE_sched_ctrl[UE_id]);
 
-      if (UE_scheduling_control->cdrx_configured == TRUE) {
+      if (UE_scheduling_control->cdrx_configured == true) {
         /* Test if CQI masking activated */
-        if (UE_scheduling_control->cqi_mask_boolean == TRUE) {
+        if (UE_scheduling_control->cqi_mask_boolean == true) {
           // CQI masking => test if onDurationTime not running since 6+ subframe
           if (UE_scheduling_control->on_duration_timer == 0) {
             /*
@@ -234,7 +234,7 @@ void schedule_CSI(module_id_t module_idP,
             continue;
           }
         } else { // No CQI masking => test if Active Time not running since 6+ subframe
-          if (UE_scheduling_control->in_active_time == FALSE) {
+          if (UE_scheduling_control->in_active_time == false) {
             /*
              * TODO: 6+ subframes condition not checked here
              */
@@ -677,8 +677,8 @@ eNB_dlsch_ulsch_scheduler(module_id_t module_idP,
       }
 
       /* Set and increment CDRX related timers */
-      if (UE_scheduling_control->cdrx_configured == TRUE) {
-        boolean_t harq_active_time_condition = FALSE;
+      if (UE_scheduling_control->cdrx_configured == true) {
+        bool harq_active_time_condition = false;
         UE_TEMPLATE *UE_template = NULL;
         unsigned long active_time_condition = 0; // variable used only for tracing purpose
 
@@ -721,7 +721,7 @@ eNB_dlsch_ulsch_scheduler(module_id_t module_idP,
             UE_scheduling_control->ul_synchronous_harq_timer[CC_id][harq_process_id]++;
 
             if (UE_scheduling_control->ul_synchronous_harq_timer[CC_id][harq_process_id] > 5) {
-              harq_active_time_condition = TRUE;
+              harq_active_time_condition = true;
               UE_scheduling_control->ul_synchronous_harq_timer[CC_id][harq_process_id] = 0;
               active_time_condition = 5; // for tracing purpose
             }
@@ -747,24 +747,24 @@ eNB_dlsch_ulsch_scheduler(module_id_t module_idP,
 
             /* When timer expires switch into short or long DRX cycle */
             if (UE_scheduling_control->drx_shortCycle_timer_thres > 0) {
-              UE_scheduling_control->in_short_drx_cycle = TRUE;
+              UE_scheduling_control->in_short_drx_cycle = true;
               UE_scheduling_control->drx_shortCycle_timer = 0;
-              UE_scheduling_control->in_long_drx_cycle = FALSE;
+              UE_scheduling_control->in_long_drx_cycle = false;
             } else {
-              UE_scheduling_control->in_long_drx_cycle = TRUE;
+              UE_scheduling_control->in_long_drx_cycle = true;
             }
           }
         }
 
         /* Short DRX Cycle */
-        if (UE_scheduling_control->in_short_drx_cycle == TRUE) {
+        if (UE_scheduling_control->in_short_drx_cycle == true) {
           UE_scheduling_control->drx_shortCycle_timer++;
 
           /* When the Short DRX cycles are over, switch to long DRX cycle */
           if (UE_scheduling_control->drx_shortCycle_timer > UE_scheduling_control->drx_shortCycle_timer_thres) {
             UE_scheduling_control->drx_shortCycle_timer = 0;
-            UE_scheduling_control->in_short_drx_cycle = FALSE;
-            UE_scheduling_control->in_long_drx_cycle = TRUE;
+            UE_scheduling_control->in_short_drx_cycle = false;
+            UE_scheduling_control->in_long_drx_cycle = true;
             UE_scheduling_control->drx_longCycle_timer = 0;
           }
         } else {
@@ -772,7 +772,7 @@ eNB_dlsch_ulsch_scheduler(module_id_t module_idP,
         }
 
         /* Long DRX Cycle */
-        if (UE_scheduling_control->in_long_drx_cycle == TRUE) {
+        if (UE_scheduling_control->in_long_drx_cycle == true) {
           UE_scheduling_control->drx_longCycle_timer++;
 
           if (UE_scheduling_control->drx_longCycle_timer > UE_scheduling_control->drx_longCycle_timer_thres) {
@@ -783,18 +783,18 @@ eNB_dlsch_ulsch_scheduler(module_id_t module_idP,
         }
 
         /* Check for error cases */
-        if ((UE_scheduling_control->in_short_drx_cycle == TRUE) && (UE_scheduling_control->in_long_drx_cycle == TRUE)) {
+        if ((UE_scheduling_control->in_short_drx_cycle == true) && (UE_scheduling_control->in_long_drx_cycle == true)) {
           LOG_E(MAC, "Error in C-DRX: UE id %d is in both short and long DRX cycle. Should not happen. Back it to long cycle only\n", UE_id);
-          UE_scheduling_control->in_short_drx_cycle = FALSE;
+          UE_scheduling_control->in_short_drx_cycle = false;
         }
 
         /* Condition to start On Duration Timer */
-        if (UE_scheduling_control->in_short_drx_cycle == TRUE && UE_scheduling_control->on_duration_timer == 0) {
+        if (UE_scheduling_control->in_short_drx_cycle == true && UE_scheduling_control->on_duration_timer == 0) {
           if (((frameP * 10) + subframeP) % (UE_scheduling_control->short_drx_cycle_duration) ==
               (UE_scheduling_control->drx_start_offset) % (UE_scheduling_control->short_drx_cycle_duration)) {
             UE_scheduling_control->on_duration_timer = 1;
           }
-        } else if (UE_scheduling_control->in_long_drx_cycle == TRUE && UE_scheduling_control->on_duration_timer == 0) {
+        } else if (UE_scheduling_control->in_long_drx_cycle == true && UE_scheduling_control->on_duration_timer == 0) {
           if (((frameP * 10) + subframeP) % (UE_scheduling_control->drx_longCycle_timer_thres) ==
               (UE_scheduling_control->drx_start_offset)) {
             UE_scheduling_control->on_duration_timer = 1;
@@ -811,7 +811,7 @@ eNB_dlsch_ulsch_scheduler(module_id_t module_idP,
         /* (a)synchronous HARQ processes handling for Active Time */
         for (int harq_process_id = 0; harq_process_id < 8; harq_process_id++) {
           if (UE_scheduling_control->drx_retransmission_timer[harq_process_id] > 0) {
-            harq_active_time_condition = TRUE;
+            harq_active_time_condition = true;
             active_time_condition = 2; // for tracing purpose
             break;
           }
@@ -822,9 +822,9 @@ eNB_dlsch_ulsch_scheduler(module_id_t module_idP,
             UE_scheduling_control->drx_inactivity_timer > 1 ||
             harq_active_time_condition ||
             UE_template->ul_SR > 0) {
-          UE_scheduling_control->in_active_time = TRUE;
+          UE_scheduling_control->in_active_time = true;
         } else {
-          UE_scheduling_control->in_active_time = FALSE;
+          UE_scheduling_control->in_active_time = false;
         }
 
         /* BEGIN VCD */

openair2/LAYER2/MAC/eNB_scheduler_RA.c

@@ -1225,7 +1225,7 @@ check_Msg4_retransmission(module_id_t module_idP, int CC_idP,
     LOG_D(MAC,"[eNB %d][RAPROC] Frame %d, Subframe %d: state:IDLE\n", module_idP, frameP, subframeP);
     UE_id = find_UE_id(module_idP, ra->rnti);
     DevAssert(UE_id != -1);
-    mac->UE_info.UE_template[UE_PCCID(module_idP, UE_id)][UE_id].configured = TRUE;
+    mac->UE_info.UE_template[UE_PCCID(module_idP, UE_id)][UE_id].configured = true;
     mac->UE_info.UE_template[UE_PCCID(module_idP, UE_id)][UE_id].pusch_repetition_levels=ra->pusch_repetition_levels;
     cancel_ra_proc(module_idP, CC_idP, frameP, ra->rnti);
   }

openair2/LAYER2/MAC/eNB_scheduler_dlsch.c

@@ -2075,7 +2075,7 @@ schedule_PCH(module_id_t module_idP,
     for (uint16_t i = 0; i < MAX_MOBILES_PER_ENB; i++) {
       ue_pf_po = &UE_PF_PO[CC_id][i];
 
-      if (ue_pf_po->enable_flag != TRUE) {
+      if (ue_pf_po->enable_flag != true) {
         continue;
       }
 

openair2/LAYER2/MAC/eNB_scheduler_fairRR.c

@@ -69,7 +69,7 @@ int last_ulsch_ue_id_volte[MAX_NUM_CCs] = {-1};
   uint16_t pre_nb_rbs_required[2][MAX_NUM_CCs][NUMBER_OF_UE_MAX];
   uint8_t dlsch_ue_select_tbl_in_use;
   uint8_t new_dlsch_ue_select_tbl_in_use;
-  boolean_t pre_scd_activeUE[NUMBER_OF_UE_MAX];
+  bool pre_scd_activeUE[NUMBER_OF_UE_MAX];
   eNB_UE_STATS pre_scd_eNB_UE_stats[MAX_NUM_CCs][NUMBER_OF_UE_MAX];
 #endif
 
@@ -125,7 +125,7 @@ void pre_scd_nb_rbs_required(    module_id_t     module_idP,
   UE_info_t *UE_info = &RC.mac[module_idP]->UE_info;
 
   for (UE_id = 0; UE_id <NUMBER_OF_UE_MAX; UE_id++) {
-    if (pre_scd_activeUE[UE_id] != TRUE)
+    if (pre_scd_activeUE[UE_id] != true)
       continue;
 
     // store dlsch buffer
@@ -210,7 +210,7 @@ void dlsch_scheduler_pre_ue_select_fairRR(
     DL_req          = &eNB->DL_req[CC_id].dl_config_request_body;
 
     for (UE_id = 0; UE_id < NUMBER_OF_UE_MAX; UE_id++) {
-      if (UE_info->active[UE_id] == FALSE) {
+      if (UE_info->active[UE_id] == false) {
         continue;
       }
 
@@ -331,7 +331,7 @@ void dlsch_scheduler_pre_ue_select_fairRR(
         break;
       }
 
-      if (UE_info->active[UE_id] == FALSE) {
+      if (UE_info->active[UE_id] == false) {
         continue;
       }
 
@@ -459,7 +459,7 @@ void dlsch_scheduler_pre_ue_select_fairRR(
         break;
       }
 
-      if (UE_info->active[UE_id] == FALSE) {
+      if (UE_info->active[UE_id] == false) {
         continue;
       }
 
@@ -607,7 +607,7 @@ static void dlsch_scheduler_pre_processor_reset_fairRR(
       if (rnti == NOT_A_RNTI)
         continue;
 
-      if (UE_info->active[UE_id] != TRUE)
+      if (UE_info->active[UE_id] != true)
         continue;
 
       LOG_D(MAC, "Running preprocessor for UE %d (%x)\n", UE_id, rnti);
@@ -755,7 +755,7 @@ static void assign_rbs_required_fairRR(
 
   // clear rb allocations across all CC_id
   for (UE_id = 0; UE_id < MAX_MOBILES_PER_ENB; UE_id++) {
-    if (UE_info->active[UE_id] != TRUE)
+    if (UE_info->active[UE_id] != true)
       continue;
 
     pCCid = UE_PCCID(Mod_id, UE_id);
@@ -945,7 +945,7 @@ void dlsch_scheduler_pre_processor_fairRR (module_id_t   Mod_id,
     min_rb_unit[CC_id] = get_min_rb_unit(Mod_id, CC_id);
 
     for (i = 0; i < NUMBER_OF_UE_MAX; i++) {
-      if (UE_info->active[i] != TRUE)
+      if (UE_info->active[i] != true)
         continue;
 
       UE_id = i;
@@ -2241,7 +2241,7 @@ void ulsch_scheduler_pre_ue_select_fairRR(
 
   // UE round >0
   for ( UE_id = 0; UE_id < NUMBER_OF_UE_MAX; UE_id++ ) {
-    if (UE_info->active[UE_id] == FALSE)
+    if (UE_info->active[UE_id] == false)
       continue;
 
     rnti = UE_RNTI(module_idP,UE_id);
@@ -2251,7 +2251,7 @@ void ulsch_scheduler_pre_ue_select_fairRR(
 
     CC_id = UE_PCCID(module_idP,UE_id);
 
-    if (UE_info->UE_template[CC_id][UE_id].configured == FALSE)
+    if (UE_info->UE_template[CC_id][UE_id].configured == false)
       continue;
 
     if (UE_info->UE_sched_ctrl[UE_id].ul_failure_timer > 0
@@ -2401,7 +2401,7 @@ void ulsch_scheduler_pre_ue_select_fairRR(
   }
 
   for ( UE_id = 0; UE_id < NUMBER_OF_UE_MAX; UE_id++ ) {
-    if (UE_info->active[UE_id] == FALSE)
+    if (UE_info->active[UE_id] == false)
       continue;
 
     rnti = UE_RNTI(module_idP,UE_id);
@@ -2414,7 +2414,7 @@ void ulsch_scheduler_pre_ue_select_fairRR(
     if (UE_id > last_ulsch_ue_id[CC_id])
       continue;
 
-    if (UE_info->UE_template[CC_id][UE_id].configured == FALSE)
+    if (UE_info->UE_template[CC_id][UE_id].configured == false)
       continue;
 
     if (UE_info->UE_sched_ctrl[UE_id].ul_failure_timer > 0

openair2/LAYER2/MAC/eNB_scheduler_primitives.c

@@ -1989,7 +1989,7 @@ find_UE_id(module_id_t mod_idP,
     return -1;
 
   for (UE_id = 0; UE_id < MAX_MOBILES_PER_ENB; UE_id++) {
-    if (UE_info->active[UE_id] == TRUE) {
+    if (UE_info->active[UE_id] == true) {
       int CC_id = UE_PCCID(mod_idP, UE_id);
       if (CC_id>=0 && CC_id<NFAPI_CC_MAX && UE_info->UE_template[CC_id][UE_id].rnti == rntiP) {
         return UE_id;
@@ -2063,7 +2063,7 @@ UE_RNTI(module_id_t mod_idP,
 }
 
 //------------------------------------------------------------------------------
-boolean_t
+bool
 is_UE_active(module_id_t mod_idP,
              int ue_idP)
 //------------------------------------------------------------------------------
@@ -2187,20 +2187,20 @@ add_new_ue(module_id_t mod_idP,
         UE_info->num_UEs);
 
   for (i = 0; i < MAX_MOBILES_PER_ENB; i++) {
-    if (UE_info->active[i] == TRUE)
+    if (UE_info->active[i] == true)
       continue;
 
     UE_id = i;
     memset(&UE_info->UE_template[cc_idP][UE_id], 0, sizeof(UE_TEMPLATE));
     UE_info->UE_template[cc_idP][UE_id].rnti = rntiP;
-    UE_info->UE_template[cc_idP][UE_id].configured = FALSE;
+    UE_info->UE_template[cc_idP][UE_id].configured = false;
     UE_info->numactiveCCs[UE_id] = 1;
     UE_info->numactiveULCCs[UE_id] = 1;
     UE_info->pCC_id[UE_id] = cc_idP;
     UE_info->ordered_CCids[0][UE_id] = cc_idP;
     UE_info->ordered_ULCCids[0][UE_id] = cc_idP;
     UE_info->num_UEs++;
-    UE_info->active[UE_id] = TRUE;
+    UE_info->active[UE_id] = true;
     add_ue_list(&UE_info->list, UE_id);
     dump_ue_list(&UE_info->list);
     pp_impl_param_t* dl = &RC.mac[mod_idP]->pre_processor_dl;
@@ -2280,7 +2280,7 @@ rrc_mac_remove_ue(module_id_t mod_idP,
         UE_id,
         pCC_id,
         rntiP);
-  UE_info->active[UE_id] = FALSE;
+  UE_info->active[UE_id] = false;
   UE_info->num_UEs--;
 
   remove_ue_list(&UE_info->list, UE_id);
@@ -3488,7 +3488,7 @@ has_ul_grant(module_id_t module_idP,
 }
 
 //------------------------------------------------------------------------------
-boolean_t
+bool
 CCE_allocation_infeasible(int module_idP,
                           int CC_idP,
                           int format_flag,
@@ -3501,7 +3501,7 @@ CCE_allocation_infeasible(int module_idP,
   nfapi_dl_config_request_pdu_t *dl_config_pdu = &DL_req->dl_config_pdu_list[DL_req->number_pdu];
   nfapi_hi_dci0_request_body_t *HI_DCI0_req    = &RC.mac[module_idP]->HI_DCI0_req[CC_idP][subframe].hi_dci0_request_body;
   nfapi_hi_dci0_request_pdu_t *hi_dci0_pdu     = &HI_DCI0_req->hi_dci0_pdu_list[HI_DCI0_req->number_of_dci + HI_DCI0_req->number_of_hi];
-  boolean_t res = TRUE;
+  bool res = true;
 
   if (format_flag != 2) { // DL DCI
     if (DL_req->number_pdu == MAX_NUM_DL_PDU) {
@@ -3517,7 +3517,7 @@ CCE_allocation_infeasible(int module_idP,
             subframe, format_flag, rnti, aggregation);
 
       if (allocate_CCEs(module_idP, CC_idP, 0, subframe, 0) != -1)
-        res = FALSE;
+        res = false;
 
       DL_req->number_pdu--;
     }
@@ -3532,7 +3532,7 @@ CCE_allocation_infeasible(int module_idP,
       HI_DCI0_req->number_of_dci++;
 
       if (allocate_CCEs(module_idP, CC_idP, 0, subframe, 0) != -1)
-        res = FALSE;
+        res = false;
 
       HI_DCI0_req->number_of_dci--;
     }
@@ -5029,7 +5029,7 @@ SR_indication(module_id_t mod_idP,
   if (UE_id != -1) {
     UE_scheduling_ctrl = &(UE_info->UE_sched_ctrl[UE_id]);
 
-    if ((UE_scheduling_ctrl->cdrx_configured == TRUE) &&
+    if ((UE_scheduling_ctrl->cdrx_configured == true) &&
         (UE_scheduling_ctrl->dci0_ongoing_timer > 0)  &&
         (UE_scheduling_ctrl->dci0_ongoing_timer < 8)) {
       LOG_D(MAC, "[eNB %d][SR %x] Frame %d subframeP %d Signaling SR for UE %d on CC_id %d.  \
@@ -5052,7 +5052,7 @@ SR_indication(module_id_t mod_idP,
       }
 
       UE_info->UE_template[cc_idP][UE_id].ul_SR = 1;
-      UE_info->UE_template[cc_idP][UE_id].ul_active = TRUE;
+      UE_info->UE_template[cc_idP][UE_id].ul_active = true;
       VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_SR_INDICATION, 1);
       VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_SR_INDICATION, 0);
     }

openair2/LAYER2/MAC/eNB_scheduler_ulsch.c

@@ -242,7 +242,7 @@ rx_sdu(const module_id_t enb_mod_idP,
       }
 
       /* CDRX UL HARQ timers */
-      if (UE_scheduling_control->cdrx_configured == TRUE) {
+      if (UE_scheduling_control->cdrx_configured == true) {
         /* Synchronous UL HARQ */
         UE_scheduling_control->ul_synchronous_harq_timer[CC_idP][harq_pid] = 5;
         /*
@@ -1003,7 +1003,7 @@ rx_sdu(const module_id_t enb_mod_idP,
 
   /* CDRX UL HARQ timers */
   if (UE_id != -1) {
-    if (UE_scheduling_control->cdrx_configured == TRUE) {
+    if (UE_scheduling_control->cdrx_configured == true) {
       /* Synchronous UL HARQ */
       UE_scheduling_control->ul_synchronous_harq_timer[CC_idP][harq_pid] = 5;
       /*
@@ -1447,7 +1447,7 @@ schedule_ulsch_rnti(module_id_t   module_idP,
       continue;
 
     // don't schedule if Msg5 is not received yet
-    if (UE_info->UE_template[CC_id][UE_id].configured == FALSE) {
+    if (UE_info->UE_template[CC_id][UE_id].configured == false) {
       LOG_D(MAC,
             "[eNB %d] frame %d, subframe %d, UE %d: not configured, skipping "
             "UE scheduling \n",
@@ -2033,7 +2033,7 @@ void schedule_ulsch_rnti_emtc(module_id_t   module_idP,
     }
 
     /* Don't schedule if Msg4 is not received yet */
-    if (UE_template->configured == FALSE) {
+    if (UE_template->configured == false) {
       LOG_D(MAC,"[eNB %d] frame %d subframe %d, UE %d: not configured, skipping UE scheduling \n",
             module_idP,
             frameP,

openair2/LAYER2/MAC/mac.h

@@ -811,9 +811,9 @@ typedef struct {
   /// TBS from last UL scheduling
   int TBS_UL[8];
   /// Flag to indicate UL has been scheduled at least once
-  boolean_t ul_active;
+  bool ul_active;
   /// Flag to indicate UE has been configured (ACK from RRCConnectionSetup received)
-  boolean_t configured;
+  bool configured;
 
   /// MCS from last scheduling
   uint8_t mcs[8];
@@ -1026,16 +1026,16 @@ typedef struct {
 
   /* C-DRX related timers */
   /* Note: only valid for FDD and LTE UE when this comment is written (11-01-19)*/
-  /// is TRUE if the cqi mask feature is activated by RRC configuration
-  boolean_t cqi_mask_boolean;
-  /// is TRUE if the following drx parameters are configured for UE
-  boolean_t cdrx_configured;
+  /// is true if the cqi mask feature is activated by RRC configuration
+  bool cqi_mask_boolean;
+  /// is true if the following drx parameters are configured for UE
+  bool cdrx_configured;
   /*
-   * if TRUE, the eNB has configured the CDRX locally, but is waiting for the UE to acknowledge
+   * if true, the eNB has configured the CDRX locally, but is waiting for the UE to acknowledge
    * the activation. This is needed, during the RRC configuration process, when the context is
    * configured on the eNB side, but not yet on the UE side...
    */
-  boolean_t cdrx_waiting_ack;
+  bool cdrx_waiting_ack;
   /*
    * Is set when a ULSCH scheduling is done and run until the first corresponding transmission is done (4 subframes).
    * When set, SR cannot be set for the UE. This allows OAI to avoid concidering a SR as uncompleted if the UE sends
@@ -1043,16 +1043,16 @@ typedef struct {
    * create a lost in timers synchronization.
    */
   uint8_t dci0_ongoing_timer;
-  /// is TRUE if the UE is in "Active Time", hence listening to PDCCH
-  boolean_t in_active_time;
+  /// is true if the UE is in "Active Time", hence listening to PDCCH
+  bool in_active_time;
   /// OnDurationTimer
   uint16_t  on_duration_timer;
   uint16_t  on_duration_timer_thres;
   /// drx-InactivityTimer
   uint16_t  drx_inactivity_timer;
   uint16_t  drx_inactivity_timer_thres;
-  /// is TRUE if UE is currently in short DRX cycle
-  boolean_t in_short_drx_cycle;
+  /// is true if UE is currently in short DRX cycle
+  bool in_short_drx_cycle;
   /// drxShortCycleTimer int (1..16) (number of short DRX cycles duration before long DRX cycles)
   uint8_t  drx_shortCycle_timer_value;
   /// shortDRX-Cycle (duration of one short DRX cycle)
@@ -1060,8 +1060,8 @@ typedef struct {
   /// DRX short cycle timer before switching to long DRX cycle = drx_shortCycle_timer_value * short_drx_cycle_duration
   uint16_t  drx_shortCycle_timer;
   uint16_t  drx_shortCycle_timer_thres;
-  /// is TRUE if UE is currently in long DRX cycle
-  boolean_t in_long_drx_cycle;
+  /// is true if UE is currently in long DRX cycle
+  bool in_long_drx_cycle;
   /// longDRX-CycleStartOffset (long DRX cycle timer)
   uint16_t  drx_longCycle_timer;
   uint16_t  drx_longCycle_timer_thres;
@@ -1183,7 +1183,7 @@ typedef struct {
   UE_sched_ctrl_t UE_sched_ctrl[MAX_MOBILES_PER_ENB];
   UE_list_t list;
   int num_UEs;
-  boolean_t active[MAX_MOBILES_PER_ENB];
+  bool active[MAX_MOBILES_PER_ENB];
 } UE_info_t;
 
 /*! \brief deleting control information*/
@@ -1191,9 +1191,9 @@ typedef struct {
   ///rnti of UE
   rnti_t rnti;
   ///remove UE context flag
-  boolean_t removeContextFlg;
+  bool removeContextFlg;
   ///remove RA flag
-  boolean_t raFlag;
+  bool raFlag;
 } UE_free_ctrl_t;
 /*! \brief REMOVE UE list used by eNB to order UEs/CC for deleting*/
 typedef struct {

openair2/LAYER2/MAC/mac_extern.h

@@ -71,7 +71,7 @@ extern rb_id_t mbms_rab_id;
 extern uint16_t pre_nb_rbs_required[2][MAX_NUM_CCs][NUMBER_OF_UE_MAX];
 extern uint8_t dlsch_ue_select_tbl_in_use;
 extern uint8_t new_dlsch_ue_select_tbl_in_use;
-extern boolean_t pre_scd_activeUE[NUMBER_OF_UE_MAX];
+extern bool pre_scd_activeUE[NUMBER_OF_UE_MAX];
 extern eNB_UE_STATS pre_scd_eNB_UE_stats[MAX_NUM_CCs][NUMBER_OF_UE_MAX];
 #endif
 

openair2/LAYER2/MAC/mac_proto.h

@@ -400,7 +400,7 @@ int find_RA_id(module_id_t mod_idP, int CC_idP, rnti_t rntiP);
 rnti_t UE_RNTI(module_id_t module_idP, int UE_id);
 int UE_PCCID(module_id_t module_idP, int UE_id);
 uint8_t find_active_UEs(module_id_t module_idP);
-boolean_t is_UE_active(module_id_t module_idP, int UE_id);
+bool is_UE_active(module_id_t module_idP, int UE_id);
 uint8_t get_aggregation(uint8_t bw_index, uint8_t cqi, uint8_t dci_fmt);
 
 int8_t find_active_UEs_with_traffic(module_id_t module_idP);
@@ -416,11 +416,11 @@ int get_nCCE_offset(int *CCE_table,
 
 int allocate_CCEs(int module_idP, int CC_idP, frame_t frameP, sub_frame_t subframeP, int test_only);
 
-boolean_t CCE_allocation_infeasible(int module_idP,
-                                    int CC_idP,
-                                    int common_flag,
-                                    int subframe,
-                                    int aggregation, int rnti);
+bool CCE_allocation_infeasible(int module_idP,
+                               int CC_idP,
+                               int common_flag,
+                               int subframe,
+                               int aggregation, int rnti);
 /* tries to allocate a CCE. If it succeeds, reserves NFAPI DCI and DLSCH config */
 int CCE_try_allocate_dlsch(int module_id,
                            int CC_id,
@@ -741,13 +741,12 @@ BSR_SHORT *get_bsr_short(module_id_t module_idP, uint8_t bsr_len);
 */
 BSR_LONG *get_bsr_long(module_id_t module_idP, uint8_t bsr_len);
 
-/*! \fn  boolean_t update_bsr(module_id_t module_idP, frame_t frameP,sub_frame_t subframeP)
+/*! \fn  bool update_bsr(module_id_t module_idP, frame_t frameP,sub_frame_t subframeP)
    \brief get the rlc stats and update the bsr level for each lcid
 \param[in] Mod_id instance of the UE
 \param[in] frame Frame index
 */
-boolean_t update_bsr(module_id_t module_idP, frame_t frameP,
-                     sub_frame_t subframeP, eNB_index_t eNB_index);
+bool update_bsr(module_id_t module_idP, frame_t frameP, sub_frame_t subframeP, eNB_index_t eNB_index);
 
 /*! \fn  locate_BsrIndexByBufferSize (int *table, int size, int value)
    \brief locate the BSR level in the table as defined in 36.321. This function requires that he values in table to be monotonic, either increasing or decreasing. The returned value is not less than 0, nor greater than n-1, where n is the size of table.

openair2/LAYER2/MAC/pre_processor.c

@@ -638,7 +638,7 @@ dlsch_scheduler_pre_processor(module_id_t Mod_id,
       LOG_E(MAC, "UE %d has RNTI NOT_A_RNTI!\n", UE_id);
       continue;
     }
-    if (UE_info->active[UE_id] != TRUE) {
+    if (UE_info->active[UE_id] != true) {
       LOG_E(MAC, "UE %d RNTI %x is NOT active!\n", UE_id, rnti);
       continue;
     }

openair2/LAYER2/MAC/ue_procedures.c

@@ -2325,8 +2325,8 @@ ue_get_sdu(module_id_t module_idP, int CC_id, frame_t frameP,
   uint8_t bsr_len = 0, bsr_ce_len = 0, bsr_header_len = 0;
   uint8_t phr_header_len = 0, phr_ce_len = 0, phr_len = 0;
   uint8_t lcid = 0, lcid_rlc_pdu_count = 0;
-  boolean_t is_lcid_processed = FALSE;
-  boolean_t is_all_lcid_processed = FALSE;
+  bool is_lcid_processed = false;
+  bool is_all_lcid_processed = false;
   uint16_t sdu_lengths[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
   uint8_t sdu_lcids[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
   uint8_t payload_offset = 0, num_sdus = 0;
@@ -2444,11 +2444,11 @@ ue_get_sdu(module_id_t module_idP, int CC_id, frame_t frameP,
   // Check for DCCH first
   // TO DO: Multiplex in the order defined by the logical channel prioritization
   for (lcid = DCCH;
-       (lcid < MAX_NUM_LCID) && (is_all_lcid_processed == FALSE); lcid++) {
+       (lcid < MAX_NUM_LCID) && (is_all_lcid_processed == false); lcid++) {
     if (UE_mac_inst[module_idP].scheduling_info.LCID_status[lcid] ==
         LCID_NOT_EMPTY) {
       lcid_rlc_pdu_count = 0;
-      is_lcid_processed = FALSE;
+      is_lcid_processed = false;
       lcid_buffer_occupancy_old =
         mac_rlc_get_buffer_occupancy_ind(module_idP,
                                          UE_mac_inst[module_idP].
@@ -2536,8 +2536,8 @@ ue_get_sdu(module_id_t module_idP, int CC_id, frame_t frameP,
             //No more remaining TBS after this PDU
             //exit the function
             rlc_pdu_header_len_last = 1;
-            is_lcid_processed = TRUE;
-            is_all_lcid_processed = TRUE;
+            is_lcid_processed = true;
+            is_all_lcid_processed = true;
           } else {
             rlc_pdu_header_len_last =
               (sdu_lengths[num_sdus] > 128) ? 3 : 2;
@@ -2547,8 +2547,8 @@ ue_get_sdu(module_id_t module_idP, int CC_id, frame_t frameP,
                 (bsr_len + phr_len + total_rlc_pdu_header_len +
                  rlc_pdu_header_len_last + sdu_length_total)) {
               rlc_pdu_header_len_last = 1;
-              is_lcid_processed = TRUE;
-              is_all_lcid_processed = TRUE;
+              is_lcid_processed = true;
+              is_all_lcid_processed = true;
             }
           }
 
@@ -2559,7 +2559,7 @@ ue_get_sdu(module_id_t module_idP, int CC_id, frame_t frameP,
           lcid_rlc_pdu_count++;
         } else {
           /* avoid infinite loop ... */
-          is_lcid_processed = TRUE;
+          is_lcid_processed = true;
         }
 
         /* Get updated BO after multiplexing this PDU */
@@ -3164,7 +3164,7 @@ ue_scheduler(const module_id_t module_idP,
   }
 
   //Check whether Regular BSR is triggered
-  if (update_bsr(module_idP, txFrameP, txSubframeP, eNB_indexP) == TRUE) {
+  if (update_bsr(module_idP, txFrameP, txSubframeP, eNB_indexP) == true) {
     // call SR procedure to generate pending SR and BSR for next PUCCH/PUSCH TxOp.  This should implement the procedures
     // outlined in Sections 5.4.4 an 5.4.5 of 36.321
     UE_mac_inst[module_idP].scheduling_info.SR_pending = 1;
@@ -3251,11 +3251,11 @@ ue_scheduler(const module_id_t module_idP,
 // to be improved
 
 
-boolean_t
+bool
 update_bsr(module_id_t module_idP, frame_t frameP,
            sub_frame_t subframeP, eNB_index_t eNB_index) {
   mac_rlc_status_resp_t rlc_status;
-  boolean_t bsr_regular_triggered = FALSE;
+  bool bsr_regular_triggered = false;
   uint8_t lcid;
   uint8_t lcgid;
   uint8_t num_lcid_with_data = 0; // for LCID with data only if LCGID is defined
@@ -3352,7 +3352,7 @@ update_bsr(module_id_t module_idP, frame_t frameP,
           (lcgid_buffer_remain
            [UE_mac_inst[module_idP].scheduling_info.LCGID[lcid]] ==
            0)) {
-        bsr_regular_triggered = TRUE;
+        bsr_regular_triggered = true;
         LOG_D(MAC,
               "[UE %d] PDCCH Tick : MAC BSR Triggered LCID%d LCGID%d data become available at frame %d subframe %d\n",
               module_idP, lcid,
@@ -3364,7 +3364,7 @@ update_bsr(module_id_t module_idP, frame_t frameP,
 
     // Trigger Regular BSR if ReTxBSR Timer has expired and UE has data for transmission
     if (UE_mac_inst[module_idP].scheduling_info.retxBSR_SF == 0) {
-      bsr_regular_triggered = TRUE;
+      bsr_regular_triggered = true;
 
       if ((UE_mac_inst[module_idP].BSR_reporting_active &
            BSR_TRIGGER_REGULAR) == 0) {

openair2/LAYER2/NR_MAC_COMMON/nr_mac_extern.h

@@ -74,7 +74,7 @@ extern uint8_t rb_table[34];
 extern uint16_t pre_nb_rbs_required[2][MAX_NUM_CCs][NUMBER_OF_UE_MAX];
 extern uint8_t dlsch_ue_select_tbl_in_use;
 extern uint8_t new_dlsch_ue_select_tbl_in_use;
-extern boolean_t pre_scd_activeUE[NUMBER_OF_UE_MAX];
+extern bool pre_scd_activeUE[NUMBER_OF_UE_MAX];
 extern eNB_UE_STATS pre_scd_eNB_UE_stats[MAX_NUM_CCs][NUMBER_OF_UE_MAX];
 #endif*/
 

openair2/LAYER2/NR_MAC_UE/config_ue.c

@@ -580,7 +580,7 @@ int nr_rrc_mac_config_req_ue_logicalChannelBearer(
     int                             cc_idP,
     uint8_t                         gNB_index,
     long                            logicalChannelIdentity,
-    boolean_t                       status){
+    bool                            status){
     NR_UE_MAC_INST_t *mac = get_mac_inst(module_id);
     mac->logicalChannelBearer_exist[logicalChannelIdentity] = status;
     return 0;

openair2/LAYER2/NR_MAC_UE/mac_defs.h

@@ -415,7 +415,7 @@ typedef struct {
   uint8_t BSR_reporting_active;
 
   /// LogicalChannelConfig has bearer.
-  boolean_t logicalChannelBearer_exist[NR_MAX_NUM_LCID];
+  bool logicalChannelBearer_exist[NR_MAX_NUM_LCID];
   NR_UE_SCHEDULING_INFO   scheduling_info;
 
   /// PHR
@@ -546,7 +546,7 @@ typedef struct prach_association_pattern {
 
 // SSB details
 typedef struct ssb_info {
-  boolean_t transmitted; // True if the SSB index is transmitted according to the SSB positions map configuration
+  bool transmitted; // True if the SSB index is transmitted according to the SSB positions map configuration
   prach_occasion_info_t *mapped_ro[MAX_NB_RO_PER_SSB_IN_ASSOCIATION_PATTERN]; // List of mapped RACH Occasions to this SSB index
   uint16_t nb_mapped_ro; // Total number of mapped ROs to this SSB index
 } ssb_info_t;

openair2/LAYER2/NR_MAC_UE/mac_proto.h

@@ -85,14 +85,12 @@ int8_t nr_ue_decode_BCCH_DL_SCH(module_id_t module_id,
    \param cc_id                     component carrier id
    \param gNB_index                 gNB index
    \param long                      logicalChannelIdentity
-   \param boolean_t                 status*/
-int nr_rrc_mac_config_req_ue_logicalChannelBearer(
-	    module_id_t                 module_id,
-	    int                         cc_idP,
-	    uint8_t                     gNB_index,
-	    long                        logicalChannelIdentity,
-	    boolean_t                   status
-);
+   \param bool                      status*/
+int nr_rrc_mac_config_req_ue_logicalChannelBearer(module_id_t module_id,
+                                                  int         cc_idP,
+                                                  uint8_t     gNB_index,
+                                                  long        logicalChannelIdentity,
+                                                  bool        status);
 
 /**\brief primitive from RRC layer to MAC layer for configuration L1/L2, now supported 4 rrc messages: MIB, cell_group_config for MAC/PHY, spcell_config(serving cell config)
    \param module_id                 module id
@@ -154,14 +152,14 @@ void fill_scheduled_response(nr_scheduled_response_t *scheduled_response,
 */
 int8_t nr_ue_get_SR(module_id_t module_idP, frame_t frameP, slot_t slotP);
 
-/*! \fn  boolean_t update_bsr(module_id_t module_idP, frame_t frameP, slot_t slotP, uint8_t gNB_index)
+/*! \fn  bool update_bsr(module_id_t module_idP, frame_t frameP, slot_t slotP, uint8_t gNB_index)
    \brief get the rlc stats and update the bsr level for each lcid
 \param[in] Mod_id instance of the UE
 \param[in] frameP Frame index
 \param[in] slot slotP number
 \param[in] uint8_t gNB_index
 */
-boolean_t nr_update_bsr(module_id_t module_idP, frame_t frameP, slot_t slotP, uint8_t gNB_index);
+bool nr_update_bsr(module_id_t module_idP, frame_t frameP, slot_t slotP, uint8_t gNB_index);
 
 /*! \fn  nr_locate_BsrIndexByBufferSize (int *table, int size, int value)
    \brief locate the BSR level in the table as defined in 38.321. This function requires that he values in table to be monotonic, either increasing or decreasing. The returned value is not less than 0, nor greater than n-1, where n is the size of table.

openair2/LAYER2/NR_MAC_UE/nr_ra_procedures.c

@@ -325,7 +325,7 @@ void ssb_rach_config(RA_config_t *ra, NR_PRACH_RESOURCES_t *prach_resources, NR_
   // =======================================
 
   NR_RACH_ConfigCommon__ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR ssb_perRACH_config = nr_rach_ConfigCommon->ssb_perRACH_OccasionAndCB_PreamblesPerSSB->present;
-  boolean_t multiple_ssb_per_ro; // true if more than one or exactly one SSB per RACH occasion, false if more than one RO per SSB
+  bool multiple_ssb_per_ro; // true if more than one or exactly one SSB per RACH occasion, false if more than one RO per SSB
   uint8_t ssb_rach_ratio; // Nb of SSBs per RACH or RACHs per SSB
   int total_preambles_per_ssb;
   uint8_t ssb_nb_in_ro;

openair2/LAYER2/NR_MAC_UE/nr_ue_procedures.c

@@ -2002,7 +2002,7 @@ int find_pucch_resource_set(NR_UE_MAC_INST_t *mac, int uci_size) {
 *                processing slots of reception/transmission
 *                gNB_id identifier
 *
-* RETURN :       TRUE a valid resource has been found
+* RETURN :       true a valid resource has been found
 *
 * DESCRIPTION :  return tx harq process identifier for given transmission slot
 *                TS 38.213 9.2.1  PUCCH Resource Sets
@@ -2132,7 +2132,7 @@ uint8_t get_downlink_ack(NR_UE_MAC_INST_t *mac,
   int number_harq_feedback = 0;
   uint32_t dai_current = 0;
   uint32_t dai_max = 0;
-  bool two_transport_blocks = FALSE;
+  bool two_transport_blocks = false;
   int number_of_code_word = 1;
   int U_DAI_c = 0;
   int N_m_c_rx = 0;
@@ -2154,7 +2154,7 @@ uint8_t get_downlink_ack(NR_UE_MAC_INST_t *mac,
       bwpd->pdsch_Config->choice.setup &&
       bwpd->pdsch_Config->choice.setup->maxNrofCodeWordsScheduledByDCI &&
       bwpd->pdsch_Config->choice.setup->maxNrofCodeWordsScheduledByDCI[0] == 2) {
-    two_transport_blocks = TRUE;
+    two_transport_blocks = true;
     number_of_code_word = 2;
   }
 
@@ -2254,7 +2254,7 @@ uint8_t get_downlink_ack(NR_UE_MAC_INST_t *mac,
   * For a monitoring occasion of a PDCCH with DCI format 1_0 or DCI format 1_1 in at least one serving cell,
   * when a UE receives a PDSCH with one transport block and the value of higher layer parameter maxNrofCodeWordsScheduledByDCI is 2,
   * the HARQ-ACK response is associated with the first transport block and the UE generates a NACK for the second transport block
-  * if spatial bundling is not applied (HARQ-ACK-spatial-bundling-PUCCH = FALSE) and generates HARQ-ACK value of ACK for the second
+  * if spatial bundling is not applied (HARQ-ACK-spatial-bundling-PUCCH = false) and generates HARQ-ACK value of ACK for the second
   * transport block if spatial bundling is applied.
   */
 
@@ -2265,7 +2265,7 @@ uint8_t get_downlink_ack(NR_UE_MAC_INST_t *mac,
         ack_data[code_word][i] = 0;     /* nack data transport block which has been missed */
         number_harq_feedback++;
       }
-      if (two_transport_blocks == TRUE) {
+      if (two_transport_blocks == true) {
         dai_total[code_word][i] = dai[code_word][i]; /* for a single cell, dai_total is the same as dai of first cell */
       }
     }
@@ -2296,7 +2296,7 @@ uint8_t get_downlink_ack(NR_UE_MAC_INST_t *mac,
       o_ACK = o_ACK | (ack_data[1][m] << O_bit_number_cw1);
     }
 
-    if (two_transport_blocks == TRUE) {
+    if (two_transport_blocks == true) {
       O_bit_number_cw0 = (8 * j) + 2*(V_temp - 1);
     }
     else {
@@ -2311,7 +2311,7 @@ uint8_t get_downlink_ack(NR_UE_MAC_INST_t *mac,
     j = j + 1;
   }
 
-  if (two_transport_blocks == TRUE) {
+  if (two_transport_blocks == true) {
     O_ACK = 2 * ( 4 * j + V_temp2);  /* for two transport blocks */
   }
   else {

openair2/LAYER2/NR_MAC_UE/nr_ue_scheduler.c

@@ -1254,7 +1254,7 @@ NR_UE_L2_STATE_t nr_ue_scheduler(nr_downlink_indication_t *dl_info, nr_uplink_in
   }
 
   //Check whether Regular BSR is triggered
-  if (nr_update_bsr(mod_id, txFrameP, txSlotP, gNB_indexP) == TRUE) {
+  if (nr_update_bsr(mod_id, txFrameP, txSlotP, gNB_indexP) == true) {
     // call SR procedure to generate pending SR and BSR for next PUCCH/PUSCH TxOp.  This should implement the procedures
     // outlined in Sections 5.4.4 an 5.4.5 of 38.321
     mac->scheduling_info.SR_pending = 1;
@@ -1267,10 +1267,10 @@ NR_UE_L2_STATE_t nr_ue_scheduler(nr_downlink_indication_t *dl_info, nr_uplink_in
 
 }
 
-boolean_t
+bool
 nr_update_bsr(module_id_t module_idP, frame_t frameP, slot_t slotP, uint8_t gNB_index) {
   mac_rlc_status_resp_t rlc_status;
-  boolean_t bsr_regular_triggered = FALSE;
+  bool bsr_regular_triggered = false;
   uint8_t lcid;
   uint8_t lcgid;
   uint8_t num_lcid_with_data = 0; // for LCID with data only if LCGID is defined
@@ -1363,7 +1363,7 @@ nr_update_bsr(module_id_t module_idP, frame_t frameP, slot_t slotP, uint8_t gNB_
          which belong to any LCG and for which data is already available for transmission
        */
       {
-        bsr_regular_triggered = TRUE;
+        bsr_regular_triggered = true;
         LOG_D(NR_MAC, "[UE %d] PDCCH Tick : MAC BSR Triggered LCID%d LCGID%d data become available at frame %d slot %d\n",
               module_idP, lcid,
               mac->scheduling_info.LCGID[lcid],
@@ -1374,7 +1374,7 @@ nr_update_bsr(module_id_t module_idP, frame_t frameP, slot_t slotP, uint8_t gNB_
 
     // Trigger Regular BSR if ReTxBSR Timer has expired and UE has data for transmission
     if (mac->scheduling_info.retxBSR_SF == 0) {
-      bsr_regular_triggered = TRUE;
+      bsr_regular_triggered = true;
 
       if ((mac->BSR_reporting_active & NR_BSR_TRIGGER_REGULAR) == 0) {
         LOG_I(NR_MAC, "[UE %d] PDCCH Tick : MAC BSR Triggered ReTxBSR Timer expiry at frame %d slot %d\n",
@@ -1635,7 +1635,7 @@ static void build_ro_list(NR_UE_MAC_INST_t *mac) {
   int y2;  // PRACH Configuration Index table additional variable used to compute the valid frame numbers
   uint8_t slot_shift_for_map;
   uint8_t map_shift;
-  boolean_t even_slot_invalid;
+  bool even_slot_invalid;
   int64_t s_map;
   uint8_t prach_conf_start_symbol; // Starting symbol of the PRACH occasions in the PRACH slot
   uint8_t N_t_slot; // Number of PRACH occasions in a 14-symbols PRACH slot
@@ -1907,7 +1907,7 @@ static void map_ssb_to_ro(NR_UE_MAC_INST_t *mac) {
     mac->scc_SIB->uplinkConfigCommon->initialUplinkBWP.rach_ConfigCommon->choice.setup;
   NR_RACH_ConfigCommon__ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR ssb_perRACH_config = setup->ssb_perRACH_OccasionAndCB_PreamblesPerSSB->present;
 
-  boolean_t multiple_ssb_per_ro; // true if more than one or exactly one SSB per RACH occasion, false if more than one RO per SSB
+  bool multiple_ssb_per_ro; // true if more than one or exactly one SSB per RACH occasion, false if more than one RO per SSB
   uint8_t ssb_rach_ratio; // Nb of SSBs per RACH or RACHs per SSB
   uint16_t required_nb_of_prach_occasion; // Nb of RACH occasions required to map all the SSBs
   uint8_t required_nb_of_prach_conf_period; // Nb of PRACH configuration periods required to map all the SSBs

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_dlsch.c

@@ -365,6 +365,18 @@ void nr_store_dlsch_buffer(module_id_t module_id,
   }
 }
 
+void abort_nr_dl_harq(NR_UE_info_t* UE, int8_t harq_pid) {
+
+  NR_UE_sched_ctrl_t *sched_ctrl = &UE->UE_sched_ctrl;
+  NR_UE_harq_t *harq = &sched_ctrl->harq_processes[harq_pid];
+
+  harq->ndi ^= 1;
+  harq->round = 0;
+  UE->mac_stats.dl.errors++;
+  add_tail_nr_list(&sched_ctrl->available_dl_harq, harq_pid);
+
+}
+
 bool allocate_dl_retransmission(module_id_t module_id,
                                 frame_t frame,
                                 sub_frame_t slot,
@@ -378,6 +390,17 @@ bool allocate_dl_retransmission(module_id_t module_id,
   NR_UE_sched_ctrl_t *sched_ctrl = &UE->UE_sched_ctrl;
   NR_sched_pdsch_t *retInfo = &sched_ctrl->harq_processes[current_harq_pid].sched_pdsch;
   NR_CellGroupConfig_t *cg = UE->CellGroup;
+  NR_pdsch_semi_static_t *ps = &sched_ctrl->pdsch_semi_static;
+
+  //TODO remove this and handle retransmission with old nrOfLayers
+  //     once ps structure is removed
+  if(ps->nrOfLayers < retInfo->nrOfLayers) {
+    LOG_W(NR_MAC,"Cannot schedule retransmission. RI changed from %d to %d\n",
+          retInfo->nrOfLayers, ps->nrOfLayers);
+    abort_nr_dl_harq(UE, current_harq_pid);
+    remove_front_nr_list(&sched_ctrl->retrans_dl_harq);
+    return false;
+  }
 
   NR_BWP_DownlinkDedicated_t *bwpd =
       cg &&
@@ -401,7 +424,6 @@ bool allocate_dl_retransmission(module_id_t module_id,
   const uint16_t bwpSize = coresetid == 0 ? RC.nrmac[module_id]->cset0_bwp_size : NRRIV2BW(genericParameters->locationAndBandwidth, MAX_BWP_SIZE);
 
   int rbStart = 0; // start wrt BWPstart
-  NR_pdsch_semi_static_t *ps = &sched_ctrl->pdsch_semi_static;
   int rbSize = 0;
   const int tda = get_dl_tda(RC.nrmac[module_id], scc, slot);
   AssertFatal(tda>=0,"Unable to find PDSCH time domain allocation in list\n");
@@ -1355,6 +1377,8 @@ void nr_schedule_ue_spec(module_id_t module_id,
       /* save which time allocation has been used, to be used on
        * retransmissions */
       harq->sched_pdsch.time_domain_allocation = ps->time_domain_allocation;
+      /* save nr of layers for retransmissions */
+      harq->sched_pdsch.nrOfLayers = ps->nrOfLayers;
 
       // ta command is sent, values are reset
       if (sched_ctrl->ta_apply) {

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_uci.c

@@ -826,14 +826,8 @@ static void handle_dl_harq(NR_UE_info_t * UE,
     harq->ndi ^= 1;
 
   } else if (harq->round >= harq_round_max - 1) {
-    add_tail_nr_list(&UE->UE_sched_ctrl.available_dl_harq, harq_pid);
-    harq->round = 0;
-    harq->ndi ^= 1;
-
-    NR_mac_stats_t *stats = &UE->mac_stats;
-    stats->dl.errors++;
-    LOG_D(NR_MAC, "retransmission error for UE %04x (total %"PRIu64")\n", UE->rnti, stats->dl.errors);
-
+    abort_nr_dl_harq(UE, harq_pid);
+    LOG_D(NR_MAC, "retransmission error for UE %04x (total %"PRIu64")\n", UE->rnti, UE->mac_stats.dl.errors);
   } else {
     LOG_D(PHY,"NACK for: pid %d, ue %04x\n",harq_pid, UE->rnti);
     add_tail_nr_list(&UE->UE_sched_ctrl.retrans_dl_harq, harq_pid);

openair2/LAYER2/NR_MAC_gNB/mac_proto.h

@@ -529,4 +529,6 @@ size_t dump_mac_stats(gNB_MAC_INST *gNB, char *output, size_t strlen, bool reset
 
 void process_CellGroup(NR_CellGroupConfig_t *CellGroup, NR_UE_sched_ctrl_t *sched_ctrl);
 
+void abort_nr_dl_harq(NR_UE_info_t* UE, int8_t harq_pid);
+
 #endif /*__LAYER2_NR_MAC_PROTO_H__*/

openair2/LAYER2/NR_MAC_gNB/main.c

@@ -215,8 +215,8 @@ void mac_top_init_gNB(void)
         RC.nrmac[i]->pre_processor_dl = nr_init_fr1_dlsch_preprocessor(i, 0);
         RC.nrmac[i]->pre_processor_ul = nr_init_fr1_ulsch_preprocessor(i, 0);
       }
-      pthread_create(&RC.nrmac[i]->stats_thread,NULL,nrmac_stats_thread,(void*)RC.nrmac[i]);
-
+      if (!IS_SOFTMODEM_NOSTATS_BIT)
+        pthread_create(&RC.nrmac[i]->stats_thread, NULL, nrmac_stats_thread, (void*)RC.nrmac[i]);
     }//END for (i = 0; i < RC.nb_nr_macrlc_inst; i++)
 
     AssertFatal(rlc_module_init(1) == 0,"Could not initialize RLC layer\n");

openair2/LAYER2/NR_MAC_gNB/nr_mac_gNB.h

@@ -441,6 +441,7 @@ typedef struct NR_sched_pdsch {
   /// only important for retransmissions; otherwise, the TDA in
   /// NR_pdsch_semi_static_t has precedence
   int time_domain_allocation;
+  uint8_t nrOfLayers;
 } NR_sched_pdsch_t;
 
 typedef struct NR_UE_harq {
@@ -674,7 +675,6 @@ typedef struct {
 } NR_UE_sched_ctrl_t;
 
 typedef struct {
-  boolean_t fiveG_connected;
   uicc_t *uicc;
 } NRUEcontext_t;
 

openair2/LAYER2/PDCP_v10.1.0/pdcp.c

@@ -139,7 +139,7 @@ extern volatile int oai_exit;
 pthread_t pdcp_stats_thread_desc;
 
 // will be called when 4G F1 implementation will use GTP-U instead of protobuf
-boolean_t cu_f1u_data_req(
+bool cu_f1u_data_req(
   protocol_ctxt_t  *ctxt_pP,
   const srb_flag_t srb_flagP,
   const rb_id_t rb_id,
@@ -228,7 +228,7 @@ rlc_op_status_t cu_send_to_du(const protocol_ctxt_t *const ctxt,
 	__func__, rb_id, size);
   extern instance_t CUuniqInstance;
   itti_send_msg_to_task(TASK_GTPV1_U, CUuniqInstance, message_p);
-  return TRUE;
+  return true;
 }
 
 //-----------------------------------------------------------------------------
@@ -239,18 +239,16 @@ rlc_op_status_t cu_send_to_du(const protocol_ctxt_t *const ctxt,
  * this mem_block_t to be dissected for testing purposes. For further details see test
  * code at targets/TEST/PDCP/test_pdcp.c:test_pdcp_data_req()
  */
-boolean_t pdcp_data_req(
-  protocol_ctxt_t  *ctxt_pP,
-  const srb_flag_t     srb_flagP,
-  const rb_id_t        rb_idP,
-  const mui_t          muiP,
-  const confirm_t      confirmP,
-  const sdu_size_t     sdu_buffer_sizeP,
-  unsigned char *const sdu_buffer_pP,
-  const pdcp_transmission_mode_t modeP,
-  const uint32_t *const sourceL2Id,
-  const uint32_t *const destinationL2Id
-)
+bool pdcp_data_req(protocol_ctxt_t  *ctxt_pP,
+                   const srb_flag_t     srb_flagP,
+                   const rb_id_t        rb_idP,
+                   const mui_t          muiP,
+                   const confirm_t      confirmP,
+                   const sdu_size_t     sdu_buffer_sizeP,
+                   unsigned char *const sdu_buffer_pP,
+                   const pdcp_transmission_mode_t modeP,
+                   const uint32_t *const sourceL2Id,
+                   const uint32_t *const destinationL2Id)
 //-----------------------------------------------------------------------------
 {
   pdcp_t            *pdcp_p          = NULL;
@@ -261,7 +259,7 @@ boolean_t pdcp_data_req(
   uint16_t           current_sn      = 0;
   mem_block_t       *pdcp_pdu_p      = NULL;
   rlc_op_status_t    rlc_status;
-  boolean_t          ret             = TRUE;
+  bool               ret             = true;
   hash_key_t         key             = HASHTABLE_NOT_A_KEY_VALUE;
   hashtable_rc_t     h_rc;
   uint8_t            rb_offset= (srb_flagP == 0) ? DTCH -1 : 0;
@@ -277,7 +275,7 @@ boolean_t pdcp_data_req(
 
   if (sdu_buffer_sizeP == 0) {
     LOG_W(PDCP, "Handed SDU is of size 0! Ignoring...\n");
-    return FALSE;
+    return false;
   }
 
   /*
@@ -287,12 +285,12 @@ boolean_t pdcp_data_req(
               sdu_buffer_sizeP, MAX_IP_PACKET_SIZE);
 
   if (modeP == PDCP_TRANSMISSION_MODE_TRANSPARENT) {
-    AssertError (rb_idP < NB_RB_MBMS_MAX, return FALSE, "RB id is too high (%ld/%d) %u %u!\n", rb_idP, NB_RB_MBMS_MAX, ctxt_pP->module_id, ctxt_pP->rnti);
+    AssertError (rb_idP < NB_RB_MBMS_MAX, return false, "RB id is too high (%ld/%d) %u %u!\n", rb_idP, NB_RB_MBMS_MAX, ctxt_pP->module_id, ctxt_pP->rnti);
   } else {
     if (srb_flagP) {
-      AssertError (rb_idP < 3, return FALSE, "RB id is too high (%ld/%d) %u %u!\n", rb_idP, 3, ctxt_pP->module_id, ctxt_pP->rnti);
+      AssertError (rb_idP < 3, return false, "RB id is too high (%ld/%d) %u %u!\n", rb_idP, 3, ctxt_pP->module_id, ctxt_pP->rnti);
     } else {
-      AssertError (rb_idP < LTE_maxDRB, return FALSE, "RB id is too high (%ld/%d) %u %u!\n", rb_idP, LTE_maxDRB, ctxt_pP->module_id, ctxt_pP->rnti);
+      AssertError (rb_idP < LTE_maxDRB, return false, "RB id is too high (%ld/%d) %u %u!\n", rb_idP, LTE_maxDRB, ctxt_pP->module_id, ctxt_pP->rnti);
     }
   }
 
@@ -304,7 +302,7 @@ boolean_t pdcp_data_req(
       LOG_W(PDCP, PROTOCOL_CTXT_FMT" Instance is not configured for rb_id %ld Ignoring SDU...\n",
             PROTOCOL_CTXT_ARGS(ctxt_pP),
             rb_idP);
-      return FALSE;
+      return false;
     }
   }
 
@@ -371,7 +369,7 @@ boolean_t pdcp_data_req(
         memset(&pdu_header.mac_i[0],0,PDCP_CONTROL_PLANE_DATA_PDU_MAC_I_SIZE);
         memset(&pdcp_pdu_p->data[sdu_buffer_sizeP + pdcp_header_len],0,PDCP_CONTROL_PLANE_DATA_PDU_MAC_I_SIZE);
 
-        if (pdcp_serialize_control_plane_data_pdu_with_SRB_sn_buffer((unsigned char *)pdcp_pdu_p->data, &pdu_header) == FALSE) {
+        if (pdcp_serialize_control_plane_data_pdu_with_SRB_sn_buffer((unsigned char *)pdcp_pdu_p->data, &pdu_header) == false) {
           LOG_E(PDCP, PROTOCOL_PDCP_CTXT_FMT" Cannot fill PDU buffer with relevant header fields!\n",
                 PROTOCOL_PDCP_CTXT_ARGS(ctxt_pP,pdcp_p));
 
@@ -382,7 +380,7 @@ boolean_t pdcp_data_req(
           }
 
           VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_DATA_REQ,VCD_FUNCTION_OUT);
-          return FALSE;
+          return false;
         }
       } else {
         pdcp_user_plane_data_pdu_header_with_long_sn pdu_header;
@@ -390,7 +388,7 @@ boolean_t pdcp_data_req(
         pdu_header.sn = pdcp_get_next_tx_seq_number(pdcp_p);
         current_sn = pdu_header.sn ;
 
-        if (pdcp_serialize_user_plane_data_pdu_with_long_sn_buffer((unsigned char *)pdcp_pdu_p->data, &pdu_header) == FALSE) {
+        if (pdcp_serialize_user_plane_data_pdu_with_long_sn_buffer((unsigned char *)pdcp_pdu_p->data, &pdu_header) == false) {
           LOG_E(PDCP, PROTOCOL_PDCP_CTXT_FMT" Cannot fill PDU buffer with relevant header fields!\n",
                 PROTOCOL_PDCP_CTXT_ARGS(ctxt_pP,pdcp_p));
 
@@ -401,7 +399,7 @@ boolean_t pdcp_data_req(
           }
 
           VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_DATA_REQ,VCD_FUNCTION_OUT);
-          return FALSE;
+          return false;
         }
       }
 
@@ -422,7 +420,7 @@ boolean_t pdcp_data_req(
         }
 
         VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_DATA_REQ,VCD_FUNCTION_OUT);
-        return FALSE;
+        return false;
       }
 
       LOG_D(PDCP, "Sequence number %d is assigned to current PDU\n", current_sn);
@@ -481,7 +479,7 @@ boolean_t pdcp_data_req(
             ctxt_pP->module_id,
             rb_idP);
       VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_DATA_REQ,VCD_FUNCTION_OUT);
-      return FALSE;
+      return false;
     }
 
     /*
@@ -497,16 +495,16 @@ boolean_t pdcp_data_req(
 
       if (ctxt_pP->enb_flag == ENB_FLAG_YES && NODE_IS_DU(RC.rrc[ctxt_pP->module_id]->node_type)) {
         LOG_E(PDCP, "Can't be DU, bad node type %d \n", RC.rrc[ctxt_pP->module_id]->node_type);
-        ret=FALSE;
+        ret = false;
       } else {
         rlc_status = pdcp_params.send_rlc_data_req_func(ctxt_pP, srb_flagP, MBMS_FLAG_NO, rb_idP, muiP,
                      confirmP, pdcp_pdu_size, pdcp_pdu_p,sourceL2Id,
                      destinationL2Id);
-	ret=FALSE;
+        ret = false;
         switch (rlc_status) {
           case RLC_OP_STATUS_OK:
             LOG_D(PDCP, "Data sending request over RLC succeeded!\n");
-            ret=TRUE;
+            ret=true;
             break;
 
           case RLC_OP_STATUS_BAD_PARAMETER:
@@ -544,7 +542,7 @@ boolean_t pdcp_data_req(
         itti_send_msg_to_task (TASK_CU_F1, ctxt_pP->module_id, message_p);
         //CU_send_DL_RRC_MESSAGE_TRANSFER(ctxt_pP->module_id, message_p);
         LOG_I(PDCP, "Send F1AP_DL_RRC_MESSAGE with ITTI\n");
-        ret=TRUE;
+        ret=true;
       } else {
         rlc_status = rlc_data_req(ctxt_pP
                                   , srb_flagP
@@ -561,27 +559,27 @@ boolean_t pdcp_data_req(
         switch (rlc_status) {
           case RLC_OP_STATUS_OK:
             LOG_D(PDCP, "Data sending request over RLC succeeded!\n");
-            ret=TRUE;
+            ret=true;
             break;
 
           case RLC_OP_STATUS_BAD_PARAMETER:
             LOG_W(PDCP, "Data sending request over RLC failed with 'Bad Parameter' reason!\n");
-            ret= FALSE;
+            ret= false;
             break;
 
           case RLC_OP_STATUS_INTERNAL_ERROR:
             LOG_W(PDCP, "Data sending request over RLC failed with 'Internal Error' reason!\n");
-            ret= FALSE;
+            ret= false;
             break;
 
           case RLC_OP_STATUS_OUT_OF_RESSOURCES:
             LOG_W(PDCP, "Data sending request over RLC failed with 'Out of Resources' reason!\n");
-            ret= FALSE;
+            ret= false;
             break;
 
           default:
             LOG_W(PDCP, "RLC returned an unknown status code after PDCP placed the order to send some data (Status Code:%d)\n", rlc_status);
-            ret= FALSE;
+            ret= false;
             break;
         } // switch case
       }
@@ -596,7 +594,7 @@ boolean_t pdcp_data_req(
 
   /*
    * Control arrives here only if rlc_data_req() returns RLC_OP_STATUS_OK
-   * so we return TRUE afterwards
+   * so we return true afterwards
    */
 
   for (pdcp_uid=0; pdcp_uid< MAX_MOBILES_PER_ENB; pdcp_uid++) {
@@ -619,7 +617,7 @@ boolean_t pdcp_data_req(
 
 
 //-----------------------------------------------------------------------------
-boolean_t
+bool
 pdcp_data_ind(
   const protocol_ctxt_t *const ctxt_pP,
   const srb_flag_t   srb_flagP,
@@ -638,7 +636,7 @@ pdcp_data_ind(
   pdcp_sn_t    sequence_number = 0;
   volatile sdu_size_t   payload_offset  = 0;
   rb_id_t      rb_id            = rb_idP;
-  boolean_t    packet_forwarded = FALSE;
+  bool         packet_forwarded = false;
   hash_key_t      key             = HASHTABLE_NOT_A_KEY_VALUE;
   hashtable_rc_t  h_rc;
   uint8_t      rb_offset= (srb_flagP == 0) ? DTCH -1 :0;
@@ -654,7 +652,7 @@ pdcp_data_ind(
               "[MSG] PDCP UL %s PDU on rb_id %ld\n", (srb_flagP)? "CONTROL" : "DATA", rb_idP);
 
   if (MBMS_flagP) {
-    AssertError (rb_idP < NB_RB_MBMS_MAX, return FALSE,
+    AssertError (rb_idP < NB_RB_MBMS_MAX, return false,
                  "RB id is too high (%ld/%d) %u rnti %x!\n",
                  rb_idP,
                  NB_RB_MBMS_MAX,
@@ -680,12 +678,12 @@ pdcp_data_ind(
     }
   } else {
     rb_id = rb_idP % LTE_maxDRB;
-    AssertError (rb_id < LTE_maxDRB, return FALSE, "RB id is too high (%ld/%d) %u UE %x!\n",
+    AssertError (rb_id < LTE_maxDRB, return false, "RB id is too high (%ld/%d) %u UE %x!\n",
                  rb_id,
                  LTE_maxDRB,
                  ctxt_pP->module_id,
                  ctxt_pP->rnti);
-    AssertError (rb_id > 0, return FALSE, "RB id is too low (%ld/%d) %u UE %x!\n",
+    AssertError (rb_id > 0, return false, "RB id is too low (%ld/%d) %u UE %x!\n",
                  rb_id,
                  LTE_maxDRB,
                  ctxt_pP->module_id,
@@ -700,14 +698,14 @@ pdcp_data_ind(
             key);
       free_mem_block(sdu_buffer_pP, __func__);
       VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_DATA_IND,VCD_FUNCTION_OUT);
-      return FALSE;
+      return false;
     }
   }
 
 
   if (sdu_buffer_sizeP == 0) {
     LOG_W(PDCP, "SDU buffer size is zero! Ignoring this chunk!\n");
-    return FALSE;
+    return false;
   }
 
   if (ctxt_pP->enb_flag) {
@@ -764,13 +762,13 @@ pdcp_data_ind(
       }
 
       VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_DATA_IND,VCD_FUNCTION_OUT);
-      return FALSE;
+      return false;
     }
 
 #if 0
 
     /* Removed by Cedric */
-    if (pdcp_is_rx_seq_number_valid(sequence_number, pdcp_p, srb_flagP) == TRUE) {
+    if (pdcp_is_rx_seq_number_valid(sequence_number, pdcp_p, srb_flagP) == true) {
       LOG_T(PDCP, "Incoming PDU has a sequence number (%d) in accordance with RX window\n", sequence_number);
       /* if (dc == PDCP_DATA_PDU )
       LOG_D(PDCP, "Passing piggybacked SDU to NAS driver...\n");
@@ -788,7 +786,7 @@ pdcp_data_ind(
        */
       LOG_W(PDCP, "Ignoring PDU...\n");
       free_mem_block(sdu_buffer_pP, __func__);
-      return FALSE;
+      return false;
     }
 
 #endif
@@ -837,7 +835,7 @@ pdcp_data_ind(
         LOG_W(PDCP, "Ignoring PDU...\n");
         free_mem_block(sdu_buffer_pP, __func__);
         /* TODO: indicate integrity verification failure to upper layer */
-        return FALSE;
+        return false;
       }
 
       if (sequence_number < pdcp_p->next_pdcp_rx_sn)
@@ -864,7 +862,7 @@ pdcp_data_ind(
       }
 
       VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_DATA_IND,VCD_FUNCTION_OUT);
-      return TRUE;
+      return true;
     } /* if (srb_flagP) */
 
     /*
@@ -892,7 +890,7 @@ pdcp_data_ind(
           LOG_W(PDCP, "Ignoring PDU...\n");
           free_mem_block(sdu_buffer_pP, __func__);
           /* TODO: indicate integrity verification failure to upper layer */
-          return FALSE;
+          return false;
         } else if (pdcp_p->next_pdcp_rx_sn - sequence_number > reordering_window) {
           pdcp_p->rx_hfn++;
           rx_hfn_for_count  = pdcp_p->rx_hfn;
@@ -948,7 +946,7 @@ pdcp_data_ind(
           LOG_W(PDCP, "Ignoring PDU...\n");
           free_mem_block(sdu_buffer_pP, __func__);
           /* TODO: indicate integrity verification failure to upper layer */
-          return FALSE;
+          return false;
         }
 
         /* TODO: specs say we have to store this PDU in a list and then deliver
@@ -1015,7 +1013,7 @@ pdcp_data_ind(
           LOG_W(PDCP, "Ignoring PDU...\n");
           free_mem_block(sdu_buffer_pP, __func__);
           /* TODO: indicate integrity verification failure to upper layer */
-          return FALSE;
+          return false;
         }
 
         break;
@@ -1039,7 +1037,7 @@ pdcp_data_ind(
     }
 
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_DATA_IND,VCD_FUNCTION_OUT);
-    return TRUE;
+    return true;
   }
 
   // XXX Decompression would be done at this point
@@ -1051,7 +1049,7 @@ pdcp_data_ind(
    */
 
   if (LINK_ENB_PDCP_TO_GTPV1U) {
-    if ((TRUE == ctxt_pP->enb_flag) && (FALSE == srb_flagP)) {
+    if ((true == ctxt_pP->enb_flag) && (false == srb_flagP)) {
       LOG_D(PDCP, "Sending packet to GTP, Calling GTPV1U_ENB_TUNNEL_DATA_REQ  ue %x rab %ld len %u\n",
             ctxt_pP->rnti,
             rb_id + 4,
@@ -1069,10 +1067,10 @@ pdcp_data_ind(
       GTPV1U_ENB_TUNNEL_DATA_REQ(message_p).rnti         = ctxt_pP->rnti;
       GTPV1U_ENB_TUNNEL_DATA_REQ(message_p).rab_id       = rb_id + 4;
       itti_send_msg_to_task(TASK_GTPV1_U, INSTANCE_DEFAULT, message_p);
-      packet_forwarded = TRUE;
+      packet_forwarded = true;
     }
   } else {
-    packet_forwarded = FALSE;
+    packet_forwarded = false;
   }
 
 #ifdef MBMS_MULTICAST_OUT
@@ -1086,13 +1084,13 @@ pdcp_data_ind(
    // dest_addr.sin_addr.s_addr = ip_header->daddr;
 
    // sendto(mbms_socket, &sdu_buffer_pP->data[payload_offset], sdu_buffer_sizeP - payload_offset, MSG_DONTWAIT, (struct sockaddr*)&dest_addr, sizeof(dest_addr));
-   // //packet_forwarded = TRUE;
+   // //packet_forwarded = true;
 
   }
 
 #endif
 
-  if (FALSE == packet_forwarded) {
+  if (false == packet_forwarded) {
     notifiedFIFO_elt_t * new_sdu_p = newNotifiedFIFO_elt(sdu_buffer_sizeP - payload_offset + sizeof (pdcp_data_ind_header_t), 0, NULL, NULL);
 
       if ((MBMS_flagP == 0) && (pdcp_p->rlc_mode == RLC_MODE_AM)) {
@@ -1185,7 +1183,7 @@ pdcp_data_ind(
   }
 
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_DATA_IND,VCD_FUNCTION_OUT);
-  return TRUE;
+  return true;
 }
 
 void pdcp_update_stats(const protocol_ctxt_t *const  ctxt_pP) {
@@ -1297,7 +1295,7 @@ pdcp_run (
                                   NULL, NULL
                                  );
 
-          if (result != TRUE)
+          if (result != true)
             LOG_E(PDCP, "PDCP data request failed!\n");
 
           // Message buffer has been processed, free it now.
@@ -1420,7 +1418,7 @@ pdcp_mbms_run (
 //                                  NULL, NULL
 //                                 );
 //
-//          if (result != TRUE)
+//          if (result != true)
 //            LOG_E(PDCP, "PDCP data request failed!\n");
 //
 //          // Message buffer has been processed, free it now.
@@ -1549,10 +1547,7 @@ void pdcp_add_UE(const protocol_ctxt_t *const  ctxt_pP) {
 }
 
 //-----------------------------------------------------------------------------
-boolean_t
-pdcp_remove_UE(
-  const protocol_ctxt_t *const  ctxt_pP
-)
+bool pdcp_remove_UE(const protocol_ctxt_t *const  ctxt_pP)
 //-----------------------------------------------------------------------------
 {
   LTE_DRB_Identity_t  srb_id         = 0;
@@ -1599,19 +1594,17 @@ pdcp_remove_UE(
 
 
 //-----------------------------------------------------------------------------
-boolean_t
-rrc_pdcp_config_asn1_req (
-  const protocol_ctxt_t *const  ctxt_pP,
-  LTE_SRB_ToAddModList_t  *const srb2add_list_pP,
-  LTE_DRB_ToAddModList_t  *const drb2add_list_pP,
-  LTE_DRB_ToReleaseList_t *const drb2release_list_pP,
-  const uint8_t                   security_modeP,
-  uint8_t                  *const kRRCenc_pP,
-  uint8_t                  *const kRRCint_pP,
-  uint8_t                  *const kUPenc_pP,
-  LTE_PMCH_InfoList_r9_t  *const pmch_InfoList_r9_pP,
-  rb_id_t                 *const defaultDRB
-)
+bool
+rrc_pdcp_config_asn1_req(const protocol_ctxt_t *const  ctxt_pP,
+                         LTE_SRB_ToAddModList_t  *const srb2add_list_pP,
+                         LTE_DRB_ToAddModList_t  *const drb2add_list_pP,
+                         LTE_DRB_ToReleaseList_t *const drb2release_list_pP,
+                         const uint8_t                   security_modeP,
+                         uint8_t                  *const kRRCenc_pP,
+                         uint8_t                  *const kRRCint_pP,
+                         uint8_t                  *const kUPenc_pP,
+                         LTE_PMCH_InfoList_r9_t  *const pmch_InfoList_r9_pP,
+                         rb_id_t                 *const defaultDRB)
 //-----------------------------------------------------------------------------
 {
   long int        lc_id          = 0;
@@ -1669,7 +1662,7 @@ rrc_pdcp_config_asn1_req (
                 PROTOCOL_PDCP_CTXT_ARGS(ctxt_pP, pdcp_p),
                 key);
           free(pdcp_p);
-          return TRUE;
+          return true;
         } else {
           LOG_D(PDCP, PROTOCOL_PDCP_CTXT_FMT" CONFIG_ACTION_ADD key 0x%"PRIx64"\n",
                 PROTOCOL_PDCP_CTXT_ARGS(ctxt_pP, pdcp_p),
@@ -1784,13 +1777,13 @@ rrc_pdcp_config_asn1_req (
                 PROTOCOL_PDCP_CTXT_ARGS(ctxt_pP, pdcp_p),
                 key_defaultDRB);
           free(pdcp_p);
-          return TRUE;
+          return true;
         } else if (h_rc != HASH_TABLE_OK) {
           LOG_E(PDCP, PROTOCOL_PDCP_CTXT_FMT" CONFIG_ACTION_ADD ADD key 0x%"PRIx64" FAILED\n",
                 PROTOCOL_PDCP_CTXT_ARGS(ctxt_pP, pdcp_p),
                 key);
           free(pdcp_p);
-          return TRUE;
+          return true;
         } else {
           LOG_D(PDCP, PROTOCOL_PDCP_CTXT_FMT" CONFIG_ACTION_ADD ADD key 0x%"PRIx64"\n",
                 PROTOCOL_PDCP_CTXT_ARGS(ctxt_pP, pdcp_p),
@@ -1944,7 +1937,7 @@ rrc_pdcp_config_asn1_req (
         if (ctxt_pP->enb_flag) {
           drb_id =  (mch_id * LTE_maxSessionPerPMCH ) + lc_id ;//+ (LTE_maxDRB + 3)*MAX_MOBILES_PER_ENB; // 1
 
-          if (pdcp_mbms_array_eNB[ctxt_pP->module_id][mch_id][lc_id].instanciated_instance == TRUE) {
+          if (pdcp_mbms_array_eNB[ctxt_pP->module_id][mch_id][lc_id].instanciated_instance == true) {
             action = CONFIG_ACTION_MBMS_MODIFY;
           } else {
             action = CONFIG_ACTION_MBMS_ADD;
@@ -1952,7 +1945,7 @@ rrc_pdcp_config_asn1_req (
         } else {
           drb_id =  (mch_id * LTE_maxSessionPerPMCH ) + lc_id; // + (LTE_maxDRB + 3); // 15
 
-          if (pdcp_mbms_array_ue[ctxt_pP->module_id][mch_id][lc_id].instanciated_instance == TRUE) {
+          if (pdcp_mbms_array_ue[ctxt_pP->module_id][mch_id][lc_id].instanciated_instance == true) {
             action = CONFIG_ACTION_MBMS_MODIFY;
           } else {
             action = CONFIG_ACTION_MBMS_ADD;
@@ -1990,23 +1983,22 @@ rrc_pdcp_config_asn1_req (
 }
 
 //-----------------------------------------------------------------------------
-boolean_t
-pdcp_config_req_asn1 (
-  const protocol_ctxt_t *const  ctxt_pP,
-  pdcp_t          *const        pdcp_pP,
-  const srb_flag_t              srb_flagP,
-  const rlc_mode_t              rlc_modeP,
-  const config_action_t         actionP,
-  const uint16_t                lc_idP,
-  const uint16_t                mch_idP,
-  const rb_id_t                 rb_idP,
-  const uint8_t                 rb_snP,
-  const uint8_t                 rb_reportP,
-  const uint16_t                header_compression_profileP,
-  const uint8_t                 security_modeP,
-  uint8_t         *const        kRRCenc_pP,
-  uint8_t         *const        kRRCint_pP,
-  uint8_t         *const        kUPenc_pP)
+bool
+pdcp_config_req_asn1(const protocol_ctxt_t *const  ctxt_pP,
+                     pdcp_t          *const        pdcp_pP,
+                     const srb_flag_t              srb_flagP,
+                     const rlc_mode_t              rlc_modeP,
+                     const config_action_t         actionP,
+                     const uint16_t                lc_idP,
+                     const uint16_t                mch_idP,
+                     const rb_id_t                 rb_idP,
+                     const uint8_t                 rb_snP,
+                     const uint8_t                 rb_reportP,
+                     const uint16_t                header_compression_profileP,
+                     const uint8_t                 security_modeP,
+                     uint8_t         *const        kRRCenc_pP,
+                     uint8_t         *const        kRRCint_pP,
+                     uint8_t         *const        kUPenc_pP)
 //-----------------------------------------------------------------------------
 {
 
@@ -2015,7 +2007,7 @@ pdcp_config_req_asn1 (
       DevAssert(pdcp_pP != NULL);
 
       if (ctxt_pP->enb_flag == ENB_FLAG_YES) {
-        pdcp_pP->is_ue = FALSE;
+        pdcp_pP->is_ue = false;
         pdcp_add_UE(ctxt_pP);
 
         //pdcp_eNB_UE_instance_to_rnti[ctxtP->module_id] = ctxt_pP->rnti;
@@ -2035,11 +2027,11 @@ pdcp_config_req_asn1 (
 
         //pdcp_eNB_UE_instance_to_rnti_index = (pdcp_eNB_UE_instance_to_rnti_index + 1) % MAX_MOBILES_PER_ENB;
       } else {
-        pdcp_pP->is_ue = TRUE;
+        pdcp_pP->is_ue = true;
         pdcp_UE_UE_module_id_to_rnti[ctxt_pP->module_id] = ctxt_pP->rnti;
       }
 
-      pdcp_pP->is_srb                     = (srb_flagP == SRB_FLAG_YES) ? TRUE : FALSE;
+      pdcp_pP->is_srb                     = srb_flagP == SRB_FLAG_YES;
       pdcp_pP->lcid                       = lc_idP;
       pdcp_pP->rb_id                      = rb_idP;
       pdcp_pP->header_compression_profile = header_compression_profileP;
@@ -2162,10 +2154,10 @@ pdcp_config_req_asn1 (
             rb_idP);
 
       if (ctxt_pP->enb_flag == ENB_FLAG_YES) {
-        pdcp_mbms_array_eNB[ctxt_pP->module_id][mch_idP][lc_idP].instanciated_instance = TRUE ;
+        pdcp_mbms_array_eNB[ctxt_pP->module_id][mch_idP][lc_idP].instanciated_instance = true ;
         pdcp_mbms_array_eNB[ctxt_pP->module_id][mch_idP][lc_idP].rb_id = rb_idP;
       } else {
-        pdcp_mbms_array_ue[ctxt_pP->module_id][mch_idP][lc_idP].instanciated_instance = TRUE ;
+        pdcp_mbms_array_ue[ctxt_pP->module_id][mch_idP][lc_idP].instanciated_instance = true ;
         pdcp_mbms_array_ue[ctxt_pP->module_id][mch_idP][lc_idP].rb_id = rb_idP;
       }
 
@@ -2245,10 +2237,10 @@ void rrc_pdcp_config_req (
         pdcp_p->rb_id  = rb_idP;
 
         if (ctxt_pP->enb_flag == ENB_FLAG_NO) {
-          pdcp_p->is_ue = TRUE;
+          pdcp_p->is_ue = true;
           pdcp_UE_UE_module_id_to_rnti[ctxt_pP->module_id] = ctxt_pP->rnti;
         } else {
-          pdcp_p->is_ue = FALSE;
+          pdcp_p->is_ue = false;
         }
 
         pdcp_p->next_pdcp_tx_sn = 0;
@@ -2321,10 +2313,10 @@ void rrc_pdcp_config_req (
           pdcp_p->rb_id  = rb_idP;
 
           if (ctxt_pP->enb_flag == ENB_FLAG_NO) {
-            pdcp_p->is_ue = TRUE;
+            pdcp_p->is_ue = true;
             pdcp_UE_UE_module_id_to_rnti[ctxt_pP->module_id] = ctxt_pP->rnti;
           } else {
-            pdcp_p->is_ue = FALSE;
+            pdcp_p->is_ue = false;
           }
 
           pdcp_p->next_pdcp_tx_sn = 0;

openair2/LAYER2/PDCP_v10.1.0/pdcp.h

@@ -51,7 +51,7 @@ typedef rlc_op_status_t  (*send_rlc_data_req_func_t)(const protocol_ctxt_t *cons
 						     const rb_id_t, const mui_t,
     confirm_t, sdu_size_t, mem_block_t *,const uint32_t *const, const uint32_t *const);
 
-typedef boolean_t (pdcp_data_ind_t)( const protocol_ctxt_t *, const srb_flag_t,
+typedef bool (pdcp_data_ind_t)( const protocol_ctxt_t *, const srb_flag_t,
 						 const MBMS_flag_t, const rb_id_t, const sdu_size_t,
 						 mem_block_t *,const uint32_t *const, const uint32_t *const);
 typedef pdcp_data_ind_t* pdcp_data_ind_func_t;
@@ -153,14 +153,13 @@ typedef struct pdcp_stats_s {
 
 
 typedef struct pdcp_s {
-  //boolean_t     instanciated_instance;
   uint16_t       header_compression_profile;
 
   /* SR: added this flag to distinguish UE/eNB instance as pdcp_run for virtual
    * mode can receive data on NETLINK for eNB while eNB_flag = 0 and for UE when eNB_flag = 1
    */
-  boolean_t is_ue;
-  boolean_t is_srb;
+  bool is_ue;
+  bool is_srb;
 
   /* Configured security algorithms */
   uint8_t cipheringAlgorithm;
@@ -217,7 +216,7 @@ typedef struct pdcp_s {
 } pdcp_t;
 
 typedef struct pdcp_mbms_s {
-  boolean_t instanciated_instance;
+  bool instanciated_instance;
   rb_id_t   rb_id;
 } pdcp_mbms_t;
 
@@ -230,7 +229,7 @@ typedef struct pdcp_mbms_s {
  * under targets/TEST/PDCP/
  */
 
-/*! \fn boolean_t pdcp_data_req(const protocol_ctxt_t* const  , srb_flag_t , rb_id_t , mui_t , confirm_t ,sdu_size_t , unsigned char* , pdcp_transmission_mode_t )
+/*! \fn bool pdcp_data_req(const protocol_ctxt_t* const  , srb_flag_t , rb_id_t , mui_t , confirm_t ,sdu_size_t , unsigned char* , pdcp_transmission_mode_t )
 * \brief This functions handles data transfer requests coming either from RRC or from IP
 * \param[in] ctxt_pP        Running context.
 * \param[in] rab_id         Radio Bearer ID
@@ -239,38 +238,34 @@ typedef struct pdcp_mbms_s {
 * \param[in] sdu_buffer_size Size of incoming SDU in bytes
 * \param[in] sdu_buffer      Buffer carrying SDU
 * \param[in] mode            flag to indicate whether the userplane data belong to the control plane or data plane or transparent
-* \return TRUE on success, FALSE otherwise
+* \return true on success, false otherwise
 * \note None
 * @ingroup _pdcp
 */
 
-boolean_t pdcp_data_req(
-  protocol_ctxt_t  *ctxt_pP,
-  const srb_flag_t srb_flagP,
-  const rb_id_t rb_id,
-  const mui_t muiP,
-  const confirm_t confirmP,
-  const sdu_size_t sdu_buffer_size,
-  unsigned char *const sdu_buffer,
-  const pdcp_transmission_mode_t mode,
-  const uint32_t * sourceL2Id,
-  const uint32_t * destinationL2Id
-);
+bool pdcp_data_req(protocol_ctxt_t  *ctxt_pP,
+                   const srb_flag_t srb_flagP,
+                   const rb_id_t rb_id,
+                   const mui_t muiP,
+                   const confirm_t confirmP,
+                   const sdu_size_t sdu_buffer_size,
+                   unsigned char *const sdu_buffer,
+                   const pdcp_transmission_mode_t mode,
+                   const uint32_t * sourceL2Id,
+                   const uint32_t * destinationL2Id);
 
-boolean_t cu_f1u_data_req(
-  protocol_ctxt_t  *ctxt_pP,
-  const srb_flag_t srb_flagP,
-  const rb_id_t rb_id,
-  const mui_t muiP,
-  const confirm_t confirmP,
-  const sdu_size_t sdu_buffer_size,
-  unsigned char *const sdu_buffer,
-  const pdcp_transmission_mode_t mode,
-  const uint32_t *const sourceL2Id,
-  const uint32_t *const destinationL2Id
-  );
+bool cu_f1u_data_req(protocol_ctxt_t  *ctxt_pP,
+                     const srb_flag_t srb_flagP,
+                     const rb_id_t rb_id,
+                     const mui_t muiP,
+                     const confirm_t confirmP,
+                     const sdu_size_t sdu_buffer_size,
+                     unsigned char *const sdu_buffer,
+                     const pdcp_transmission_mode_t mode,
+                     const uint32_t *const sourceL2Id,
+                     const uint32_t *const destinationL2Id);
 
-/*! \fn boolean_t pdcp_data_ind(const protocol_ctxt_t* const, srb_flag_t, MBMS_flag_t, rb_id_t, sdu_size_t, mem_block_t*, boolean_t)
+/*! \fn bool pdcp_data_ind(const protocol_ctxt_t* const, srb_flag_t, MBMS_flag_t, rb_id_t, sdu_size_t, mem_block_t*, bool)
 * \brief This functions handles data transfer indications coming from RLC
 * \param[in] ctxt_pP        Running context.
 * \param[in] Shows if rb is SRB
@@ -279,7 +274,7 @@ boolean_t cu_f1u_data_req(
 * \param[in] sdu_buffer_size Size of incoming SDU in bytes
 * \param[in] sdu_buffer Buffer carrying SDU
 * \param[in] is_data_plane flag to indicate whether the userplane data belong to the control plane or data plane
-* \return TRUE on success, FALSE otherwise
+* \return TRUE on success, false otherwise
 * \note None
 * @ingroup _pdcp
 */
@@ -316,20 +311,18 @@ void rrc_pdcp_config_req (
 * \param[in]  defaultDRB        Default DRB ID
 * \return     A status about the processing, OK or error code.
 */
-boolean_t rrc_pdcp_config_asn1_req (
-  const protocol_ctxt_t *const  ctxt_pP,
-  LTE_SRB_ToAddModList_t  *const srb2add_list,
-  LTE_DRB_ToAddModList_t  *const drb2add_list,
-  LTE_DRB_ToReleaseList_t *const drb2release_list,
-  const uint8_t                   security_modeP,
-  uint8_t                  *const kRRCenc,
-  uint8_t                  *const kRRCint,
-  uint8_t                  *const kUPenc,
-  LTE_PMCH_InfoList_r9_t  *pmch_InfoList_r9,
-  rb_id_t                 *const defaultDRB
-);
+bool rrc_pdcp_config_asn1_req(const protocol_ctxt_t *const  ctxt_pP,
+                              LTE_SRB_ToAddModList_t  *const srb2add_list,
+                              LTE_DRB_ToAddModList_t  *const drb2add_list,
+                              LTE_DRB_ToReleaseList_t *const drb2release_list,
+                              const uint8_t                   security_modeP,
+                              uint8_t                  *const kRRCenc,
+                              uint8_t                  *const kRRCint,
+                              uint8_t                  *const kUPenc,
+                              LTE_PMCH_InfoList_r9_t  *pmch_InfoList_r9,
+                              rb_id_t                 *const defaultDRB);
 
-/*! \fn boolean_t pdcp_config_req_asn1 (const protocol_ctxt_t* const ctxt_pP, srb_flag_t srb_flagP, uint32_t  action, rb_id_t rb_id, uint8_t rb_sn, uint8_t rb_report, uint16_t header_compression_profile, uint8_t security_mode)
+/*! \fn bool pdcp_config_req_asn1 (const protocol_ctxt_t* const ctxt_pP, srb_flag_t srb_flagP, uint32_t  action, rb_id_t rb_id, uint8_t rb_sn, uint8_t rb_report, uint16_t header_compression_profile, uint8_t security_mode)
 * \brief  Function for RRC to configure a Radio Bearer.
 * \param[in]  ctxt_pP           Running context.
 * \param[in]  pdcp_pP            Pointer on PDCP structure.
@@ -349,22 +342,21 @@ boolean_t rrc_pdcp_config_asn1_req (
 * \param[in]  kUPenc             User-Plane encryption key
 * \return     A status about the processing, OK or error code.
 */
-boolean_t pdcp_config_req_asn1 (
-  const protocol_ctxt_t *const  ctxt_pP,
-  pdcp_t         *const pdcp_pP,
-  const srb_flag_t       srb_flagP,
-  const rlc_mode_t       rlc_mode,
-  const uint32_t         action,
-  const uint16_t         lc_id,
-  const uint16_t         mch_id,
-  const rb_id_t          rb_id,
-  const uint8_t          rb_sn,
-  const uint8_t          rb_report,
-  const uint16_t         header_compression_profile,
-  const uint8_t          security_mode,
-  uint8_t         *const kRRCenc,
-  uint8_t         *const kRRCint,
-  uint8_t         *const kUPenc);
+bool pdcp_config_req_asn1(const protocol_ctxt_t *const  ctxt_pP,
+                          pdcp_t         *const pdcp_pP,
+                          const srb_flag_t       srb_flagP,
+                          const rlc_mode_t       rlc_mode,
+                          const uint32_t         action,
+                          const uint16_t         lc_id,
+                          const uint16_t         mch_id,
+                          const rb_id_t          rb_id,
+                          const uint8_t          rb_sn,
+                          const uint8_t          rb_report,
+                          const uint16_t         header_compression_profile,
+                          const uint8_t          security_mode,
+                          uint8_t         *const kRRCenc,
+                          uint8_t         *const kRRCint,
+                          uint8_t         *const kUPenc);
 
 /*! \fn void pdcp_add_UE(const protocol_ctxt_t* const  ctxt_pP)
 * \brief  Function (for RRC) to add a new UE in PDCP module
@@ -373,13 +365,12 @@ boolean_t pdcp_config_req_asn1 (
 */
 void pdcp_add_UE(const protocol_ctxt_t *const  ctxt_pP);
 
-/*! \fn boolean_t pdcp_remove_UE(const protocol_ctxt_t* const  ctxt_pP)
+/*! \fn bool pdcp_remove_UE(const protocol_ctxt_t* const  ctxt_pP)
 * \brief  Function for RRC to remove UE from PDCP module hashtable
 * \param[in]  ctxt_pP           Running context.
 * \return     A status about the processing, OK or error code.
 */
-boolean_t pdcp_remove_UE(
-  const protocol_ctxt_t *const  ctxt_pP);
+bool pdcp_remove_UE(const protocol_ctxt_t *const  ctxt_pP);
 
 /*! \fn void rrc_pdcp_config_release( const protocol_ctxt_t* const, rb_id_t)
 * \brief This functions is unused

openair2/LAYER2/PDCP_v10.1.0/pdcp_primitives.c

@@ -32,7 +32,7 @@
 #include "pdcp.h"
 #include "pdcp_primitives.h"
 
-extern boolean_t util_mark_nth_bit_of_octet(uint8_t* octet, uint8_t index);
+extern bool util_mark_nth_bit_of_octet(uint8_t* octet, uint8_t index);
 
 /*
  * Parses data/control field out of buffer of User Plane PDCP Data PDU with
@@ -123,13 +123,13 @@ uint8_t pdcp_get_sequence_number_of_pdu_with_SRB_sn(unsigned char* pdu_buffer)
  * Fills the incoming buffer with the fields of the header for srb sn
  *
  * @param pdu_buffer PDCP PDU buffer
- * @return TRUE on success, FALSE otherwise
+ * @return true on success, false otherwise
  */
-boolean_t pdcp_serialize_control_plane_data_pdu_with_SRB_sn_buffer(unsigned char* pdu_buffer, \
-    pdcp_control_plane_data_pdu_header* pdu)
+bool pdcp_serialize_control_plane_data_pdu_with_SRB_sn_buffer(unsigned char* pdu_buffer,
+                                                              pdcp_control_plane_data_pdu_header* pdu)
 {
   if (pdu_buffer == NULL || pdu == NULL) {
-    return FALSE;
+    return false;
   }
 
   /*
@@ -138,20 +138,20 @@ boolean_t pdcp_serialize_control_plane_data_pdu_with_SRB_sn_buffer(unsigned char
   uint8_t sequence_number = pdu->sn;
   pdu_buffer[0] = sequence_number & 0x1F; // 5bit sn
 
-  return TRUE;
+  return true;
 }
 
 /*
  * Fills the incoming buffer with the fields of the header for long sn
  *
  * @param pdu_buffer PDCP PDU buffer
- * @return TRUE on success, FALSE otherwise
+ * @return true on success, false otherwise
  */
-boolean_t pdcp_serialize_user_plane_data_pdu_with_long_sn_buffer(unsigned char* pdu_buffer, \
-    pdcp_user_plane_data_pdu_header_with_long_sn* pdu)
+bool pdcp_serialize_user_plane_data_pdu_with_long_sn_buffer(unsigned char* pdu_buffer,
+                                                            pdcp_user_plane_data_pdu_header_with_long_sn* pdu)
 {
   if (pdu_buffer == NULL || pdu == NULL) {
-    return FALSE;
+    return false;
   }
 
   /*
@@ -170,7 +170,7 @@ boolean_t pdcp_serialize_user_plane_data_pdu_with_long_sn_buffer(unsigned char*
     pdu_buffer[0] |= 0x80; // set the first bit as 1
   }
 
-  return TRUE;
+  return true;
 }
 
 /*
@@ -178,13 +178,14 @@ boolean_t pdcp_serialize_user_plane_data_pdu_with_long_sn_buffer(unsigned char*
  *
  * @param pdu_buffer The buffer that PDU will be serialized into
  * @param pdu A status report header
- * @return TRUE on success, FALSE otherwise
+ * @return true on success, false otherwise
  */
-boolean_t pdcp_serialize_control_pdu_for_pdcp_status_report(unsigned char* pdu_buffer, \
-    uint8_t bitmap[512], pdcp_control_pdu_for_pdcp_status_report* pdu)
+bool pdcp_serialize_control_pdu_for_pdcp_status_report(unsigned char* pdu_buffer,
+                                                       uint8_t bitmap[512],
+                                                       pdcp_control_pdu_for_pdcp_status_report* pdu)
 {
   if (pdu_buffer == NULL || pdu == NULL) {
-    return FALSE;
+    return false;
   }
 
   /*
@@ -205,6 +206,6 @@ boolean_t pdcp_serialize_control_pdu_for_pdcp_status_report(unsigned char* pdu_b
    */
   memcpy(pdu_buffer + 2, bitmap, 512);
 
-  return TRUE;
+  return true;
 }
 

openair2/LAYER2/PDCP_v10.1.0/pdcp_primitives.h

@@ -142,18 +142,18 @@ uint8_t pdcp_get_sequence_number_of_pdu_with_SRB_sn(unsigned char* pdu_buffer);
  * Fills the incoming buffer with the fields of the header for SRB1
  *
  * @param pdu_buffer PDCP PDU buffer
- * @return TRUE on success, FALSE otherwise
+ * @return true on success, false otherwise
  */
-boolean_t pdcp_serialize_control_plane_data_pdu_with_SRB_sn_buffer(unsigned char* pdu_buffer, \
-    pdcp_control_plane_data_pdu_header* pdu);
+bool pdcp_serialize_control_plane_data_pdu_with_SRB_sn_buffer(unsigned char* pdu_buffer,
+                                                              pdcp_control_plane_data_pdu_header* pdu);
 /*
  * Fills the incoming buffer with the fields of the header for long SN (RLC UM and AM)
  *
  * @param pdu_buffer PDCP PDU buffer
- * @return TRUE on success, FALSE otherwise
+ * @return true on success, false otherwise
  */
-boolean_t pdcp_serialize_user_plane_data_pdu_with_long_sn_buffer(unsigned char* pdu_buffer, \
-    pdcp_user_plane_data_pdu_header_with_long_sn* pdu);
+bool pdcp_serialize_user_plane_data_pdu_with_long_sn_buffer(unsigned char* pdu_buffer,
+                                                            pdcp_user_plane_data_pdu_header_with_long_sn* pdu);
 
 /*
  * Fills the incoming status report header with given value of bitmap
@@ -162,10 +162,11 @@ boolean_t pdcp_serialize_user_plane_data_pdu_with_long_sn_buffer(unsigned char*
  * @param FMS First Missing PDCP SN
  * @param bitmap Received/Missing sequence number bitmap
  * @param pdu A status report header
- * @return TRUE on success, FALSE otherwise
+ * @return true on success, false otherwise
  */
-boolean_t pdcp_serialize_control_pdu_for_pdcp_status_report(unsigned char* pdu_buffer, \
-    uint8_t bitmap[512], pdcp_control_pdu_for_pdcp_status_report* pdu);
+bool pdcp_serialize_control_pdu_for_pdcp_status_report(unsigned char* pdu_buffer,
+                                                       uint8_t bitmap[512],
+                                                       pdcp_control_pdu_for_pdcp_status_report* pdu);
 
 int pdcp_netlink_dequeue_element(const protocol_ctxt_t* const  ctxt_pP,
                                  struct pdcp_netlink_element_s **data_ppP);

openair2/LAYER2/PDCP_v10.1.0/pdcp_sequence_manager.c

@@ -33,12 +33,12 @@
 /*
  * Initializes sequence numbering state
  * @param pdcp_entity The PDCP entity to be initialized
- * @return boolean_t TRUE on success, FALSE otherwise
+ * @return bool true on success, false otherwise
  */
-boolean_t pdcp_init_seq_numbers(pdcp_t* pdcp_entity)
+bool pdcp_init_seq_numbers(pdcp_t* pdcp_entity)
 {
   if (pdcp_entity == NULL) {
-    return FALSE;
+    return false;
   }
 
   /* Sequence number state variables */
@@ -55,34 +55,34 @@ boolean_t pdcp_init_seq_numbers(pdcp_t* pdcp_entity)
   // Shall UE and eNB behave differently on initialization? (see 7.1.e)
   pdcp_entity->last_submitted_pdcp_rx_sn = 4095;
 
-  return TRUE;
+  return true;
 }
 
-boolean_t pdcp_is_seq_num_size_valid(pdcp_t* pdcp_entity)
+bool pdcp_is_seq_num_size_valid(pdcp_t* pdcp_entity)
 {
   if (pdcp_entity == NULL) {
-    return FALSE;
+    return false;
   }
 
   // Check if the size of SN is valid (see 3GPP TS 36.323 v10.1.0 item 6.3.2)
   if (pdcp_entity->seq_num_size != 5 && pdcp_entity->seq_num_size != 7 && pdcp_entity->seq_num_size != 12) {
     LOG_W(PDCP, "Incoming SN size is invalid! (Expected: {5 | 7 | 12}, Received: %d\n", pdcp_entity->seq_num_size);
-    return FALSE;
+    return false;
   }
 
-  return TRUE;
+  return true;
 }
 
 /**
  * Check if SN number is in the range according to SN size
  */
-boolean_t pdcp_is_seq_num_valid(uint16_t seq_num, uint8_t seq_num_size)
+bool pdcp_is_seq_num_valid(uint16_t seq_num, uint8_t seq_num_size)
 {
   if (seq_num >= 0 && seq_num <= pdcp_calculate_max_seq_num_for_given_size(seq_num_size)) {
-    return TRUE;
+    return true;
   }
 
-  return FALSE;
+  return false;
 }
 
 uint16_t pdcp_calculate_max_seq_num_for_given_size(uint8_t seq_num_size)
@@ -96,7 +96,7 @@ uint16_t pdcp_calculate_max_seq_num_for_given_size(uint8_t seq_num_size)
 
 uint16_t pdcp_get_next_tx_seq_number(pdcp_t* pdcp_entity)
 {
-  if (pdcp_is_seq_num_size_valid(pdcp_entity) == FALSE) {
+  if (pdcp_is_seq_num_size_valid(pdcp_entity) == false) {
     return -1;
   }
 
@@ -118,10 +118,10 @@ uint16_t pdcp_get_next_tx_seq_number(pdcp_t* pdcp_entity)
   return pdcp_seq_num;
 }
 
-boolean_t pdcp_advance_rx_window(pdcp_t* pdcp_entity)
+bool pdcp_advance_rx_window(pdcp_t* pdcp_entity)
 {
-  if (pdcp_is_seq_num_size_valid(pdcp_entity) == FALSE) {
-    return FALSE;
+  if (pdcp_is_seq_num_size_valid(pdcp_entity) == false) {
+    return false;
   }
 
   /*
@@ -137,10 +137,10 @@ boolean_t pdcp_advance_rx_window(pdcp_t* pdcp_entity)
     pdcp_entity->next_pdcp_rx_sn++;
   }
 
-  return TRUE;
+  return true;
 }
 
-boolean_t pdcp_mark_current_pdu_as_received(uint16_t seq_num, pdcp_t* pdcp_entity)
+bool pdcp_mark_current_pdu_as_received(uint16_t seq_num, pdcp_t* pdcp_entity)
 {
   /*
    * Incoming sequence number and PDCP entity were already
@@ -158,5 +158,5 @@ boolean_t pdcp_mark_current_pdu_as_received(uint16_t seq_num, pdcp_t* pdcp_entit
   LOG_D(PDCP, "Marking %d. bit of %d. octet of status bitmap\n", (seq_num % 8) + 1, octet_index);
   util_mark_nth_bit_of_octet(&pdcp_entity->missing_pdu_bitmap[octet_index], seq_num % 8);
   util_print_binary_representation((uint8_t*)"Current state of relevant octet: ", pdcp_entity->missing_pdu_bitmap[octet_index]);
-  return TRUE;
+  return true;
 }

openair2/LAYER2/PDCP_v10.1.0/pdcp_sequence_manager.h

@@ -35,17 +35,17 @@
  * @param pdcp_entity The PDCP entity to be initialized
  * @return none
  */
-boolean_t pdcp_init_seq_numbers(pdcp_t* pdcp_entity);
+bool pdcp_init_seq_numbers(pdcp_t* pdcp_entity);
 /**
  * Checks if incoming PDCP entitiy pointer and relevant sequence number size is valid
- * @return TRUE (0x01) if it is valid, FALSE (0x00) otherwise
+ * @return true (0x01) if it is valid, false (0x00) otherwise
  */
-boolean_t pdcp_is_seq_num_size_valid(pdcp_t* pdcp_entity);
+bool pdcp_is_seq_num_size_valid(pdcp_t* pdcp_entity);
 /**
  * Check if SN number is in the range according to SN size
- * @return TRUE if it is valid, FALSE otherwise
+ * @return true if it is valid, false otherwise
  */
-boolean_t pdcp_is_seq_num_valid(uint16_t seq_num, uint8_t seq_num_size);
+bool pdcp_is_seq_num_valid(uint16_t seq_num, uint8_t seq_num_size);
 /**
  * Returns the maximum allowed sequence number value for given size of SN field
  * @return Max sequence number value
@@ -58,11 +58,11 @@ uint16_t pdcp_get_next_tx_seq_number(pdcp_t* pdcp_entity);
 /**
  * Advances the RX window state of given PDCP entity upon successfull receipt of a SDU
  */
-boolean_t pdcp_advance_rx_window(pdcp_t* pdcp_entity);
+bool pdcp_advance_rx_window(pdcp_t* pdcp_entity);
 /**
 * Updates missing PDU bitmap with incoming sequence number
-* @return TRUE if successful, FALSE otherwise
+* @return true if successful, false otherwise
 */
-boolean_t pdcp_mark_current_pdu_as_received(uint16_t seq_num, pdcp_t* pdcp_entity);
+bool pdcp_mark_current_pdu_as_received(uint16_t seq_num, pdcp_t* pdcp_entity);
 
 #endif

openair2/LAYER2/PDCP_v10.1.0/pdcp_util.c

@@ -130,9 +130,9 @@ void util_print_binary_representation(unsigned char* message, uint8_t octet)
  *
  * @param octet 8-bit data
  * @param index Index of bit to be set
- * @return TRUE on success, FALSE otherwise
+ * @return true on success, false otherwise
  */
-boolean_t util_mark_nth_bit_of_octet(uint8_t* octet, uint8_t index)
+bool util_mark_nth_bit_of_octet(uint8_t* octet, uint8_t index)
 {
   uint8_t mask = 0x80;
 
@@ -148,6 +148,6 @@ boolean_t util_mark_nth_bit_of_octet(uint8_t* octet, uint8_t index)
    */
   *octet |= mask;
 
-  return TRUE;
+  return true;
 }
 

openair2/LAYER2/PDCP_v10.1.0/pdcp_util.h

@@ -66,8 +66,8 @@ void util_print_binary_representation(unsigned char* message, uint8_t octet);
  *
  * @param octet Octet
  * @param index Index
- * @return TRUE on success, FALSE otherwise
+ * @return true on success, false otherwise
  */
-boolean_t util_mark_nth_bit_of_octet(uint8_t* octet, uint8_t index);
+bool util_mark_nth_bit_of_octet(uint8_t* octet, uint8_t index);
 
 #endif // PDCP_UTIL_H

openair2/LAYER2/RLC/AM_v9.3.0/rlc_am.c

@@ -52,7 +52,7 @@ rlc_am_get_status_pdu_buffer_occupancy(
   rlc_sn_t sn_cursor = rlc_pP->vr_r;
   rlc_sn_t sn_prev = rlc_pP->vr_r;
   rlc_sn_t sn_end = rlc_pP->vr_ms;
-  boolean_t segment_loop_end    = false;
+  bool segment_loop_end    = false;
 
   if (sn_prev != sn_end) {
     while ((RLC_AM_DIFF_SN(sn_prev,rlc_pP->vr_r) < RLC_AM_DIFF_SN(sn_end,rlc_pP->vr_r)) && (cursor_p != NULL)) {

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

@@ -54,7 +54,7 @@ typedef struct rlc_am_entity_s {
 
   rb_id_t           rb_id;                              /*!< \brief Radio bearer identifier, for statistics and trace purpose. */
   logical_chan_id_t channel_id;                         /*!< \brief Transport channel identifier. */
-  boolean_t         is_data_plane;                      /*!< \brief To know if the RLC belongs to a data radio bearer or a signalling radio bearer, for statistics and trace purpose. */
+  bool              is_data_plane;                      /*!< \brief To know if the RLC belongs to a data radio bearer or a signalling radio bearer, for statistics and trace purpose. */
 
   rlc_buffer_occupancy_t sdu_buffer_occupancy;               /*!< \brief Number of bytes of unsegmented SDUs. */
   rlc_buffer_occupancy_t status_buffer_occupancy;            /*!< \brief Number of bytes of control PDUs waiting for transmission. */
@@ -76,7 +76,7 @@ typedef struct rlc_am_entity_s {
   rlc_am_tx_data_pdu_management_t *tx_data_pdu_buffer;       /*!< \brief Transmission PDU data buffer. Used also for retransmissions */
   signed int      retrans_num_pdus;                          /*!< \brief Number of PDUs in the retransmission buffer. */
   signed int      retrans_num_bytes_to_retransmit;           /*!< \brief Number of bytes in the retransmission buffer to be retransmitted. Only payload is taken into account */
-  boolean_t       force_poll;                                /*!< \brief force poll due to t_poll_retransmit time-out. */
+  bool            force_poll;                                /*!< \brief force poll due to t_poll_retransmit time-out. */
 
   //---------------------------------------------------------------------
   // RX BUFFERS
@@ -186,8 +186,8 @@ typedef struct rlc_am_entity_s {
   // note occupancy of other buffers is deducted from nb elements in lists
   rlc_buffer_occupancy_t  buffer_occupancy_retransmission_buffer;   /*!< \brief Number of PDUs. */
 
-  boolean_t               initialized;                               /*!< \brief Boolean for rlc_am_entity_t struct initialization. */
-  boolean_t               configured;                               /*!< \brief Boolean for rlc_am_entity_t struct  configuration. */
+  bool                    initialized;                               /*!< \brief Boolean for rlc_am_entity_t struct initialization. */
+  bool                    configured;                               /*!< \brief Boolean for rlc_am_entity_t struct  configuration. */
 } rlc_am_entity_t;
 /** @} */
 #    endif

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

@@ -32,7 +32,7 @@ rlc_am_init(
   const protocol_ctxt_t* const  ctxt_pP,
   rlc_am_entity_t *const        rlc_pP)
 {
-  if (rlc_pP->initialized == TRUE) {
+  if (rlc_pP->initialized == true) {
     LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[AM INIT] INITIALIZATION ALREADY DONE, DOING NOTHING\n",
           PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP));
   } else {
@@ -79,7 +79,7 @@ rlc_am_init(
 
     rlc_pP->last_absolute_subframe_status_indication = 0xFFFFFFFF; // any value > 1
 
-    rlc_pP->initialized                  = TRUE;
+    rlc_pP->initialized                  = true;
   }
 }
 //-----------------------------------------------------------------------------
@@ -134,7 +134,7 @@ rlc_am_reestablish(
 
   rlc_pP->last_absolute_subframe_status_indication = 0xFFFFFFFF; // any value > 1
 
-  rlc_pP->initialized                  = TRUE;
+  rlc_pP->initialized                  = true;
 
 }
 
@@ -197,7 +197,7 @@ rlc_am_configure(
   const uint32_t                t_reorderingP,
   const uint32_t                t_status_prohibitP)
 {
-  if (rlc_pP->configured == TRUE) {
+  if (rlc_pP->configured == true) {
     LOG_I(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[RECONFIGURE] max_retx_threshold %d poll_pdu %d poll_byte %d t_poll_retransmit %d t_reordering %d t_status_prohibit %d\n",
           PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),
           max_retx_thresholdP,
@@ -235,7 +235,7 @@ rlc_am_configure(
     rlc_am_init_timer_reordering     (ctxt_pP, rlc_pP, t_reorderingP);
     rlc_am_init_timer_status_prohibit(ctxt_pP, rlc_pP, t_status_prohibitP);
 
-    rlc_pP->configured = TRUE;
+    rlc_pP->configured = true;
   }
 
 }

openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_reassembly.c

@@ -183,12 +183,10 @@ rlc_am_send_sdu (
   }
 }
 //-----------------------------------------------------------------------------
-void
-rlc_am_reassemble_pdu(
-  const protocol_ctxt_t *const ctxt_pP,
-  rlc_am_entity_t *const      rlc_pP,
-  mem_block_t *const          tb_pP,
-  boolean_t free_rlc_pdu) {
+void rlc_am_reassemble_pdu(const protocol_ctxt_t *const ctxt_pP,
+                           rlc_am_entity_t *const      rlc_pP,
+                           mem_block_t *const          tb_pP,
+                           bool free_rlc_pdu) {
   int i,j;
   rlc_am_pdu_info_t *pdu_info        = &((rlc_am_rx_pdu_management_t *)(tb_pP->data))->pdu_info;
   LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[REASSEMBLY PDU] TRY REASSEMBLY PDU SN=%03d\n",

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

@@ -57,14 +57,14 @@ void rlc_am_reassembly   (const protocol_ctxt_t* const ctxtP, rlc_am_entity_t *
 */
 void rlc_am_send_sdu     (const protocol_ctxt_t* const ctxtP, rlc_am_entity_t * const rlc_pP);
 
-/*! \fn void rlc_am_reassemble_pdu(const protocol_ctxt_t* const ctxtP, rlc_am_entity_t * const rlc_pP, const  mem_block_t* const tb_pP,boolean_t free_rlc_pdu)
+/*! \fn void rlc_am_reassemble_pdu(const protocol_ctxt_t* const ctxtP, rlc_am_entity_t * const rlc_pP, const  mem_block_t* const tb_pP, bool free_rlc_pdu)
 * \brief    Reassembly a RLC AM PDU, depending of the content of this PDU, data will be reassemblied to the current output SDU, the current will be sent to higher layers or not, after or before the reassembly, or no send of SDU will be triggered, depending on FI field in PDU header.
 * \param[in]  ctxtP                       Running context.
 * \param[in]  rlc_pP                      RLC AM protocol instance pointer.
 * \param[in]  tb_pP                       RLC AM PDU embedded in a mem_block_t.
 * \param[in]  free_rlc_pdu                Flag for freeing RLC AM PDU after reassembly.
 */
-void rlc_am_reassemble_pdu(const protocol_ctxt_t* const ctxtP, rlc_am_entity_t * const rlc_pP, mem_block_t* const tb_pP,boolean_t free_rlc_pdu);
+void rlc_am_reassemble_pdu(const protocol_ctxt_t* const ctxtP, rlc_am_entity_t * const rlc_pP, mem_block_t* const tb_pP, bool free_rlc_pdu);
 /** @} */
 #endif
 

openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_receiver.c

@@ -328,7 +328,7 @@ rlc_am_receive_process_data_pdu (
   rlc_am_pdu_info_t*  pdu_info_p         = &((rlc_am_rx_pdu_management_t*)(tb_pP->data))->pdu_info;
   rlc_am_pdu_sn_10_t* rlc_am_pdu_sn_10_p = (rlc_am_pdu_sn_10_t*)first_byte_pP;
   rlc_am_rx_pdu_status_t pdu_status		= RLC_AM_DATA_PDU_STATUS_OK;
-  boolean_t		reassemble = false;
+  bool reassemble = false;
 
   if (rlc_am_get_data_pdu_infos(ctxt_pP,rlc_pP, rlc_am_pdu_sn_10_p, tb_size_in_bytesP, pdu_info_p) >= 0) {
 

openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_retransmit.c

@@ -29,13 +29,12 @@
 #include "LAYER2/MAC/mac_extern.h"
 #include "common/utils/LOG/log.h"
 //-----------------------------------------------------------------------------
-boolean_t rlc_am_nack_pdu (
-  const protocol_ctxt_t* const  ctxt_pP,
-  rlc_am_entity_t *const rlc_pP,
-  const rlc_sn_t snP,
-  const rlc_sn_t prev_nack_snP,
-  sdu_size_t so_startP,
-  sdu_size_t so_endP)
+bool rlc_am_nack_pdu(const protocol_ctxt_t* const  ctxt_pP,
+                     rlc_am_entity_t *const rlc_pP,
+                     const rlc_sn_t snP,
+                     const rlc_sn_t prev_nack_snP,
+                     sdu_size_t so_startP,
+                     sdu_size_t so_endP)
 {
   // 5.2.1 Retransmission
   // ...
@@ -54,8 +53,8 @@ boolean_t rlc_am_nack_pdu (
   rlc_am_tx_data_pdu_management_t *tx_data_pdu_buffer_p = &rlc_pP->tx_data_pdu_buffer[snP % RLC_AM_WINDOW_SIZE];
   //int          pdu_sdu_index;
   //int          sdu_index;
-  boolean_t status = TRUE;
-  boolean_t retx_count_increment = FALSE;
+  bool status = true;
+  bool retx_count_increment = false;
   sdu_size_t pdu_data_to_retx = 0;
 
   if (mb_p != NULL) {
@@ -63,7 +62,7 @@ boolean_t rlc_am_nack_pdu (
     if(so_startP > so_endP) {
       LOG_E(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[NACK-PDU] ERROR NACK MISSING PDU, so_startP %d, so_endP %d\n",
             PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),so_startP, so_endP);
-      status = FALSE;
+      status = false;
     }
     // Handle full PDU NACK first
     else if ((so_startP == 0) && (so_endP == 0x7FFF)) {
@@ -71,9 +70,7 @@ boolean_t rlc_am_nack_pdu (
     		pdu_data_to_retx = tx_data_pdu_buffer_p->payload_size;
             /* Increment VtReTxNext if this is the first NACK or if some segments have already been transmitted */
             if ((tx_data_pdu_buffer_p->flags.retransmit == 0) || (tx_data_pdu_buffer_p->nack_so_start))
-            {
-            	retx_count_increment = TRUE;
-            }
+              retx_count_increment = true;
 
             tx_data_pdu_buffer_p->nack_so_start = 0;
             tx_data_pdu_buffer_p->num_holes     = 0;
@@ -89,11 +86,11 @@ boolean_t rlc_am_nack_pdu (
     	      if(tx_data_pdu_buffer_p->nack_so_start >= tx_data_pdu_buffer_p->payload_size){
               LOG_E(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[NACK-PDU] ERROR NACK MISSING PDU, nack_so_start %d, payload_size %d\n",
                     PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),tx_data_pdu_buffer_p->nack_so_start, tx_data_pdu_buffer_p->payload_size);
-    	        status = FALSE;
+              status = false;
     	      }
     	}
     	else {
-    		status = FALSE;
+        status = false;
     	}
     }
     else if (tx_data_pdu_buffer_p->flags.max_retransmit == 0) {
@@ -107,9 +104,8 @@ boolean_t rlc_am_nack_pdu (
 	    	if (prev_nack_snP != snP) {
 	    		/* New NACK_SN with SO */
                 /* check whether a new segment is to be placed in Retransmission Buffer, then increment vrReTx */
-                if ((tx_data_pdu_buffer_p->flags.retransmit == 0) || (so_startP < tx_data_pdu_buffer_p->nack_so_start)) {
-                	retx_count_increment = TRUE;
-                }
+                if ((tx_data_pdu_buffer_p->flags.retransmit == 0) || (so_startP < tx_data_pdu_buffer_p->nack_so_start))
+                  retx_count_increment = true;
 
 	            tx_data_pdu_buffer_p->num_holes     = 1;
 	            tx_data_pdu_buffer_p->retx_hole_index = 0;
@@ -129,21 +125,18 @@ boolean_t rlc_am_nack_pdu (
 		            tx_data_pdu_buffer_p->nack_so_stop = so_endP;
 		            tx_data_pdu_buffer_p->num_holes ++;
 		            pdu_data_to_retx = so_endP - so_startP + 1;
+          } else {
+            status = false;
 	    		}
-	    		else {
-	    			status = FALSE;
-	    		}
-	    	}
-	    	else {
-	    		status = FALSE;
+        } else {
+          status = false;
 	    	}
 		}
 		else {
-			status = FALSE;
+      status = false;
 		}
-    }
-    else {
-    	status = FALSE;
+    } else {
+      status = false;
     }
 
     if (status) {
@@ -175,17 +168,16 @@ boolean_t rlc_am_nack_pdu (
     LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[NACK-PDU] ERROR NACK MISSING PDU SN %05d\n",
           PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),
           snP);
-    status = FALSE;
+    status = false;
   }
 
   return status;
 }
 //-----------------------------------------------------------------------------
-void rlc_am_ack_pdu (
-  const protocol_ctxt_t* const  ctxt_pP,
-  rlc_am_entity_t *const rlc_pP,
-  const rlc_sn_t snP,
-  boolean_t free_pdu)
+void rlc_am_ack_pdu(const protocol_ctxt_t* const  ctxt_pP,
+                    rlc_am_entity_t *const rlc_pP,
+                    const rlc_sn_t snP,
+                    bool free_pdu)
 {
   mem_block_t* mb_p         = rlc_pP->tx_data_pdu_buffer[snP % RLC_AM_WINDOW_SIZE].mem_block;
   rlc_am_tx_data_pdu_management_t *tx_data_pdu_buffer = &rlc_pP->tx_data_pdu_buffer[snP % RLC_AM_WINDOW_SIZE];
@@ -283,7 +275,7 @@ mem_block_t* rlc_am_retransmit_get_am_segment(
 	sdu_size_t     retx_so_start,retx_so_stop; //starting and ending SO for retransmission in this PDU
 	rlc_sn_t sn = pdu_mngt->sn;
 	uint16_t	header_so_part;
-	boolean_t fi_start, fi_end;
+	bool fi_start, fi_end;
 	uint8_t sdu_index = 0;
 	uint8_t sdu_segment_index = 0;
 	uint8_t num_LIs_pdu_segment = pdu_mngt->nb_sdus - 1;
@@ -377,11 +369,11 @@ mem_block_t* rlc_am_retransmit_get_am_segment(
 		/* Set FI part to false if SO Start and SO End are different from PDU boundaries */
 		if (retx_so_start)
 		{
-			fi_start = FALSE;
+			fi_start = false;
 		}
 		if (retx_so_stop < pdu_mngt->payload_size - 1)
 		{
-			fi_end = FALSE;
+			fi_end = false;
 		}
 
 		/* Header content is filled at the end */
@@ -423,7 +415,7 @@ mem_block_t* rlc_am_retransmit_get_am_segment(
 			else
 			{
 				/* if retx_so_start is still not included then set data_size with full original PDU data size */
-				/* Set fi_start to FALSE in this case */
+				/* Set fi_start to false in this case */
 				data_size = pdu_mngt->payload_size;
 			}
 			sdu_index ++;
@@ -432,7 +424,7 @@ mem_block_t* rlc_am_retransmit_get_am_segment(
 		if (retx_so_start == data_size)
 		{
 			/* Set FI Start if retx_so_start = cumulated data size */
-			fi_start = TRUE;
+			fi_start = true;
 			/* there must be at least one SDU more */
 //Assertion(eNB)_PRAN_DesignDocument_annex No.778
             if(sdu_index >= pdu_mngt->nb_sdus)
@@ -464,8 +456,8 @@ mem_block_t* rlc_am_retransmit_get_am_segment(
 		}
 		else if (retx_so_start != 0)
 		{
-			/* in all other cases set fi_start to FALSE if it SO Start is not 0 */
-			fi_start = FALSE;
+			/* in all other cases set fi_start to false if it SO Start is not 0 */
+			fi_start = false;
 		}
 
 		/* Set first SDU portion of the segment */
@@ -582,10 +574,10 @@ mem_block_t* rlc_am_retransmit_get_am_segment(
 				"RLC AM Tx PDU Segment Data Error: retx_so_stop=%d OriginalPDUDataLength=%d SOStart=%d SegmentLength=%d numLISegment=%d numLIPDU=%d sn=%d LcId=%d !\n",
 				retx_so_stop,pdu_mngt->payload_size,retx_so_start,*payload_sizeP,num_LIs_pdu_segment,pdu_mngt->nb_sdus - 1,sn,rlc_pP->channel_id);
 */
-		/* init FI End to FALSE if retx_so_stop is not end of PDU */
+		/* init FI End to false if retx_so_stop is not end of PDU */
 		if (retx_so_stop != pdu_mngt->payload_size - 1)
 		{
-			fi_end = FALSE;
+			fi_end = false;
 		}
 
 		/* Check consistency between sdus_segment_size and payload_sizeP */
@@ -596,7 +588,7 @@ mem_block_t* rlc_am_retransmit_get_am_segment(
 			data_size += sdus_segment_size[i];
 			if ((retx_so_stop == data_size - 1) && (i < num_LIs_pdu_segment))
 			{
-				fi_end = TRUE;
+				fi_end = true;
 			}
 		}
 //Assertion(eNB)_PRAN_DesignDocument_annex No.782
@@ -665,7 +657,7 @@ mem_block_t* rlc_am_retransmit_get_am_segment(
 			pdu_mngt->nack_so_start = pdu_mngt->hole_so_start[pdu_mngt->retx_hole_index];
 		}
 
-		/* Content is supposed to be init with 0 so with FIStart=FIEnd=TRUE */
+		/* Content is supposed to be init with 0 so with FIStart=FIEnd=true */
 		RLC_AM_PDU_SET_D_C(*pdu_segment_header_p);
 		RLC_AM_PDU_SET_RF(*pdu_segment_header_p);
 		/* Change FI */

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

@@ -35,7 +35,7 @@
 #    ifndef __RLC_AM_RETRANSMIT_H__
 #        define __RLC_AM_RETRANSMIT_H__
 //-----------------------------------------------------------------------------
-/*! \fn boolean_t  rlc_am_nack_pdu (const protocol_ctxt_t* const  ctxt_pP, rlc_am_entity_t *rlcP, int16_t snP, int16_t prev_nack_snP,sdu_size_t so_startP, sdu_size_t so_endP)
+/*! \fn bool  rlc_am_nack_pdu (const protocol_ctxt_t* const  ctxt_pP, rlc_am_entity_t *rlcP, int16_t snP, int16_t prev_nack_snP,sdu_size_t so_startP, sdu_size_t so_endP)
 * \brief      The RLC AM PDU which have the sequence number snP is marked NACKed with segment offset fields.
 * \param[in]  ctxtP        Running context.
 * \param[in]  rlcP         RLC AM protocol instance pointer.
@@ -46,13 +46,12 @@
 * \return                  OK/KO
 * \note It may appear a new hole in the retransmission buffer depending on the segment offset informations. Depending on the state of the retransmission buffer, negative confirmation can be sent to higher layers about the drop by the RLC AM instance of a particular SDU.
 */
-boolean_t         rlc_am_nack_pdu (
-                              const protocol_ctxt_t* const  ctxt_pP,
-                              rlc_am_entity_t *const rlcP,
-                              const rlc_sn_t snP,
-							  const rlc_sn_t prev_nack_snP,
-                              sdu_size_t so_startP,
-                              sdu_size_t so_endP);
+bool rlc_am_nack_pdu(const protocol_ctxt_t* const  ctxt_pP,
+                     rlc_am_entity_t *const rlcP,
+                     const rlc_sn_t snP,
+                     const rlc_sn_t prev_nack_snP,
+                     sdu_size_t so_startP,
+                     sdu_size_t so_endP);
 
 /*! \fn void rlc_am_ack_pdu (const protocol_ctxt_t* const  ctxt_pP,rlc_am_entity_t *rlcP, rlc_sn_t snP)
 * \brief      The RLC AM PDU which have the sequence number snP is marked ACKed.
@@ -62,11 +61,10 @@ boolean_t         rlc_am_nack_pdu (
 * \param[in]  free_pdu     Boolean indicating that the PDU can be freed because smaller than new vtA.
 * \note                    Depending on the state of the retransmission buffer, positive confirmation can be sent to higher layers about the receiving by the peer RLC AM instance of a particular SDU.
 */
-void         rlc_am_ack_pdu (
-                              const protocol_ctxt_t* const  ctxt_pP,
-                              rlc_am_entity_t *const rlcP,
-                              const rlc_sn_t snP,
-							  boolean_t free_pdu);
+void rlc_am_ack_pdu(const protocol_ctxt_t* const  ctxt_pP,
+                    rlc_am_entity_t *const rlcP,
+                    const rlc_sn_t snP,
+							      bool free_pdu);
 
 /*! \fn mem_block_t* rlc_am_retransmit_get_copy (const protocol_ctxt_t* const  ctxt_pP, rlc_am_entity_t *rlcP, rlc_sn_t snP)
 * \brief      The RLC AM PDU which have the sequence number snP is marked ACKed.

openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_rx_list.c

@@ -31,14 +31,13 @@
 #include "common/utils/LOG/log.h"
 
 
-boolean_t rlc_am_rx_check_vr_reassemble(
-		  const protocol_ctxt_t* const ctxt_pP,
-		  const rlc_am_entity_t* const rlc_pP)
+bool rlc_am_rx_check_vr_reassemble(const protocol_ctxt_t* const ctxt_pP,
+                                   const rlc_am_entity_t* const rlc_pP)
 {
 	mem_block_t*       cursor_p                    = rlc_pP->receiver_buffer.head;
 	rlc_am_rx_pdu_management_t * pdu_cursor_mgnt_p = NULL;
 	sdu_size_t          next_waited_so = 0;
-	boolean_t reassemble = FALSE;
+	bool reassemble = false;
 
 	if (cursor_p != NULL) {
 
@@ -48,7 +47,7 @@ boolean_t rlc_am_rx_check_vr_reassemble(
 		if (sn_ref != rlc_pP->vr_r) {
 			/* Case vrR has advanced from head : most likely case */
 
-			reassemble = TRUE;
+			reassemble = true;
 			/* Handle first SN if it is made of PDU segments : set them all to be reassembled */
 			if (pdu_info_p->rf) {
 				pdu_cursor_mgnt_p = (rlc_am_rx_pdu_management_t *) (cursor_p->data);
@@ -58,7 +57,7 @@ boolean_t rlc_am_rx_check_vr_reassemble(
                 {
                    LOG_E(RLC, "AM Rx Check Reassembly head SN=%d with PDU segments != vrR=%d should be fully received LCID=%d\n",
                          sn_ref,rlc_pP->vr_r,rlc_pP->channel_id);
-                   return FALSE;
+                   return false;
                 }
 /*
 				AssertFatal(pdu_cursor_mgnt_p->all_segments_received > 0,"AM Rx Check Reassembly head SN=%d with PDU segments != vrR=%d should be fully received LCID=%d\n",
@@ -94,7 +93,7 @@ boolean_t rlc_am_rx_check_vr_reassemble(
               {
                  LOG_E(RLC, "AM Rx Check Reassembly vr=%d should be partly received SNHead=%d LCID=%d\n",
                        rlc_pP->vr_r,sn_ref,rlc_pP->channel_id);
-                 return FALSE;
+                 return false;
               }
 /*
 				AssertFatal(pdu_cursor_mgnt_p->all_segments_received == 0,"AM Rx Check Reassembly vr=%d should be partly received SNHead=%d LCID=%d\n",
@@ -123,7 +122,7 @@ boolean_t rlc_am_rx_check_vr_reassemble(
             {
                LOG_E(RLC, "AM Rx Check Reassembly SNHead=vr=%d should be partly received LCID=%d\n",
                      rlc_pP->vr_r,rlc_pP->channel_id);
-               return FALSE;
+               return false;
             }
 /*
 			AssertFatal(pdu_cursor_mgnt_p->all_segments_received == 0,"AM Rx Check Reassembly SNHead=vr=%d should be partly received LCID=%d\n",
@@ -132,7 +131,7 @@ boolean_t rlc_am_rx_check_vr_reassemble(
 			while ((cursor_p != NULL) && (pdu_info_p->sn == rlc_pP->vr_r) && (pdu_info_p->so == next_waited_so)) {
 				if (pdu_cursor_mgnt_p->segment_reassembled == RLC_AM_RX_PDU_SEGMENT_REASSEMBLE_NO) {
 					pdu_cursor_mgnt_p->segment_reassembled = RLC_AM_RX_PDU_SEGMENT_REASSEMBLE_PENDING;
-					reassemble = TRUE;
+					reassemble = true;
 				}
 				next_waited_so += pdu_info_p->payload_size;
 				cursor_p = cursor_p->next;
@@ -157,7 +156,7 @@ mem_block_t * create_new_segment_from_pdu(
 	int16_t  new_li_list[RLC_AM_MAX_SDU_IN_PDU];
 	int16_t header_size = 0;
 	uint8_t	num_li = 0;
-	boolean_t fi_start, fi_end, lsf;
+	bool fi_start, fi_end, lsf;
 
 	/* Init some PDU Segment header fixed parameters */
 	fi_start = !((pdu_rx_info_p->fi & 0x2) >> 1);
@@ -170,11 +169,11 @@ mem_block_t * create_new_segment_from_pdu(
 		header_size = RLC_AM_PDU_SEGMENT_HEADER_MIN_SIZE;
 
 		if (so_offset) {
-			fi_start = FALSE;
+			fi_start = false;
 		}
 		if (so_offset + data_length_to_copy != pdu_rx_info_p->payload_size) {
-			fi_end = FALSE;
-			lsf = FALSE;
+			fi_end = false;
+			lsf = false;
 		}
 	} // end no LI in original segment
 	else {
@@ -185,7 +184,7 @@ mem_block_t * create_new_segment_from_pdu(
 
 		/* set LSF to false if we know that end of the original segment will not be copied */
 		if (so_offset + data_length_to_copy != pdu_rx_info_p->payload_size) {
-			lsf = FALSE;
+			lsf = false;
 		}
 
 		/* catch the first LI containing so_offset */
@@ -223,7 +222,7 @@ mem_block_t * create_new_segment_from_pdu(
 				num_li = j;
 				/* set FI End if remaining size = 0  */
 				if (remaining_size == 0) {
-					fi_end = TRUE;
+					fi_end = true;
 				}
 			}
 		}
@@ -263,7 +262,7 @@ mem_block_t * create_new_segment_from_pdu(
 		}
 
 		/* Fill Header part in the buffer */
-		/* Content is supposed to be init with 0 so with FIStart=FIEnd=TRUE */
+		/* Content is supposed to be init with 0 so with FIStart=FIEnd=true */
 		/* copy first two bytes from original: D/C + RF + FI + E+ SN*/
 		memset(pdu_segment_header_p, 0, header_size);
 		RLC_AM_PDU_SET_D_C(*pdu_segment_header_p);
@@ -1106,7 +1105,7 @@ rlc_am_rx_list_reassemble_rlc_sdus(
   do {
     if (rlc_am_rx_pdu_management_p->all_segments_received > 0) {
       cursor_p = list2_remove_head(&rlc_pP->receiver_buffer);
-      rlc_am_reassemble_pdu(ctxt_pP, rlc_pP, cursor_p,TRUE);
+      rlc_am_reassemble_pdu(ctxt_pP, rlc_pP, cursor_p, true);
       rlc_am_rx_old_pdu_management = rlc_am_rx_pdu_management_p;
       cursor_p = list2_get_head(&rlc_pP->receiver_buffer);
 
@@ -1123,7 +1122,7 @@ rlc_am_rx_list_reassemble_rlc_sdus(
     else if (rlc_am_rx_pdu_management_p->segment_reassembled == RLC_AM_RX_PDU_SEGMENT_REASSEMBLE_PENDING) {
     	rlc_am_rx_pdu_management_p->segment_reassembled = RLC_AM_RX_PDU_SEGMENT_REASSEMBLED;
 
-        rlc_am_reassemble_pdu(ctxt_pP, rlc_pP, cursor_p,FALSE);
+        rlc_am_reassemble_pdu(ctxt_pP, rlc_pP, cursor_p, false);
         rlc_am_rx_old_pdu_management = rlc_am_rx_pdu_management_p;
         cursor_p = cursor_p->next;
 

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

@@ -61,13 +61,13 @@ rlc_am_rx_pdu_status_t rlc_am_rx_list_check_duplicate_insert_pdu(const protocol_
 */
 signed int rlc_am_rx_list_insert_pdu(const protocol_ctxt_t* const ctxt_pP, rlc_am_entity_t* const rlcP,  mem_block_t* const tbP);
 
-/*! \fn boolean_t rlc_am_rx_check_vr_reassemble(const protocol_ctxt_t* const ctxt_pP,const rlc_am_entity_t* const rlc_pP)
+/*! \fn bool rlc_am_rx_check_vr_reassemble(const protocol_ctxt_t* const ctxt_pP,const rlc_am_entity_t* const rlc_pP)
 * \brief      Check if reassembly taking into account potential new vrR value
 * \param[in]  ctxt_pP        Running context.
 * \param[in]  rlcP         RLC AM protocol instance pointer.
-* \return     TRUE if reassembly must be done, FALSE else
+* \return     true if reassembly must be done, false else
 */
-boolean_t rlc_am_rx_check_vr_reassemble(const protocol_ctxt_t* const ctxt_pP,const rlc_am_entity_t* const rlc_pP);
+bool rlc_am_rx_check_vr_reassemble(const protocol_ctxt_t* const ctxt_pP,const rlc_am_entity_t* const rlc_pP);
 
 /*! \fn void rlc_am_rx_check_all_byte_segments(const protocol_ctxt_t* const ctxt_pP, rlc_am_entity_t* const rlcP, mem_block_t* const tbP)
 * \brief      Check if all sub-segments of a PDU are received, if yes then call rlc_am_rx_mark_all_segments_received() procedure.

openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_segment.c

@@ -32,12 +32,11 @@
 #include "common/utils/LOG/log.h"
 
 //-----------------------------------------------------------------------------
-void rlc_am_pdu_polling (
-  const protocol_ctxt_t* const  ctxt_pP,
-  rlc_am_entity_t *const rlc_pP,
-  rlc_am_pdu_sn_10_t *const pdu_pP,
-  const int16_t payload_sizeP,
-  boolean_t is_new_pdu)
+void rlc_am_pdu_polling(const protocol_ctxt_t* const  ctxt_pP,
+                        rlc_am_entity_t *const rlc_pP,
+                        rlc_am_pdu_sn_10_t *const pdu_pP,
+                        const int16_t payload_sizeP,
+                        bool is_new_pdu)
 {
   // 5.2.2 Polling
   // An AM RLC entity can poll its peer AM RLC entity in order to trigger STATUS reporting at the peer AM RLC entity.

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

@@ -36,14 +36,14 @@
 #        define __RLC_AM_SEGMENT_H__
 //-----------------------------------------------------------------------------
 
-/*! \fn void rlc_am_pdu_polling (const protocol_ctxt_t* const  ctxt_pP, rlc_am_entity_t *const rlcP, rlc_am_pdu_sn_10_t *pduP, int16_t payload_sizeP,boolean_t is_new_pdu)
+/*! \fn void rlc_am_pdu_polling (const protocol_ctxt_t* const  ctxt_pP, rlc_am_entity_t *const rlcP, rlc_am_pdu_sn_10_t *pduP, int16_t payload_sizeP, bool is_new_pdu)
 * \brief      Set or not the poll bit in the PDU header depending on RLC AM protocol variables.
 * \param[in]  ctxt_pP          Running context.
 * \param[in]  rlcP           RLC AM protocol instance pointer.
 * \param[in]  pduP           Pointer on the header of the PDU in order to be able to set the poll bit if necessary.
 * \param[in]  payload_sizeP  Size of the payload of the PDU.
 */
-void rlc_am_pdu_polling (const protocol_ctxt_t* const  ctxt_pP, rlc_am_entity_t *const rlcP, rlc_am_pdu_sn_10_t *pduP, int16_t payload_sizeP,boolean_t is_new_pdu);
+void rlc_am_pdu_polling (const protocol_ctxt_t* const  ctxt_pP, rlc_am_entity_t *const rlcP, rlc_am_pdu_sn_10_t *pduP, int16_t payload_sizeP, bool is_new_pdu);
 
 /*! \fn void rlc_am_segment_10 (const protocol_ctxt_t* const  ctxt_pP, rlc_am_entity_t * const rlcP)
 * \brief      Segment a PDU with 10 bits sequence number, based on segmentation information given by MAC (size to transmit).

openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_status_report.c

@@ -237,7 +237,7 @@ rlc_am_receive_process_control_pdu(
   rlc_sn_t        nack_sn,prev_nack_sn;
   sdu_size_t    data_cnf_so_stop = 0x7FFF;
   unsigned int nack_index;
-  boolean_t status = TRUE;
+  bool status = true;
 
   if (rlc_am_get_control_pdu_infos(rlc_am_pdu_sn_10_p, tb_size_in_bytes_pP, &rlc_pP->control_pdu_info) >= 0) {
     rlc_am_tx_buffer_display(ctxt_pP, rlc_pP, " TX BUFFER BEFORE PROCESS OF STATUS PDU");
@@ -282,7 +282,7 @@ rlc_am_receive_process_control_pdu(
     if (RLC_AM_DIFF_SN(rlc_pP->vt_s,rlc_pP->vt_a) >= RLC_AM_DIFF_SN(ack_sn,rlc_pP->vt_a)) {
       if (rlc_pP->control_pdu_info.num_nack == 0) {
         while (sn_cursor != ack_sn) {
-          rlc_am_ack_pdu(ctxt_pP, rlc_pP, sn_cursor,TRUE);
+          rlc_am_ack_pdu(ctxt_pP, rlc_pP, sn_cursor, true);
           sn_cursor = RLC_AM_NEXT_SN(sn_cursor);
         }
 
@@ -294,7 +294,7 @@ rlc_am_receive_process_control_pdu(
         prev_nack_sn = 0x3FFF;
 
         while (sn_cursor != nack_sn) {
-          rlc_am_ack_pdu(ctxt_pP, rlc_pP, sn_cursor,TRUE);
+          rlc_am_ack_pdu(ctxt_pP, rlc_pP, sn_cursor, true);
           sn_cursor = RLC_AM_NEXT_SN(sn_cursor);
         }
 
@@ -316,7 +316,7 @@ rlc_am_receive_process_control_pdu(
             rlc_am_ack_pdu(ctxt_pP,
                            rlc_pP,
                            sn_cursor,
-                           FALSE);
+                           false);
           } else {
             status = rlc_am_nack_pdu (ctxt_pP,
                                       rlc_pP,
@@ -348,13 +348,13 @@ rlc_am_receive_process_control_pdu(
       LOG_E(RLC, PROTOCOL_RLC_AM_CTXT_FMT" WARNING CONTROL PDU ACK SN %d OUT OF WINDOW vtA=%d vtS=%d\n",
             PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),ack_sn,rlc_pP->vt_a,rlc_pP->vt_s);
       *tb_size_in_bytes_pP = 0;
-      status = FALSE;
+      status = false;
     }
   } else {
     LOG_E(RLC, PROTOCOL_RLC_AM_CTXT_FMT" ERROR IN DECODING CONTROL PDU\n",
           PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP));
     *tb_size_in_bytes_pP = 0;
-    status = FALSE;
+    status = false;
   }
 
   if (status) {
@@ -480,8 +480,8 @@ rlc_am_send_status_pdu(
   int                           waited_so             = 0;
   mem_block_t                  *tb_p                  = NULL;
   sdu_size_t                    pdu_size              = 0;
-  boolean_t           status_report_completed = false;
-  boolean_t           segment_loop_end    = false;
+  bool                          status_report_completed = false;
+  bool                          segment_loop_end    = false;
   memset(&control_pdu_info, 0, sizeof(rlc_am_control_pdu_info_t));
   LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[SEND-STATUS] nb_bits_to_transmit %d (15 already allocated for header)\n",
         PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),

openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_test.c

@@ -1170,7 +1170,7 @@ void rlc_am_v9_3_0_test(void)
 {
   //     initscr();
   //     cbreak();
-  //     keypad(stdscr, TRUE);
+  //     keypad(stdscr, true);
   // under test
   pool_buffer_init();
   set_comp_log(RLC, LOG_ERR, LOG_MED, 1);

openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_timer_poll_retransmit.c

@@ -111,7 +111,7 @@ rlc_am_check_timer_poll_retransmit(
 	  }
 
 
-      rlc_pP->force_poll= TRUE;
+      rlc_pP->force_poll = true;
       //BugFix : new ms_time_out is computed when next poll is transmitter
     }
   }

openair2/LAYER2/RLC/TM_v9.3.0/rlc_tm.c

@@ -31,13 +31,11 @@
 #include "list.h"
 #include "LAYER2/MAC/mac_extern.h"
 //-----------------------------------------------------------------------------
-void
-rlc_tm_send_sdu (
-  const protocol_ctxt_t* const  ctxt_pP,
-  rlc_tm_entity_t * const rlc_pP,
-  const boolean_t         error_indicationP,
-  uint8_t * const         srcP,
-  const sdu_size_t        length_in_bitsP)
+void rlc_tm_send_sdu(const protocol_ctxt_t* const ctxt_pP,
+                     rlc_tm_entity_t *      const rlc_pP,
+                     const bool                   error_indicationP,
+                     uint8_t *              const srcP,
+                     const sdu_size_t             length_in_bitsP)
 {
   int             length_in_bytes;
 #if DEBUG_RLC_TM_DISPLAY_ASCII_DATA

openair2/LAYER2/RLC/TM_v9.3.0/rlc_tm.h

@@ -51,7 +51,7 @@
 /*! \fn void rlc_tm_send_sdu (
 *        const protocol_ctxt_t* const  ctxt_pP,
 *        rlc_tm_entity_t * const rlc_pP,
-*        const boolean_t         error_indicationP,
+*        const bool            error_indicationP,
 *        uint8_t * const         srcP,
 *        const sdu_size_t        length_in_bitsP)
 * \brief    Send SDU if any reassemblied to upper layer.
@@ -60,12 +60,11 @@
 * \param[in]  srcP                SDU data pointer.
 * \param[in]  length_in_bitsP     Length of SDU in bits.
 */
-void rlc_tm_send_sdu (
-                 const protocol_ctxt_t* const  ctxt_pP,
-                 rlc_tm_entity_t * const rlc_pP,
-                 const boolean_t         error_indicationP,
-                 uint8_t * const         srcP,
-                 const sdu_size_t        length_in_bitsP);
+void rlc_tm_send_sdu(const protocol_ctxt_t* const  ctxt_pP,
+                     rlc_tm_entity_t * const rlc_pP,
+                     const bool         error_indicationP,
+                     uint8_t * const         srcP,
+                     const sdu_size_t        length_in_bitsP);
 
 /*! \fn void rlc_tm_no_segment (const protocol_ctxt_t* const  ctxt_pP, rlc_tm_entity_t * const rlcP)
 * \brief    Schedule a SDU to be transmited by lower layers.

openair2/LAYER2/RLC/TM_v9.3.0/rlc_tm_entity.h

@@ -40,14 +40,13 @@
 * \brief Structure containing a RLC TM instance protocol variables, allocation variables, buffers and other miscellaneous variables.
 */
 typedef struct rlc_tm_entity {
-  boolean_t            allocation;         /*!< \brief Boolean for rlc_tm_entity_t struct allocation. */
+  bool                 allocation;         /*!< \brief Boolean for rlc_tm_entity_t struct allocation. */
   rlc_protocol_state_t protocol_state;     /*!< \brief Protocol state, can be RLC_NULL_STATE, RLC_DATA_TRANSFER_READY_STATE, RLC_LOCAL_SUSPEND_STATE. */
-  boolean_t            is_uplink_downlink; /*!< \brief Is this instance is a transmitter, a receiver or both? */
-  boolean_t            is_data_plane;      /*!< \brief To know if the RLC belongs to a data radio bearer or a signalling radio bearer, for statistics and trace purpose. */
+  bool                 is_uplink_downlink; /*!< \brief Is this instance is a transmitter, a receiver or both? */
+  bool                 is_data_plane;      /*!< \brief To know if the RLC belongs to a data radio bearer or a signalling radio bearer, for statistics and trace purpose. */
   // for stats and trace purpose :
   logical_chan_id_t    channel_id;         /*!< \brief Transport channel identifier. */
   rb_id_t              rb_id;              /*!< \brief Radio bearer identifier, for statistics and trace purpose. */
-  //boolean_t            is_enb;             /*!< \brief To know if the RLC belongs to a eNB or UE. */
   //-----------------------------
   // tranmission
   //-----------------------------

openair2/LAYER2/RLC/TM_v9.3.0/rlc_tm_init.c

@@ -133,10 +133,9 @@ rlc_tm_cleanup (
 }
 
 //-----------------------------------------------------------------------------
-void rlc_tm_configure(
-  const protocol_ctxt_t* const  ctxt_pP,
-  rlc_tm_entity_t * const rlcP,
-  const boolean_t is_uplink_downlinkP)
+void rlc_tm_configure(const protocol_ctxt_t* const  ctxt_pP,
+                      rlc_tm_entity_t * const rlcP,
+                      const bool is_uplink_downlinkP)
 {
   rlcP->is_uplink_downlink = is_uplink_downlinkP;
   rlc_tm_reset_state_variables (ctxt_pP, rlcP);

openair2/LAYER2/RLC/TM_v9.3.0/rlc_tm_init.h

@@ -78,27 +78,24 @@ void rlc_tm_init (
 * \brief    Reset protocol variables and state variables to initial values.
 * \param[in]  rlcP                      RLC TM protocol instance pointer.
 */
-void rlc_tm_reset_state_variables (
-                        const protocol_ctxt_t* const  ctxt_pP,
-                        rlc_tm_entity_t * const rlcP);
+void rlc_tm_reset_state_variables(const protocol_ctxt_t* const ctxt_pP,
+                                  rlc_tm_entity_t * const rlcP);
 
 /*! \fn void rlc_tm_cleanup(rlc_tm_entity_t * const rlcP)
 * \brief    Free all allocated memory (lists and buffers) previously allocated by this RLC TM instance.
 * \param[in]  rlcP                      RLC TM protocol instance pointer.
 */
-void rlc_tm_cleanup(
-                        rlc_tm_entity_t * const rlcP);
+void rlc_tm_cleanup(rlc_tm_entity_t * const rlcP);
 
-/*! \fn void rlc_tm_configure(const protocol_ctxt_t* const  ctxt_pP,rlc_tm_entity_t * const rlcP, const boolean_t is_uplink_downlinkP)
+/*! \fn void rlc_tm_configure(const protocol_ctxt_t* const  ctxt_pP,rlc_tm_entity_t * const rlcP, const bool is_uplink_downlinkP)
 * \brief    Configure RLC TM protocol parameters.
 * \param[in]  rlcP                      RLC TM protocol instance pointer.
 * \param[in]  is_uplink_downlinkP       Is this instance is TRANSMITTER_ONLY,
 RECEIVER_ONLY, or TRANSMITTER_AND_RECEIVER.
 */
-void rlc_tm_configure(
-                        const protocol_ctxt_t* const  ctxt_pP,
-                        rlc_tm_entity_t * const rlcP,
-                        const boolean_t is_uplink_downlinkP);
+void rlc_tm_configure(const protocol_ctxt_t* const  ctxt_pP,
+                      rlc_tm_entity_t * const rlcP,
+                      const bool is_uplink_downlinkP);
 
 /*! \fn void rlc_tm_set_debug_infos(const protocol_ctxt_t* const  ctxt_pP, rlc_tm_entity_t * const rlcP, const rb_id_t rb_idP, const srb_flag_t srb_flagP)
 * \brief    Set debug informations for a RLC TM protocol instance, these informations are only for trace purpose.

openair2/LAYER2/RLC/UM_v9.3.0/rlc_um_control_primitives.c

@@ -263,7 +263,7 @@ rlc_um_init (
     }
 
     rlc_pP->first_pdu = 1;
-    rlc_pP->initialized = TRUE;
+    rlc_pP->initialized = true;
   }
 }
 //-----------------------------------------------------------------------------

openair2/LAYER2/RLC/UM_v9.3.0/rlc_um_entity.h

@@ -53,12 +53,11 @@ typedef struct rlc_um_timer_s {
 */
 
 typedef struct rlc_um_entity_s {
-  boolean_t            initialized;        /*!< \brief Boolean for rlc_am_entity_t struct initialization. */
-  boolean_t            is_uplink_downlink; /*!< \brief Is this instance is a transmitter, a receiver or both? */
+  bool                 initialized;        /*!< \brief Boolean for rlc_am_entity_t struct initialization. */
+  bool                 is_uplink_downlink; /*!< \brief Is this instance is a transmitter, a receiver or both? */
   rlc_protocol_state_t protocol_state;     /*!< \brief Protocol state, can be RLC_NULL_STATE, RLC_DATA_TRANSFER_READY_STATE, RLC_LOCAL_SUSPEND_STATE. */
-  boolean_t            is_data_plane;      /*!< \brief To know if the RLC belongs to a data radio bearer or a signalling radio bearer, for statistics and trace purpose. */
-  //boolean_t            is_enb;             /*!< \brief To know if the RLC belongs to a eNB or UE. */
-  boolean_t            is_mxch;            /*!< \brief To know if the RLC belongs to a MBMS bearer. */
+  bool                 is_data_plane;      /*!< \brief To know if the RLC belongs to a data radio bearer or a signalling radio bearer, for statistics and trace purpose. */
+  bool                 is_mxch;            /*!< \brief To know if the RLC belongs to a MBMS bearer. */
   //-----------------------------
   // PROTOCOL VARIABLES
   //-----------------------------
@@ -114,7 +113,7 @@ typedef struct rlc_um_entity_s {
   //-----------------------------
   // STATISTICS
   //-----------------------------
-  boolean_t         first_pdu;                        /*!< \brief Act as a boolean, tells if the next PDU is the first PDU to be received. */
+  bool              first_pdu;                        /*!< \brief Act as a boolean, tells if the next PDU is the first PDU to be received. */
 
   unsigned int stat_tx_pdcp_sdu;                      /*!< \brief Number of SDUs received from upper layers. */
   unsigned int stat_tx_pdcp_bytes;                    /*!< \brief Number of SDU bytes received from upper layers. */

openair2/LAYER2/RLC/rlc.c

@@ -41,13 +41,12 @@
 #include "common/ran_context.h"
 extern RAN_CONTEXT_t RC;
 
-extern boolean_t pdcp_data_ind(
-  const protocol_ctxt_t *const ctxt_pP,
-  const srb_flag_t srb_flagP,
-  const MBMS_flag_t MBMS_flagP,
-  const rb_id_t rb_idP,
-  const sdu_size_t sdu_buffer_sizeP,
-  mem_block_t *const sdu_buffer_pP);
+extern bool pdcp_data_ind(const protocol_ctxt_t *const ctxt_pP,
+                          const srb_flag_t srb_flagP,
+                          const MBMS_flag_t MBMS_flagP,
+                          const rb_id_t rb_idP,
+                          const sdu_size_t sdu_buffer_sizeP,
+                          mem_block_t *const sdu_buffer_pP);
 
 #define DEBUG_RLC_PDCP_INTERFACE 1
 //#define TRACE_RLC_PAYLOAD 1
@@ -397,7 +396,7 @@ rlc_op_status_t rlc_data_req     (const protocol_ctxt_t *const ctxt_pP,
 
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_IN);
 
-  if (MBMS_flagP == TRUE) {
+  if (MBMS_flagP == true) {
     if (ctxt_pP->enb_flag) {
       log_ch_id = rlc_mbms_enb_get_lcid_by_rb_id(ctxt_pP->module_id,rb_idP);
       mbms_id_p = &rlc_mbms_lcid2service_session_id_eNB[ctxt_pP->module_id][log_ch_id];

openair2/LAYER2/RLC/rlc.h

@@ -107,7 +107,7 @@ typedef  struct {
   rlc_buffer_occupancy_t       pdus_in_buffer;  /*!< \brief Number of PDUs buffered in RLC protocol instance (OBSOLETE). */
   frame_t                      head_sdu_creation_time;           /*!< \brief Head SDU creation time. */
   sdu_size_t                   head_sdu_remaining_size_to_send;  /*!< \brief remaining size of sdu: could be the total size or the remaining size of already segmented sdu */
-  boolean_t                    head_sdu_is_segmented;     /*!< \brief 0 if head SDU has not been segmented, 1 if already segmented */
+  bool                         head_sdu_is_segmented;     /*!< \brief 0 if head SDU has not been segmented, 1 if already segmented */
 } mac_rlc_status_resp_t;
 
 

openair2/LAYER2/RLC/rlc_mac.c

@@ -425,8 +425,8 @@ rlc_buffer_occupancy_t mac_rlc_get_buffer_occupancy_ind(
   /* Assumptions : for UE only */
   /* At each TTI, Buffer Occupancy is first computed in mac_rlc_status_ind called by MAC ue_scheduler() function */
   /* Then this function is called during MAC multiplexing ue_get_sdu(), and it may be call several times for the same bearer if it is in AM mode and there are several PDU types to transmit */
-  //AssertFatal(enb_flagP == FALSE,"RLC Tx mac_rlc_get_buffer_occupancy_ind function is not implemented for eNB LcId=%d\n", channel_idP);
-  if(enb_flagP != FALSE) {
+  //AssertFatal(enb_flagP == false,"RLC Tx mac_rlc_get_buffer_occupancy_ind function is not implemented for eNB LcId=%d\n", channel_idP);
+  if(enb_flagP != false) {
     LOG_E(RLC, "Tx mac_rlc_get_buffer_occupancy_ind function is not implemented for eNB LcId=%u\n", channel_idP);
     return 0;
   }