Merge branch 'ocp_nrsimulator' into 'develop-nr'

Critical bugs from compilation, Ocp nrsimulator

See merge request oai/openairinterface5g!512

cmake_targets/build_oai

@@ -43,10 +43,10 @@ conf_nvram_path=$OPENAIR_DIR/openair3/NAS/TOOLS/ue_eurecom_test_sfr.conf
 MSC_GEN=0
 XFORMS="True"
 UE_EXPANSION="False"
+UESIM_EXPANSION="False"
 PRINT_STATS="False"
 VCD_TIMING="False"
-DEADLINE_SCHEDULER_FLAG_USER="False"
-FORCE_DEADLINE_SCHEDULER_FLAG_USER=""
+DEADLINE_SCHEDULER_FLAG_USER=""
 CPU_AFFINITY_FLAG_USER="False" #Only valid when lowlatecy flag is set to False
 REL="Rel15"
 NR_REL="NR_Rel15"
@@ -78,7 +78,7 @@ trap handle_ctrl_c INT
 function print_help() {
   echo_info "
 This program installs OpenAirInterface Software
-You should have ubuntu 14.xx, updated, and the Linux kernel >= 3.14
+You should have ubuntu 16.xx or 18.04 updated
 Options
 -h
    This help
@@ -116,7 +116,7 @@ Options
    Rel8 limits the implementation to 3GPP Release 8 version
    Rel10 limits the implementation to 3GPP Release 10 version
 -w | --hardware
-   EXMIMO, USRP, BLADERF, ETHERNET, LMSSDR, ADRV9371_ZC706, None (Default)
+   EXMIMO, USRP, BLADERF, ETHERNET, LMSSDR, ADRV9371_ZC706, SIMU, None (Default)
    Adds this RF board support (in external packages installation and in compilation)
 -t | --transport protocol
    ETHERNET , None
@@ -175,6 +175,9 @@ Options
 --basic-simulator
    Generates a basic [1 UE + 1 eNB + no channel] simulator.
    See targets/ARCH/tcp_bridge/README.tcp_bridge_oai for documentation.
+--rfsimulator
+   Generate virtual RF driver
+   to use it, set the environement variable RFSIMULATOR to \"enb\" in the eNB and to the eNB IP address in the UEs
 Usage (first build):
  NI/ETTUS B201  + COTS UE : ./build_oai -I  --eNB -x --install-system-files -w USRP
 Usage (Regular):
@@ -250,7 +253,7 @@ function main() {
        -w | --hardware)
             HW="$2" #"${i#*=}"
             # Use OAI_USRP  as the key word USRP is used inside UHD driver
-	    if [ "$HW" != "BLADERF" -a  "$HW" != "USRP" -a "$HW" != "LMSSDR" -a  "$HW" != "None" -a  "$HW" != "EXMIMO" -a  "$HW" != "ADRV9371_ZC706"  ] ; then 
+	    if [ "$HW" != "BLADERF" -a  "$HW" != "USRP" -a "$HW" != "LMSSDR" -a  "$HW" != "None" -a  "$HW" != "EXMIMO" -a  "$HW" != "ADRV9371_ZC706"  -a  "$HW" != "SIMU" ] ; then 
 		echo_fatal "Unknown HW type $HW will exit..."		
 	    else
 		if [ "$HW" == "USRP" ] ; then 
@@ -265,6 +268,9 @@ function main() {
 		if [ "$HW" == "LMSSDR" ] ; then 
 		    HW="OAI_LMSSDR"
 		fi 
+		if [ "$HW" == "SIMU" ] ; then
+                    HW="OAI_SIMU"
+                fi
 		echo_info "Setting hardware to: $HW"
 	    fi
             shift 2;;
@@ -331,13 +337,13 @@ function main() {
 	    BUILD_DOXYGEN=1
             echo_info "Will build doxygen support"
             shift;;     
-       --disable-deadline)
-            FORCE_DEADLINE_SCHEDULER_FLAG_USER="False"
-            echo_info "Disabling the usage of deadline scheduler"
-            shift 1;;
-       --enable-deadline)
-            FORCE_DEADLINE_SCHEDULER_FLAG_USER="True"
-            echo_info "Enabling the usage of deadline scheduler"
+            --disable-deadline)
+                DEADLINE_SCHEDULER_FLAG_USER="False"
+                echo_info "Disabling the usage of deadline scheduler"
+                shift 1;;
+            --enable-deadline)
+                DEADLINE_SCHEDULER_FLAG_USER="True"
+                echo_info "Enabling the usage of deadline scheduler"
             shift 1;;
        --enable-cpu-affinity)
             CPU_AFFINITY_FLAG_USER="True"
@@ -400,7 +406,11 @@ function main() {
             BASIC_SIMULATOR=1
             echo_info "Compiling the basic simulator"
             shift 1;;
-        -h | --help)
+            --rfsimulator)
+                RFSIMULATOR=true
+                echo_info "Compiling the RF simulator"
+                shift 1;;
+            -h | --help)
             print_help
             exit 1;;
 	*)
@@ -441,33 +451,18 @@ function main() {
       fi
   fi
 
-  echo_info "RF HW set to $HW" 
-  #Now we set flags to enable deadline scheduler settings
-  #By default: USRP: disable, 
-  #By default: BLADERF: enable,
-  #By default: EXMIMO: enable
-  if [ "$FORCE_DEADLINE_SCHEDULER_FLAG_USER" = "" ]; then
-     if [ "$HW" = "EXMIMO" ] ; then 
-        DEADLINE_SCHEDULER_FLAG_USER="True"
-     elif [ "$HW" = "ETHERNET" ] ; then 
-        DEADLINE_SCHEDULER_FLAG_USER="False"
-     elif [ "$HW" = "OAI_USRP" ] ; then 
-        DEADLINE_SCHEDULER_FLAG_USER="False"
-     elif [ "$HW" = "OAI_ADRV9371_ZC706" ] ; then 
-        DEADLINE_SCHEDULER_FLAG_USER="False"
-     elif [ "$HW" = "OAI_BLADERF" ] ; then 
-        DEADLINE_SCHEDULER_FLAG_USER="False"
-     elif [ "$HW" = "OAI_LMSSDR" ] ; then 
-        DEADLINE_SCHEDULER_FLAG_USER="False"
-     elif [ "$HW" = "None" ] ; then 
-        DEADLINE_SCHEDULER_FLAG_USER="False"
-     else 
-        echo_error "Unknown HW type $HW. Exiting now..."
-        exit 
-     fi
-  else
-     DEADLINE_SCHEDULER_FLAG_USER=$FORCE_DEADLINE_SCHEDULER_FLAG_USER
-  fi
+    echo_info "RF HW set to $HW" 
+    # If the user doesn't specify the Linux scheduler to use, we set a value
+    if [ "$DEADLINE_SCHEDULER_FLAG_USER" = "" ]; then
+	case "$HW" in
+            "EXMIMO")
+		DEADLINE_SCHEDULER_FLAG_USER="True"
+		;;
+            *)
+		DEADLINE_SCHEDULER_FLAG_USER="False"
+		;;
+	esac
+    fi
 
   #Disable CPU Affinity for deadline scheduler
   if [ "$DEADLINE_SCHEDULER_FLAG_USER" = "True" ] ; then 

cmake_targets/tools/make_asn1c_includes.sh

+#!/bin/bash
+GENERATED_FULL_DIR=$1
+shift
+ASN1_SOURCE_DIR=$1
+shift
+export ASN1C_PREFIX=$1 
+shift
+options=$*
+done_flag="$GENERATED_FULL_DIR"/done
+if [ "$done_flag" -ot $ASN1_SOURCE_DIR ] ; then 
+   rm -f "$GENERATED_FULL_DIR"/${ASN1C_PREFIX}*.c "$GENERATED_FULL_DIR"/${ASN1C_PREFIX}*.h
+   mkdir -p "$GENERATED_FULL_DIR"
+   asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example $options -D $GENERATED_FULL_DIR $ASN1_SOURCE_DIR |& egrep -v "^Copied|^Compiled" | sort -u
+fi
+touch $done_flag

common/utils/backtrace.h

@@ -23,9 +23,16 @@
 
 #ifndef BACKTRACE_H_
 #define BACKTRACE_H_
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 void display_backtrace(void);
 
 void backtrace_handle_signal(siginfo_t *info);
+#ifdef __cplusplus
+}
+#endif
+
 
 #endif /* BACKTRACE_H_ */

openair1/PHY/INIT/nr_init_ue.c

@@ -919,7 +919,7 @@ void init_nr_ue_transport(PHY_VARS_NR_UE *ue,int abstraction_flag) {
 
   for (i=0; i<NUMBER_OF_CONNECTED_eNB_MAX; i++) {
     for (j=0; j<2; j++) {
-      for (k=0; k<2; k++) {
+      for (k=0; k<RX_NB_TH_MAX; k++) {
 	AssertFatal((ue->dlsch[k][i][j]  = new_nr_ue_dlsch(1,NUMBER_OF_HARQ_PID_MAX,NSOFT,MAX_LDPC_ITERATIONS,ue->frame_parms.N_RB_DL, abstraction_flag))!=NULL,"Can't get ue dlsch structures\n");
 
 	LOG_D(PHY,"dlsch[%d][%d][%d] => %p\n",k,i,j,ue->dlsch[i][j]);

openair1/PHY/NR_UE_TRANSPORT/dci_nr.c

@@ -421,6 +421,7 @@ void nr_pdcch_extract_rbs_single(int32_t **rxdataF,
 #ifdef NR_PDCCH_DCI_DEBUG
       printf("\t\t<-NR_PDCCH_DCI_DEBUG (nr_pdcch_extract_rbs_single)-> c_rb=%d\n",c_rb);
 #endif
+      rxF=NULL;
       // first we set initial conditions for pointer to rxdataF depending on the situation of the first RB within the CORESET (c_rb = n_BWP_start)
       if ((c_rb < (frame_parms->N_RB_DL >> 1)) && ((frame_parms->N_RB_DL & 1) == 0)) {
         //if RB to be treated is lower than middle system bandwidth then rxdataF pointed at (offset + c_br + symbol * ofdm_symbol_size): even case

openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_decoding.c

@@ -516,7 +516,8 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
                            p_nrLDPC_procBuf[r],
                            p_procTime);
 
-		if (check_crc(llrProcBuf,harq_process->B,harq_process->F,crc_type)) {
+		// Fixme: correct type is unsigned, but nrLDPC_decoder and all called behind use signed int
+		if (check_crc((uint8_t*)llrProcBuf,harq_process->B,harq_process->F,crc_type)) {
 		  printf("CRC OK\n");
 		  ret = 2;
 		}

openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_demodulation.c

@@ -1350,7 +1350,7 @@ void nr_dlsch_channel_compensation(int **rxdataF_ext,
   unsigned char aatx,aarx,pilots=0;
   __m128i *dl_ch128,*dl_ch128_2,*dl_ch_mag128,*dl_ch_mag128b,*rxdataF128,*rxdataF_comp128,*rho128;
   __m128i mmtmpD0,mmtmpD1,mmtmpD2,mmtmpD3,QAM_amp128,QAM_amp128b;
-
+  QAM_amp128b = _mm_setzero_si128();
 
   if (symbol == 2){
       pilots=1;

openair1/PHY/NR_UE_TRANSPORT/nr_pbch.c

@@ -266,123 +266,33 @@ void nr_pbch_channel_compensation(int **rxdataF_ext,
 				  int **rxdataF_comp,
 				  NR_DL_FRAME_PARMS *frame_parms,
 				  uint32_t symbol,
-				  uint8_t output_shift)
-{
-
-  short conjugate[8]__attribute__((aligned(16))) = {-1,1,-1,1,-1,1,-1,1};
-  //short conjugate2[8]__attribute__((aligned(16))) = {1,-1,1,-1,1,-1,1,-1};
-#if defined(__x86_64__) || defined(__i386__)
-  __m128i mmtmpP0,mmtmpP1,mmtmpP2,mmtmpP3;
-#elif defined(__arm__)
-  int16x8_t mmtmpP0,mmtmpP1,mmtmpP2,mmtmpP3;
-#endif
-
-  uint16_t nb_re=180;
-  uint8_t aarx;
-
-#if defined(__x86_64__) || defined(__i386__)
-  __m128i *dl_ch128,*rxdataF128,*rxdataF_comp128;
-#elif defined(__arm__)
-
-#endif
+				  uint8_t output_shift) {
 
+  const uint16_t nb_re=symbol == 2 ? 72 : 180;
+    
   AssertFatal((symbol > 0 && symbol < 4),
 	      "symbol %d is illegal for PBCH DM-RS\n",
 	      symbol);
-
-  if (symbol == 2) nb_re = 72;
-
+  
   //  printf("comp: symbol %d : nb_re %d\n",symbol,nb_re);
 
-  for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
+  for (int aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
     
-#if defined(__x86_64__) || defined(__i386__)
-    dl_ch128          = (__m128i *)&dl_ch_estimates_ext[aarx][symbol*20*12];
-    rxdataF128        = (__m128i *)&rxdataF_ext[aarx][symbol*20*12];
-    rxdataF_comp128   = (__m128i *)&rxdataF_comp[aarx][symbol*20*12];
+    vect128 *dl_ch128          = (vect128 *)&dl_ch_estimates_ext[aarx][symbol*20*12];
+    vect128 *rxdataF128        = (vect128 *)&rxdataF_ext[aarx][symbol*20*12];
+    vect128 *rxdataF_comp128   = (vect128 *)&rxdataF_comp[aarx][symbol*20*12];
     /*
     printf("ch compensation dl_ch ext addr %p \n", &dl_ch_estimates_ext[aarx][symbol*20*12]);
     printf("rxdataf ext addr %p symbol %d\n", &rxdataF_ext[aarx][symbol*20*12], symbol);
     printf("rxdataf_comp addr %p\n",&rxdataF_comp[aarx][symbol*20*12]); 
     */
-#elif defined(__arm__)
-// to be filled in
-#endif
 
     for (int re=0; re<nb_re; re+=12) {
-      //            printf("******re %d\n",re);
-#if defined(__x86_64__) || defined(__i386__)
-      // multiply by conjugated channel
-      mmtmpP0 = _mm_madd_epi16(dl_ch128[0],rxdataF128[0]);
-      //  print_ints("re",&mmtmpP0);
-      // mmtmpP0 contains real part of 4 consecutive outputs (32-bit)
-      mmtmpP1 = _mm_shufflelo_epi16(dl_ch128[0],_MM_SHUFFLE(2,3,0,1));
-      mmtmpP1 = _mm_shufflehi_epi16(mmtmpP1,_MM_SHUFFLE(2,3,0,1));
-      mmtmpP1 = _mm_sign_epi16(mmtmpP1,*(__m128i*)&conjugate[0]);
-      //  print_ints("im",&mmtmpP1);
-      mmtmpP1 = _mm_madd_epi16(mmtmpP1,rxdataF128[0]);
-      // mmtmpP1 contains imag part of 4 consecutive outputs (32-bit)
-      mmtmpP0 = _mm_srai_epi32(mmtmpP0,output_shift);
-      //  print_ints("re(shift)",&mmtmpP0);
-      mmtmpP1 = _mm_srai_epi32(mmtmpP1,output_shift);
-      //  print_ints("im(shift)",&mmtmpP1);
-      mmtmpP2 = _mm_unpacklo_epi32(mmtmpP0,mmtmpP1);
-      mmtmpP3 = _mm_unpackhi_epi32(mmtmpP0,mmtmpP1);
-      //      print_ints("c0",&mmtmpP2);
-      //  print_ints("c1",&mmtmpP3);
-      rxdataF_comp128[0] = _mm_packs_epi32(mmtmpP2,mmtmpP3);
-      /*
-        print_shorts("rx:",rxdataF128);
-        print_shorts("ch:",dl_ch128);
-        print_shorts("pack:",rxdataF_comp128);
-      */
-      // multiply by conjugated channel
-      mmtmpP0 = _mm_madd_epi16(dl_ch128[1],rxdataF128[1]);
-      // mmtmpP0 contains real part of 4 consecutive outputs (32-bit)
-      mmtmpP1 = _mm_shufflelo_epi16(dl_ch128[1],_MM_SHUFFLE(2,3,0,1));
-      mmtmpP1 = _mm_shufflehi_epi16(mmtmpP1,_MM_SHUFFLE(2,3,0,1));
-      mmtmpP1 = _mm_sign_epi16(mmtmpP1,*(__m128i*)&conjugate[0]);
-      mmtmpP1 = _mm_madd_epi16(mmtmpP1,rxdataF128[1]);
-      // mmtmpP1 contains imag part of 4 consecutive outputs (32-bit)
-      mmtmpP0 = _mm_srai_epi32(mmtmpP0,output_shift);
-      mmtmpP1 = _mm_srai_epi32(mmtmpP1,output_shift);
-      mmtmpP2 = _mm_unpacklo_epi32(mmtmpP0,mmtmpP1);
-      mmtmpP3 = _mm_unpackhi_epi32(mmtmpP0,mmtmpP1);
-      rxdataF_comp128[1] = _mm_packs_epi32(mmtmpP2,mmtmpP3);
-      //  print_shorts("rx:",rxdataF128+1);
-      //  print_shorts("ch:",dl_ch128+1);
-      //  print_shorts("pack:",rxdataF_comp128+1);
-      
-      // multiply by conjugated channel
-      mmtmpP0 = _mm_madd_epi16(dl_ch128[2],rxdataF128[2]);
-      // mmtmpP0 contains real part of 4 consecutive outputs (32-bit)
-      mmtmpP1 = _mm_shufflelo_epi16(dl_ch128[2],_MM_SHUFFLE(2,3,0,1));
-      mmtmpP1 = _mm_shufflehi_epi16(mmtmpP1,_MM_SHUFFLE(2,3,0,1));
-      mmtmpP1 = _mm_sign_epi16(mmtmpP1,*(__m128i*)&conjugate[0]);
-      mmtmpP1 = _mm_madd_epi16(mmtmpP1,rxdataF128[2]);
-      // mmtmpP1 contains imag part of 4 consecutive outputs (32-bit)
-      mmtmpP0 = _mm_srai_epi32(mmtmpP0,output_shift);
-      mmtmpP1 = _mm_srai_epi32(mmtmpP1,output_shift);
-      mmtmpP2 = _mm_unpacklo_epi32(mmtmpP0,mmtmpP1);
-      mmtmpP3 = _mm_unpackhi_epi32(mmtmpP0,mmtmpP1);
-      rxdataF_comp128[2] = _mm_packs_epi32(mmtmpP2,mmtmpP3);
-      //  print_shorts("rx:",rxdataF128+2);
-      //  print_shorts("ch:",dl_ch128+2);
-      //      print_shorts("pack:",rxdataF_comp128+2);
-      
-      dl_ch128+=3;
-      rxdataF128+=3;
-      rxdataF_comp128+=3;
-      
-#elif defined(__arm__)
-      // to be filled in
-#endif
+      *rxdataF_comp128++ = mulByConjugate128(rxdataF128++, dl_ch128++, output_shift);
+      *rxdataF_comp128++ = mulByConjugate128(rxdataF128++, dl_ch128++, output_shift);
+      *rxdataF_comp128++ = mulByConjugate128(rxdataF128++, dl_ch128++, output_shift);
     }
   }
-#if defined(__x86_64__) || defined(__i386__)
-  _mm_empty();
-  _m_empty();
-#endif
 }
 
 void nr_pbch_detection_mrc(NR_DL_FRAME_PARMS *frame_parms,

openair1/PHY/NR_UE_TRANSPORT/nr_prach.c

@@ -577,7 +577,7 @@ int32_t generate_nr_prach( PHY_VARS_NR_UE *ue, uint8_t eNB_id, uint8_t subframe,
   uint8_t preamble_index     = ue->prach_resources[eNB_id]->ra_PreambleIndex;
   //uint8_t tdd_mapindex       = ue->prach_resources[eNB_id]->ra_TDD_map_index;
   int16_t *prachF           = ue->prach_vars[eNB_id]->prachF;
-  static int16_t prach_tmp[45600*2] __attribute__((aligned(32)));
+  static int16_t prach_tmp[45600*4] __attribute__((aligned(32)));
   int16_t *prach            = prach_tmp;
   int16_t *prach2;
   int16_t amp               = ue->prach_vars[eNB_id]->amp;

openair1/PHY/defs_RU.h

@@ -399,7 +399,7 @@ typedef struct RU_t_s{
   /// function pointer to release function for radio interface
   int                  (*stop_rf)(struct RU_t_s *ru);
   /// function pointer to initialization function for radio interface
-  int                  (*start_if)(struct RU_t_s *ru,struct PHY_VARS_eNB_s *eNB);
+  int                  (*start_if)(struct RU_t_s *ru,struct PHY_VARS_gNB_s *gNB);
   /// function pointer to RX front-end processing routine (DFTs/prefix removal or NULL)
   void                 (*feprx)(struct RU_t_s *ru);
   /// function pointer to TX front-end processing routine (IDFTs and prefix removal or NULL)

openair1/PHY/defs_nr_UE.h

@@ -1021,11 +1021,13 @@ typedef struct {
   NR_UE_COMMON    common_vars;
 
   nr_ue_if_module_t *if_inst;
+
   nr_downlink_indication_t dl_indication;
   nr_uplink_indication_t ul_indication;
   /// UE FAPI DCI request
   nr_dcireq_t dcireq;
 
+  // CHECK if we need those as they are also included in dl_indictation
   /// UE FAPI indication for DLSCH reception
   fapi_nr_rx_indication_t rx_ind;
   /// UE FAPI indication for DCI reception

openair1/PHY/sse_intrin.h

@@ -26,11 +26,11 @@
  * The host CPU needs to have support for SSE2 at least. SSE3 and SSE4.1 functions are emulated if the CPU lacks support for them.
  * This will slow down the softmodem, but may be valuable if only offline signal processing is required.
  *
- * \author S. Held
- * \email sebastian.held@imst.de
- * \company IMST GmbH
- * \date 2015
- * \version 0.1
+ * \author S. Held, Laurent THOMAS
+ * \email sebastian.held@imst.de, laurent.thomas@open-cells.com	
+ * \company IMST GmbH, Open Cells Project
+ * \date 2019
+ * \version 0.2
 */
 
 #ifndef SSE_INTRIN_H
@@ -40,23 +40,23 @@
 #if defined(__x86_64) || defined(__i386__)
 
 #ifndef __SSE2__
-#  error SSE2 processor intrinsics disabled
+  #  error SSE2 processor intrinsics disabled
 #endif
 
 #include <emmintrin.h>
 #include <xmmintrin.h>
 
 #ifdef __SSE3__
-#  include <pmmintrin.h>
-#  include <tmmintrin.h>
+  #include <pmmintrin.h>
+  #include <tmmintrin.h>
 #endif
 
 #ifdef __SSE4_1__
-#  include <smmintrin.h>
+  #include <smmintrin.h>
 #endif
 
 #ifdef __AVX2__
-#  include <immintrin.h>
+  #include <immintrin.h>
 #endif
 
 // ------------------------------------------------
@@ -108,8 +108,7 @@ typedef union {
  * \date 2006-2008
  * \copyright Apache License 2.0
  */
-static inline __m128i ssp_comge_epi8_SSE2(__m128i a, __m128i b)
-{
+static inline __m128i ssp_comge_epi8_SSE2(__m128i a, __m128i b) {
   __m128i c;
   c = _mm_cmpgt_epi8( a, b );
   a = _mm_cmpeq_epi8( a, b );
@@ -126,13 +125,11 @@ static inline __m128i ssp_comge_epi8_SSE2(__m128i a, __m128i b)
  * \date 2006-2008
  * \copyright Apache License 2.0
  */
-static inline __m128i ssp_shuffle_epi8_SSE2 (__m128i a, __m128i mask)
-{
+static inline __m128i ssp_shuffle_epi8_SSE2 (__m128i a, __m128i mask) {
   ssp_m128 A,B, MASK, maskZero;
   A.i        = a;
   maskZero.i = ssp_comge_epi8_SSE2( mask, _mm_setzero_si128()        );
   MASK.i     = _mm_and_si128      ( mask, _mm_set1_epi8( (char)0x0F) );
-
   B.s8[ 0] = A.s8[ (MASK.s8[ 0]) ];
   B.s8[ 1] = A.s8[ (MASK.s8[ 1]) ];
   B.s8[ 2] = A.s8[ (MASK.s8[ 2]) ];
@@ -149,7 +146,6 @@ static inline __m128i ssp_shuffle_epi8_SSE2 (__m128i a, __m128i mask)
   B.s8[13] = A.s8[ (MASK.s8[13]) ];
   B.s8[14] = A.s8[ (MASK.s8[14]) ];
   B.s8[15] = A.s8[ (MASK.s8[15]) ];
-
   B.i = _mm_and_si128( B.i, maskZero.i );
   return B.i;
 }
@@ -182,8 +178,7 @@ static inline __m128i ssp_shuffle_epi8_SSE2 (__m128i a, __m128i mask)
  * \date 2006-2008
  * \copyright Apache License 2.0
  */
-static inline __m128i ssp_insert_epi8_SSE2( __m128i a, int b, const int ndx )
-{
+static inline __m128i ssp_insert_epi8_SSE2( __m128i a, int b, const int ndx ) {
   ssp_m128 Ahi, Alo;
   b = b & 0xFF;                                           /* Convert to 8-bit integer */
   Ahi.i = _mm_unpackhi_epi8( a, _mm_setzero_si128() );    /* Ahi = a_8[8:15]  Simulate 8bit integers as 16-bit integers */
@@ -191,72 +186,71 @@ static inline __m128i ssp_insert_epi8_SSE2( __m128i a, int b, const int ndx )
 
   /* Insert b as a 16-bit integer to upper or lower half of a */
   switch( ndx & 0xF ) {
-  case 0:
-    Alo.i = _mm_insert_epi16( Alo.i, b, 0 );
-    break;
+    case 0:
+      Alo.i = _mm_insert_epi16( Alo.i, b, 0 );
+      break;
 
-  case 1:
-    Alo.i = _mm_insert_epi16( Alo.i, b, 1 );
-    break;
+    case 1:
+      Alo.i = _mm_insert_epi16( Alo.i, b, 1 );
+      break;
 
-  case 2:
-    Alo.i = _mm_insert_epi16( Alo.i, b, 2 );
-    break;
+    case 2:
+      Alo.i = _mm_insert_epi16( Alo.i, b, 2 );
+      break;
 
-  case 3:
-    Alo.i = _mm_insert_epi16( Alo.i, b, 3 );
-    break;
+    case 3:
+      Alo.i = _mm_insert_epi16( Alo.i, b, 3 );
+      break;
 
-  case 4:
-    Alo.i = _mm_insert_epi16( Alo.i, b, 4 );
-    break;
+    case 4:
+      Alo.i = _mm_insert_epi16( Alo.i, b, 4 );
+      break;
 
-  case 5:
-    Alo.i = _mm_insert_epi16( Alo.i, b, 5 );
-    break;
+    case 5:
+      Alo.i = _mm_insert_epi16( Alo.i, b, 5 );
+      break;
 
-  case 6:
-    Alo.i = _mm_insert_epi16( Alo.i, b, 6 );
-    break;
+    case 6:
+      Alo.i = _mm_insert_epi16( Alo.i, b, 6 );
+      break;
 
-  case 7:
-    Alo.i = _mm_insert_epi16( Alo.i, b, 7 );
-    break;
+    case 7:
+      Alo.i = _mm_insert_epi16( Alo.i, b, 7 );
+      break;
 
-  case 8:
-    Ahi.i = _mm_insert_epi16( Ahi.i, b, 0 );
-    break;
+    case 8:
+      Ahi.i = _mm_insert_epi16( Ahi.i, b, 0 );
+      break;
 
-  case 9:
-    Ahi.i = _mm_insert_epi16( Ahi.i, b, 1 );
-    break;
+    case 9:
+      Ahi.i = _mm_insert_epi16( Ahi.i, b, 1 );
+      break;
 
-  case 10:
-    Ahi.i = _mm_insert_epi16( Ahi.i, b, 2 );
-    break;
+    case 10:
+      Ahi.i = _mm_insert_epi16( Ahi.i, b, 2 );
+      break;
 
-  case 11:
-    Ahi.i = _mm_insert_epi16( Ahi.i, b, 3 );
-    break;
+    case 11:
+      Ahi.i = _mm_insert_epi16( Ahi.i, b, 3 );
+      break;
 
-  case 12:
-    Ahi.i = _mm_insert_epi16( Ahi.i, b, 4 );
-    break;
+    case 12:
+      Ahi.i = _mm_insert_epi16( Ahi.i, b, 4 );
+      break;
 
-  case 13:
-    Ahi.i = _mm_insert_epi16( Ahi.i, b, 5 );
-    break;
+    case 13:
+      Ahi.i = _mm_insert_epi16( Ahi.i, b, 5 );
+      break;
 
-  case 14:
-    Ahi.i = _mm_insert_epi16( Ahi.i, b, 6 );
-    break;
+    case 14:
+      Ahi.i = _mm_insert_epi16( Ahi.i, b, 6 );
+      break;
 
-  default:
-    Ahi.i = _mm_insert_epi16( Ahi.i, b, 7 );
+    default:
+      Ahi.i = _mm_insert_epi16( Ahi.i, b, 7 );
   }
 
   return _mm_packus_epi16( Alo.i, Ahi.i ); // Pack the 16-bit integers to 8bit again.
-
   ///* Another implementation, but slower: */
   //ssp_m128 A, B, mask;
   //mask.i = _mm_setzero_si128();
@@ -277,16 +271,13 @@ static inline __m128i ssp_insert_epi8_SSE2( __m128i a, int b, const int ndx )
  * \date 2006-2008
  * \copyright Apache License 2.0
  */
-static inline __m128i ssp_cvtepi8_epi16_SSE2 ( __m128i a)
-{
+static inline __m128i ssp_cvtepi8_epi16_SSE2 ( __m128i a) {
   __m128i b = _mm_setzero_si128 ();
   __m128i c = _mm_unpacklo_epi8(a, b);
   __m128i d = _mm_set1_epi16 (128);
-
   b = _mm_and_si128(d, c);
   d = _mm_set1_epi16(0x1FE);
   b = _mm_mullo_epi16(b, d);
-
   return _mm_add_epi16(c, b);
 }
 
@@ -299,8 +290,7 @@ static inline __m128i ssp_cvtepi8_epi16_SSE2 ( __m128i a)
  * \date 2006-2008
  * \copyright Apache License 2.0
  */
-static inline __m128i ssp_logical_bitwise_select_SSE2( __m128i a, __m128i b, __m128i mask )   // Bitwise (mask ? a : b)
-{
+static inline __m128i ssp_logical_bitwise_select_SSE2( __m128i a, __m128i b, __m128i mask ) { // Bitwise (mask ? a : b)
   a = _mm_and_si128   ( a,    mask );                                 // clear a where mask = 0
   b = _mm_andnot_si128( mask, b    );                                 // clear b where mask = 1
   a = _mm_or_si128    ( a,    b    );                                 // a = a OR b
@@ -316,8 +306,7 @@ static inline __m128i ssp_logical_bitwise_select_SSE2( __m128i a, __m128i b, __m
  * \date 2006-2008
  * \copyright Apache License 2.0
  */
-static inline __m128i ssp_max_epi8_SSE2( __m128i a, __m128i b )
-{
+static inline __m128i ssp_max_epi8_SSE2( __m128i a, __m128i b ) {
   __m128i mask  = _mm_cmpgt_epi8( a, b );                             // FFFFFFFF where a > b
   a = ssp_logical_bitwise_select_SSE2( a, b, mask );
   return a;
@@ -332,15 +321,12 @@ static inline __m128i ssp_max_epi8_SSE2( __m128i a, __m128i b )
  * \date 2006-2008
  * \copyright Apache License 2.0
  */
-static inline __m128i ssp_cvtepi16_epi32_SSE2 ( __m128i a)
-{
+static inline __m128i ssp_cvtepi16_epi32_SSE2 ( __m128i a) {
   __m128i b = _mm_set1_epi32 (-1);         //0xFFFFFFFF
   __m128i c = _mm_unpacklo_epi16(a, b);    //FFFFa0**FFFFa1**....
   __m128i d = _mm_set1_epi32 (0x8000);     //0x8000
-
   b = _mm_andnot_si128(c, d);              // 0x80 for positive, 0x00 for negative
   d = _mm_slli_epi32(b, 1);                // 0x100 for positive, 0x000 for negative
-
   return _mm_add_epi32(c, d);
 }
 #endif // __SSE4_1__
@@ -350,5 +336,46 @@ static inline __m128i ssp_cvtepi16_epi32_SSE2 ( __m128i a)
 
 #endif // x86_64 || i386
 
-#endif // SSE_INTRIN_H
+#if defined(__x86_64__) || defined(__i386__)
+  #define vect128 __m128i
+#elif defined(__arm__)
+  #define vect128 int16x8_t
+#endif
+
+static const short minusConjug128[8]__attribute__((aligned(16))) = {-1,1,-1,1,-1,1,-1,1};
+static inline vect128 mulByConjugate128(vect128 *a, vect128 *b, int8_t output_shift) {
+
+#if defined(__x86_64__) || defined(__i386__)
+  vect128 realPart = _mm_madd_epi16(*a,*b);
+  realPart = _mm_srai_epi32(realPart,output_shift);
+  vect128 imagPart = _mm_shufflelo_epi16(*b,_MM_SHUFFLE(2,3,0,1));
+  imagPart = _mm_shufflehi_epi16(imagPart,_MM_SHUFFLE(2,3,0,1));
+  imagPart = _mm_sign_epi16(imagPart,*(vect128 *)minusConjug128);
+  imagPart = _mm_madd_epi16(imagPart,*a);
+  imagPart = _mm_srai_epi32(imagPart,output_shift);
+  vect128 lowPart = _mm_unpacklo_epi32(realPart,imagPart);
+  vect128 highPart = _mm_unpackhi_epi32(realPart,imagPart);
+  return ( _mm_packs_epi32(lowPart,highPart));
+#elif defined(__arm__)
+  AssertFatal(false, "not developped\n");
+#endif
+}
 
+#if defined(__x86_64__) || defined(__i386__)
+#define displaySamples128(vect)  {\
+    __m128i x=vect;                                       \
+    printf("vector: %s = (%hd,%hd) (%hd,%hd) (%hd,%hd) (%hd,%hd)\n", #vect, \
+           _mm_extract_epi16(x,0),                                  \
+           _mm_extract_epi16(x,1),\
+           _mm_extract_epi16(x,2),\
+           _mm_extract_epi16(x,3),\
+           _mm_extract_epi16(x,4),\
+           _mm_extract_epi16(x,5),\
+           _mm_extract_epi16(x,6),\
+           _mm_extract_epi16(x,7));\
+  }
+#elif defined(__arm__)
+  displaySamples128(vect) {}
+//TBD
+#endif
+#endif // SSE_INTRIN_H

openair1/SCHED_NR/phy_procedures_nr_common.c

@@ -36,4 +36,6 @@ nr_subframe_t nr_slot_select(nfapi_nr_config_request_t *cfg,unsigned char slot)
 {
   if (cfg->subframe_config.duplex_mode.value == FDD)
     return(SF_DL);
+  LOG_E(PHY,"Not developped TDD mode\n");
+  return -1;
 }

openair1/SCHED_NR_UE/phy_procedures_nr_ue.c

@@ -1595,22 +1595,10 @@ void ue_ulsch_uespec_procedures(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8
   int harq_pid;
   int frame_tx=proc->frame_tx;
   int nr_tti_tx=proc->nr_tti_tx;
-  int Mod_id = ue->Mod_id;
-  int CC_id = ue->CC_id;
-  uint8_t Msg3_flag=0;
-  uint16_t first_rb, nb_rb;
   unsigned int input_buffer_length;
   int i;
   int aa;
   int tx_amp;
-  uint8_t ulsch_input_buffer[5477] __attribute__ ((aligned(32)));
-  uint8_t access_mode;
-  uint8_t Nbundled=0;
-  uint8_t NbundledCw1=0;
-  uint8_t ack_status_cw0=0;
-  uint8_t ack_status_cw1=0;
-  uint8_t cqi_status = 0;
-  uint8_t ri_status  = 0;
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_UE_TX_ULSCH_UESPEC,VCD_FUNCTION_IN);
 
   /* reset harq for tx of current rx slot because it is sure that transmission has already been achieved for this slot */
@@ -1621,6 +1609,18 @@ void ue_ulsch_uespec_procedures(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8
 
 #if 0
 
+  int Mod_id = ue->Mod_id;
+  int CC_id = ue->CC_id;
+  uint8_t Msg3_flag=0;
+  uint16_t first_rb, nb_rb;
+  uint8_t ulsch_input_buffer[5477] __attribute__ ((aligned(32)));
+  uint8_t access_mode;
+  uint8_t Nbundled=0;
+  uint8_t NbundledCw1=0;
+  uint8_t ack_status_cw0=0;
+  uint8_t ack_status_cw1=0;
+  uint8_t cqi_status = 0;
+  uint8_t ri_status  = 0;
   if (ue->mac_enabled == 1) {
     if ((ue->ulsch_Msg3_active[eNB_id] == 1) &&
 	(ue->ulsch_Msg3_frame[eNB_id] == frame_tx) &&
@@ -3081,7 +3081,7 @@ int nr_ue_pdcch_procedures(uint8_t eNB_id,PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *
   pdcch_vars[eNB_id]->crnti = 0x1234; //to be check how to set when using loop memory
 
   uint16_t c_rnti=pdcch_vars[eNB_id]->crnti;
-  uint16_t cs_rnti,new_rnti,tc_rnti;
+  uint16_t cs_rnti=0,new_rnti=0,tc_rnti;
   uint16_t p_rnti=P_RNTI;
   uint16_t si_rnti=SI_RNTI;
   uint16_t ra_rnti=99;
@@ -3354,7 +3354,7 @@ int nr_ue_pdcch_procedures(uint8_t eNB_id,PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *
       } // end for loop dci_cnt
 
     //  TODO: check where should we send up this message.
-    ue->if_inst->dl_indication(&ue->dl_indication);
+    //ue->if_inst->dl_indication(&ue->dl_indication);
 
 
 #if UE_TIMING_TRACE

openair1/SCHED_NR_UE/pucch_power_control_ue_nr.c

@@ -32,6 +32,7 @@
 #include "PHY/defs_nr_UE.h"
 #include "SCHED_NR_UE/pucch_uci_ue_nr.h"
 #include "SCHED_NR_UE/pucch_power_control_ue_nr.h"
+#include <openair1/PHY/LTE_ESTIMATION/lte_estimation.h>
 
 /**************** defines **************************************/
 

openair1/SCHED_NR_UE/pucch_uci_ue_nr.c

@@ -36,6 +36,8 @@
 
 #include "PHY/NR_REFSIG/ss_pbch_nr.h"
 #include "PHY/defs_nr_UE.h"
+#include <openair1/SCHED/sched_common.h>
+#include <openair1/PHY/NR_UE_TRANSPORT/pucch_nr.h>
 
 #ifndef NO_RAT_NR
 
@@ -278,7 +280,7 @@ bool pucch_procedures_ue_nr(PHY_VARS_NR_UE *ue, uint8_t gNB_id, UE_nr_rxtx_proc_
   /* Part - III */
   /* Choice PUCCH format and its related parameters */
   pucch_format_nr_t format = pucch_format0_nr;
-  uint8_t  starting_symbol_index;
+  uint8_t  starting_symbol_index=0;
   uint8_t nb_symbols_total = 0;
   uint8_t  nb_symbols = 0;
   uint16_t starting_prb = 0;;  /* it can be considered as first  hop on case of pucch hopping */
@@ -558,7 +560,7 @@ bool pucch_procedures_ue_nr(PHY_VARS_NR_UE *ue, uint8_t gNB_id, UE_nr_rxtx_proc_
     {
       nr_generate_pucch0(ue,ue->common_vars.txdataF,
                          &ue->frame_parms,
-                         &ue->pucch_config_dedicated_nr[gNB_id],
+                         &ue->pucch_config_dedicated[gNB_id],
                          tx_amp,
                          nr_tti_tx,
                          (uint8_t)m_0,
@@ -572,7 +574,7 @@ bool pucch_procedures_ue_nr(PHY_VARS_NR_UE *ue, uint8_t gNB_id, UE_nr_rxtx_proc_
     {
       nr_generate_pucch1(ue,ue->common_vars.txdataF,
                          &ue->frame_parms,
-                         &ue->pucch_config_dedicated_nr[gNB_id],
+                         &ue->pucch_config_dedicated[gNB_id],
                          pucch_payload,
                          tx_amp,
                          nr_tti_tx,
@@ -591,7 +593,7 @@ bool pucch_procedures_ue_nr(PHY_VARS_NR_UE *ue, uint8_t gNB_id, UE_nr_rxtx_proc_
                          ue->pdcch_vars[ue->current_thread_id[proc->nr_tti_rx]][gNB_id]->crnti,
                          ue->common_vars.txdataF,
                          &ue->frame_parms,
-                         &ue->pucch_config_dedicated_nr[gNB_id],
+                         &ue->pucch_config_dedicated[gNB_id],
                          pucch_payload,
                          tx_amp,
                          nr_tti_tx,
@@ -610,7 +612,7 @@ bool pucch_procedures_ue_nr(PHY_VARS_NR_UE *ue, uint8_t gNB_id, UE_nr_rxtx_proc_
                            ue->common_vars.txdataF,
                            &ue->frame_parms,
                            format,
-                           &ue->pucch_config_dedicated_nr[gNB_id],
+                           &ue->pucch_config_dedicated[gNB_id],
                            pucch_payload,
                            tx_amp,
                            nr_tti_tx,
@@ -729,7 +731,7 @@ uint8_t get_downlink_ack(PHY_VARS_NR_UE *ue, uint8_t gNB_id,  UE_nr_rxtx_proc_t
         }
       }
       if (do_reset == TRUE) {
-        init_downlink_harq_status(&ue->dlsch[ue->current_thread_id[proc->nr_tti_rx]][gNB_id][code_word]->harq_processes[dl_harq_pid]);
+        init_downlink_harq_status(ue->dlsch[ue->current_thread_id[proc->nr_tti_rx]][gNB_id][code_word]->harq_processes[dl_harq_pid]);
       }
     }
   }

openair1/SCHED_UE/phy_procedures_lte_ue.c

@@ -322,10 +322,10 @@ void ra_failed(uint8_t Mod_id,uint8_t CC_id,uint8_t eNB_index)
 
   // if contention resolution fails, go back to PRACH
   PHY_vars_UE_g[Mod_id][CC_id]->UE_mode[eNB_index] = PRACH;
-  PHY_vars_UE_g[Mod_id][CC_id]->pdcch_vars[0][eNB_index]->crnti_is_temporary = 0;
-  PHY_vars_UE_g[Mod_id][CC_id]->pdcch_vars[0][eNB_index]->crnti = 0;
-  PHY_vars_UE_g[Mod_id][CC_id]->pdcch_vars[1][eNB_index]->crnti_is_temporary = 0;
-  PHY_vars_UE_g[Mod_id][CC_id]->pdcch_vars[1][eNB_index]->crnti = 0;
+  for (int i=0; i <RX_NB_TH_MAX; i++ ) {
+    PHY_vars_UE_g[Mod_id][CC_id]->pdcch_vars[i][eNB_index]->crnti_is_temporary = 0;
+    PHY_vars_UE_g[Mod_id][CC_id]->pdcch_vars[i][eNB_index]->crnti = 0;
+  }
   LOG_E(PHY,"[UE %d] Random-access procedure fails, going back to PRACH, setting SIStatus = 0, discard temporary C-RNTI and State RRC_IDLE\n",Mod_id);
 }
 
@@ -336,16 +336,18 @@ void ra_succeeded(uint8_t Mod_id,uint8_t CC_id,uint8_t eNB_index)
 
   LOG_I(PHY,"[UE %d][RAPROC] Random-access procedure succeeded. Set C-RNTI = Temporary C-RNTI\n",Mod_id);
 
-  PHY_vars_UE_g[Mod_id][CC_id]->pdcch_vars[0][eNB_index]->crnti_is_temporary = 0;
-  PHY_vars_UE_g[Mod_id][CC_id]->pdcch_vars[1][eNB_index]->crnti_is_temporary = 0;
+  for (int i=0; i <RX_NB_TH_MAX; i++ ) {
+    PHY_vars_UE_g[Mod_id][CC_id]->pdcch_vars[i][eNB_index]->crnti_is_temporary = 0;
+  }
   PHY_vars_UE_g[Mod_id][CC_id]->ulsch_Msg3_active[eNB_index] = 0;
   PHY_vars_UE_g[Mod_id][CC_id]->UE_mode[eNB_index] = PUSCH;
 
   for (i=0; i<8; i++) {
     if (PHY_vars_UE_g[Mod_id][CC_id]->ulsch[eNB_index]->harq_processes[i]) {
       PHY_vars_UE_g[Mod_id][CC_id]->ulsch[eNB_index]->harq_processes[i]->status=SCH_IDLE;
-      PHY_vars_UE_g[Mod_id][CC_id]->dlsch[0][eNB_index][0]->harq_processes[i]->round=0;
-      PHY_vars_UE_g[Mod_id][CC_id]->dlsch[1][eNB_index][0]->harq_processes[i]->round=0;
+      for (int i=0; i <RX_NB_TH_MAX; i++ ) {
+        PHY_vars_UE_g[Mod_id][CC_id]->dlsch[i][eNB_index][0]->harq_processes[i]->round=0;
+      }
       PHY_vars_UE_g[Mod_id][CC_id]->ulsch[eNB_index]->harq_processes[i]->subframe_scheduling_flag=0;
     }
   }
@@ -2885,10 +2887,10 @@ int ue_pdcch_procedures(uint8_t eNB_id,PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint
 	      {
                 ue->dlsch[th_id][eNB_id][0]->g_pucch += delta_pucch;
 	      }
-            LOG_D(PHY,"update TPC for PUCCH %d.%d / pid %d delta_PUCCH %d g_pucch %d %d \n",frame_rx, subframe_rx,ue->dlsch[ue->current_thread_id[subframe_rx]][eNB_id][0]->current_harq_pid,
+            LOG_D(PHY,"update TPC for PUCCH %d.%d / pid %d delta_PUCCH %d g_pucch %d\n",
+			    frame_rx, subframe_rx,ue->dlsch[ue->current_thread_id[subframe_rx]][eNB_id][0]->current_harq_pid,
 		  delta_pucch,
-		  ue->dlsch[0][eNB_id][0]->g_pucch,
-		  ue->dlsch[1][eNB_id][0]->g_pucch
+		  ue->dlsch[0][eNB_id][0]->g_pucch
 		  //ue->dlsch[2][eNB_id][0]->g_pucch
 		  );
           }

openair2/LAYER2/NR_MAC_UE/mac.h

@@ -65,7 +65,7 @@ typedef struct {
 } __attribute__ ((__packed__)) NR_MAC_SUBHEADER_LONG;
 
 typedef struct {
-    uint8_t LCID:5;     // octet 1 [5:0]
+    uint8_t LCID:6;     // octet 1 [5:0]
     uint8_t R:2;        // octet 1 [7:6]
 } __attribute__ ((__packed__)) NR_MAC_SUBHEADER_FIXED;
 

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler.c

@@ -58,6 +58,7 @@
 #endif
 
 #include "assertions.h"
+#include <openair1/PHY/LTE_TRANSPORT/transport_proto.h>
 
 #define ENABLE_MAC_PAYLOAD_DEBUG
 #define DEBUG_eNB_SCHEDULER 1
@@ -392,7 +393,7 @@ void gNB_dlsch_ulsch_scheduler(module_id_t module_idP,
           }
 
           for (int ii=0; ii<MAX_MOBILES_PER_GNB; ii++) {
-            LTE_eNB_DLSCH_t *dlsch = RC.gNB[module_idP][CC_id]->dlsch[ii][0];
+            NR_gNB_DLSCH_t *dlsch = RC.gNB[module_idP][CC_id]->dlsch[ii][0];
             if((dlsch != NULL) && (dlsch->rnti == rnti)){
               LOG_I(MAC, "clean_eNb_dlsch UE %x \n", rnti);
               clean_eNb_dlsch(dlsch);

openair2/NR_UE_PHY_INTERFACE/NR_IF_Module.c

@@ -74,7 +74,7 @@ int8_t handle_dlsch (module_id_t module_id, int cc_id, uint8_t gNB_index, fapi_n
   return nr_ue_process_dlsch( module_id,
 			      cc_id,
 			      gNB_index,
-			      &dci_ind,
+			      dci_ind,
 			      pduP,
 			      pdu_len);
 
@@ -308,4 +308,5 @@ int nr_ue_dcireq(nr_dcireq_t *dcireq) {
   dl_config->dl_config_list[0].dci_config_pdu.dci_config_rel15.N_RB_BWP = 106;
 
   
+  return 0;
 }

targets/ARCH/COMMON/common_lib.c

@@ -34,40 +34,42 @@
 #include <dlfcn.h>
 #include <errno.h>
 #include <string.h>
+#include <stdlib.h>
 
 #include "common_lib.h"
 #include "common/utils/load_module_shlib.h"
+#include <common/utils/LOG/log.h>
 
 int set_device(openair0_device *device) {
 
   switch (device->type) {
     
   case EXMIMO_DEV:
-    printf("[%s] has loaded EXPRESS MIMO device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU"));
+    LOG_I(HW,"[%s] has loaded EXPRESS MIMO device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU"));
     break;
   case USRP_B200_DEV:
-    printf("[%s] has loaded USRP B200 device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU")); 
+    LOG_I(HW,"[%s] has loaded USRP B200 device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU")); 
     break;
-case USRP_X300_DEV:
-    printf("[%s] has loaded USRP X300 device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU")); 
+  case USRP_X300_DEV:
+    LOG_I(HW,"[%s] has loaded USRP X300 device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU")); 
     break;
   case BLADERF_DEV:
-    printf("[%s] has loaded BLADERF device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU")); 
+    LOG_I(HW,"[%s] has loaded BLADERF device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU")); 
     break;
   case LMSSDR_DEV:
-    printf("[%s] has loaded LMSSDR device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU")); 
+    LOG_I(HW,"[%s] has loaded LMSSDR device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU")); 
     break;
   case NONE_DEV:
-    printf("[%s] has not loaded a HW device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU"));
+    LOG_W(HW,"[%s] has not loaded a HW device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU"));
     break;    
   case ADRV9371_ZC706_DEV:
-    printf("[%s] has loaded ADRV9371_ZC706 device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU"));
+    LOG_I(HW,"[%s] has loaded ADRV9371_ZC706 device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU"));
     break;
   case UEDv2_DEV:
-    printf("[%s] has loaded UEDv2 device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU"));
+    LOG_I(HW,"[%s] has loaded UEDv2 device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU"));
     break;
   default:
-    printf("[%s] invalid HW device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU")); 
+    LOG_E(HW,"[%s] invalid HW device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU")); 
     return -1;
   }
   return 0;
@@ -78,15 +80,15 @@ int set_transport(openair0_device *device) {
   switch (device->transp_type) {
     
   case ETHERNET_TP:
-    printf("[%s] has loaded ETHERNET trasport protocol.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU"));
+    LOG_I(HW,"[%s] has loaded ETHERNET trasport protocol.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU"));
     return 0;     
     break;
   case NONE_TP:
-    printf("[%s] has not loaded a transport protocol.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU"));
+    LOG_W(HW,"[%s] has not loaded a transport protocol.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU"));
     return 0; 
     break;    
   default:
-    printf("[%s] invalid transport protocol.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU")); 
+    LOG_E(HW,"[%s] invalid transport protocol.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU")); 
     return -1;
     break;
   }
@@ -100,6 +102,9 @@ int load_lib(openair0_device *device, openair0_config_t *openair0_cfg, eth_param
   int ret=0;
   char *libname;
   if (flag == RAU_LOCAL_RADIO_HEAD) {
+	  if (getenv("RFSIMULATOR") != NULL) 
+     	  libname="rfsimulator";
+	  else 
       libname=OAI_RF_LIBNAME;
       shlib_fdesc[0].fname="device_init";
     } else {
@@ -108,7 +113,7 @@ int load_lib(openair0_device *device, openair0_config_t *openair0_cfg, eth_param
     } 
   ret=load_module_shlib(libname,shlib_fdesc,1,NULL);
   if (ret < 0) {
-       fprintf(stderr,"Library %s couldn't be loaded\n",libname);
+       LOG_E(HW,"Library %s couldn't be loaded\n",libname);
   } else {
        ret=((devfunc_t)shlib_fdesc[0].fptr)(device,openair0_cfg,cfg);
   }    
@@ -124,7 +129,7 @@ int openair0_device_load(openair0_device *device, openair0_config_t *openair0_cf
 
   if ( rc >= 0) {       
 	if ( set_device(device) < 0) {
-      fprintf(stderr, "%s %d:Unsupported radio head\n",__FILE__, __LINE__);
+      LOG_E(HW,"Unsupported radio head\n");
       return -1;		   
     }   
   }
@@ -136,7 +141,7 @@ int openair0_transport_load(openair0_device *device, openair0_config_t *openair0
   rc=load_lib(device, openair0_cfg, eth_params, RAU_REMOTE_RADIO_HEAD);
   if ( rc >= 0) {       
     if ( set_transport(device) < 0) {
-      fprintf(stderr, "%s %d:Unsupported transport protocol\n",__FILE__, __LINE__);
+      LOG_E(HW,"Unsupported transport protocol\n");
       return -1;		   
       }   
   }

targets/ARCH/rfsimulator/README.md

+#General
+This is a RF simulator that allows to test OAI without a RF board.
+It replaces a actual RF board driver.
+
+As much as possible, it works like a RF board, but not in realtime: it can run faster than realtime if there is enough CPU or slower (it is CPU bound instead of real time RF sampling bound)
+
+#build
+
+## From build_oai
+You can build it the same way, and together with actual RF driver
+
+Example:
+```bash
+./build_oai --ue-nas-use-tun --UE --eNB -w SIMU
+```
+It is also possible to build actual RF and use choose on each run:
+```bash
+./build_oai --ue-nas-use-tun --UE --eNB -w USRP --rfsimulator
+```
+Will build both the eNB (lte-softmodem) and the UE (lte-uesoftmodem)
+We recommend to use the option --ue-nas-use-tun that is much simpler to use than the OAI kernel driver.
+
+## Add the rfsimulator after initial build
+After any regular build, you can compile the driver
+```bash
+cd <the_compilation_dir_from_bouild_oai_script>/build
+make rfsimulator
+```
+Then, you can use it freely
+
+# Usage
+Setting the env variable RFSIMULATOR enables the RF board simulator
+It should the set to "enb" in the eNB
+
+## 4G case
+For the UE, it should be set to the IP address of the eNB
+example: 
+```bash
+sudo RFSIMULATOR=192.168.2.200 ./lte-uesoftmodem -C 2685000000 -r 50 
+```
+Except this, the UE and the eNB can be used as it the RF is real
+
+If you reach 'RA not active' on UE, be careful to generate a valid SIM
+```bash
+$OPENAIR_DIR/targets/bin/conf2uedata -c $OPENAIR_DIR/openair3/NAS/TOOLS/ue_eurecom_test_sfr.conf -o .
+```
+## 5G case
+After regular build, add the simulation driver
+(don't use ./build_oai -w SIMU until we merge 4G and 5G branches)
+```bash
+cd ran_build/build
+make rfsimulator
+```
+### Launch gNB in one window
+```bash
+sudo RFSIMULATOR=enb ./nr-softmodem -O ../../../targets/PROJECTS/GENERIC-LTE-EPC/CONF/gnb.band78.tm1.106PRB.usrpn300.conf --parallel-config PARALLEL_SINGLE_THREAD
+```
+### Launch UE in another window
+```bash
+sudo RFSIMULATOR=127.0.0.1 ./nr-uesoftmodem --numerology 1 -r 106 -C 3510000000 
+```
+Of course, set the gNB machine IP address if the UE and the gNB are not on the same machine
+In UE, you can add "-d" to get the softscope
+
+#Caveacts
+Still issues in power control: txgain, rxgain are not used
+
+no S1 mode is currently broken, so we were not able to test the simulator in noS1 mode

targets/RT/USER/nr-softmodem.c

@@ -429,9 +429,12 @@ static void *scope_thread(void *arg) {
       for(UE_id=0; UE_id<NUMBER_OF_UE_MAX; UE_id++) {
 	for(CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
 	  if ((ue_cnt<scope_enb_num_ue)) {
-	    phy_scope_eNB(form_enb[CC_id][ue_cnt],
+	    /* 
+	    //this function needs to be written
+	    phy_scope_gNB(form_enb[CC_id][ue_cnt],
 			          RC.gNB[0][CC_id],
 					  UE_id);
+	    */
 	    ue_cnt++;
 	  }
 	}

targets/RT/USER/nr-ue.c

@@ -628,7 +628,6 @@ static void *UE_thread_rxn_txnp4(void *arg) {
     struct nr_rxtx_thread_data *rtd = arg;
     UE_nr_rxtx_proc_t *proc = rtd->proc;
     PHY_VARS_NR_UE    *UE   = rtd->UE;
-    int ret;
 
     //proc->counter_decoder = 0;
     proc->instance_cnt_rxtx=-1;
@@ -781,16 +780,14 @@ void *UE_thread(void *arg) {
 
     PHY_VARS_NR_UE *UE = (PHY_VARS_NR_UE *) arg;
     //  int tx_enabled = 0;
-    int dummy_rx[UE->frame_parms.nb_antennas_rx][UE->frame_parms.samples_per_subframe] __attribute__((aligned(32)));
     openair0_timestamp timestamp;
     void* rxp[NB_ANTENNAS_RX], *txp[NB_ANTENNAS_TX];
     int start_rx_stream = 0;
     int i;
     char threadname[128];
     int th_id;
-    UE->proc.proc_rxtx[0].counter_decoder = 0;
-    UE->proc.proc_rxtx[1].counter_decoder = 0;
-    UE->proc.proc_rxtx[2].counter_decoder = 0;
+    for (int i=0; i<  RX_NB_TH_MAX; i++ ) 
+       UE->proc.proc_rxtx[i].counter_decoder = 0;
 
     static uint8_t thread_idx = 0;
     uint16_t table_sf_slot[20] = {0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9};
@@ -833,48 +830,54 @@ void *UE_thread(void *arg) {
 	    usleep(500*1000);
 	  }
 #endif
-
+	  LOG_W(PHY,"is_synchro %d\n" ,  is_synchronized );
             if (instance_cnt_synch < 0) {  // we can invoke the synch
                 // grab 10 ms of signal and wakeup synch thread
-                for (int i=0; i<UE->frame_parms.nb_antennas_rx; i++)
-                    rxp[i] = (void*)&UE->common_vars.rxdata[i][0];
-
-                if (UE->mode != loop_through_memory)
-                    AssertFatal( UE->frame_parms.samples_per_subframe*10==
-                                 UE->rfdevice.trx_read_func(&UE->rfdevice,
-                                                            &timestamp,
-                                                            rxp,
-                                                            UE->frame_parms.samples_per_subframe*10,
-                                                            UE->frame_parms.nb_antennas_rx), "error reading samples");
-
-		AssertFatal ( 0== pthread_mutex_lock(&UE->proc.mutex_synch), "");
-                instance_cnt_synch = ++UE->proc.instance_cnt_synch;
-                if (instance_cnt_synch == 0) {
-                    AssertFatal( 0 == pthread_cond_signal(&UE->proc.cond_synch), "");
-                } else {
-                    LOG_E( PHY, "[SCHED][UE] UE sync thread busy!!\n" );
-                    exit_fun("nothing to add");
-                }
-		AssertFatal ( 0== pthread_mutex_unlock(&UE->proc.mutex_synch), "");
-            } else {
-#if OAISIM
-              (void)dummy_rx; /* avoid gcc warnings */
-              usleep(500);
-#else
-                // grab 10 ms of signal into dummy buffer
-                if (UE->mode != loop_through_memory) {
-                    for (int i=0; i<UE->frame_parms.nb_antennas_rx; i++)
-                        rxp[i] = (void*)&dummy_rx[i][0];
-                    for (int sf=0; sf<NR_NUMBER_OF_SUBFRAMES_PER_FRAME; sf++)
-                        //	    printf("Reading dummy sf %d\n",sf);
-		      AssertFatal(UE->frame_parms.samples_per_subframe==
-				 UE->rfdevice.trx_read_func(&UE->rfdevice,
-							    &timestamp,
-							    rxp,
-							    UE->frame_parms.samples_per_subframe,
-							    UE->frame_parms.nb_antennas_rx), "error reading samples");
-                }
-#endif
+	if (UE->mode != loop_through_memory) {
+	  void *dummy_tx[UE->frame_parms.nb_antennas_tx];
+	  for (int i=0; i<UE->frame_parms.nb_antennas_tx; i++)
+	    dummy_tx[i]=malloc16_clear(UE->frame_parms.samples_per_subframe*4);
+	  for(int x=0; x<10; x++) {
+	    for (int i=0; i<UE->frame_parms.nb_antennas_rx; i++)
+	      rxp[i] = ((void*)&UE->common_vars.rxdata[i][0]) + 4*x*UE->frame_parms.samples_per_subframe;
+	    AssertFatal( UE->frame_parms.samples_per_subframe ==
+			 UE->rfdevice.trx_read_func(&UE->rfdevice,
+						    &timestamp,
+						    rxp,
+						    UE->frame_parms.samples_per_subframe,
+						    UE->frame_parms.nb_antennas_rx), "");
+	  }
+	  for (int i=0; i<UE->frame_parms.nb_antennas_tx; i++)
+	    free(dummy_tx[i]);
+	}
+	AssertFatal( 0 == pthread_mutex_lock(&UE->proc.mutex_synch), "");
+	AssertFatal( 0 == ++UE->proc.instance_cnt_synch, "[SCHED][UE] UE sync thread busy!!\n" );
+        AssertFatal( 0 == pthread_cond_signal(&UE->proc.cond_synch), "");
+	AssertFatal( 0 == pthread_mutex_unlock(&UE->proc.mutex_synch), "");
+      } else {
+	// grab 10 ms of signal into dummy buffer to wait result of sync detection
+	if (UE->mode != loop_through_memory) {
+	  void *dummy_tx[UE->frame_parms.nb_antennas_tx];
+	  for (int i=0; i<UE->frame_parms.nb_antennas_tx; i++)
+	    dummy_tx[i]=malloc16_clear(UE->frame_parms.samples_per_subframe*4);
+	  void *dummy_rx[UE->frame_parms.nb_antennas_rx];
+	  for (int i=0; i<UE->frame_parms.nb_antennas_rx; i++)
+	    dummy_rx[i]=malloc16(UE->frame_parms.samples_per_subframe*4);
+	  for (int sf=0; sf<NR_NUMBER_OF_SUBFRAMES_PER_FRAME; sf++) {
+	    //	    printf("Reading dummy sf %d\n",sf);
+	    UE->rfdevice.trx_read_func(&UE->rfdevice,
+				       &timestamp,
+				       dummy_rx,
+				       UE->frame_parms.samples_per_subframe,
+				       UE->frame_parms.nb_antennas_rx);
+	   usleep(500); // this sleep improves in the case of simulated RF and doesn't harm with true radio
+	  
+	  }
+	  for (int i=0; i<UE->frame_parms.nb_antennas_tx; i++)
+	    free(dummy_tx[i]);
+	  for (int i=0; i<UE->frame_parms.nb_antennas_rx; i++)
+	    free(dummy_rx[i]);
+	}
             }
 
         } // UE->is_synchronized==0
@@ -884,12 +887,20 @@ void *UE_thread(void *arg) {
                 if (UE->mode != loop_through_memory) {
                     if (UE->no_timing_correction==0) {
                         LOG_I(PHY,"Resynchronizing RX by %d samples (mode = %d)\n",UE->rx_offset,UE->mode);
-                        AssertFatal(UE->rx_offset ==
-                                    UE->rfdevice.trx_read_func(&UE->rfdevice,
-                                                               &timestamp,
-                                                               (void**)UE->common_vars.rxdata,
-                                                               UE->rx_offset,
-                                                               UE->frame_parms.nb_antennas_rx),"");
+		    void *dummy_tx[UE->frame_parms.nb_antennas_tx];
+		    for (int i=0; i<UE->frame_parms.nb_antennas_tx; i++)
+		      dummy_tx[i]=malloc16_clear(UE->frame_parms.samples_per_subframe*4);
+		    for ( int size=UE->rx_offset ; size > 0 ; size -= UE->frame_parms.samples_per_subframe ) { 
+		      int unitTransfer=size>UE->frame_parms.samples_per_subframe ? UE->frame_parms.samples_per_subframe : size ;
+		      AssertFatal(unitTransfer ==
+				  UE->rfdevice.trx_read_func(&UE->rfdevice,
+							     &timestamp,
+							     (void**)UE->common_vars.rxdata,
+							     unitTransfer,
+							     UE->frame_parms.nb_antennas_rx),"");
+		    }
+		    for (int i=0; i<UE->frame_parms.nb_antennas_tx; i++)
+		      free(dummy_tx[i]);
                     }
                     UE->rx_offset=0;
                     UE->time_sync_cell=0;
@@ -965,7 +976,13 @@ void *UE_thread(void *arg) {
                                 UE->rx_offset < 10*UE->frame_parms.samples_per_slot )
                             UE->rx_offset_diff = 1;
 
-                        LOG_D(PHY,"AbsSubframe %d.%d TTI SET rx_off_diff to %d rx_offset %d \n",proc->frame_rx,slot_nr,UE->rx_offset_diff,UE->rx_offset);
+
+		        
+                        if ( getenv("RFSIMULATOR") != 0) {
+                           LOG_E(PHY,"AbsSubframe %d.%d TTI SET rx_off_diff to %d rx_offset %d \n",
+                           proc->frame_rx,slot_nr,UE->rx_offset_diff,UE->rx_offset);
+			   //UE->rx_offset_diff=0;	
+                        }
                         readBlockSize=UE->frame_parms.samples_per_slot -
                                       UE->frame_parms.ofdm_symbol_size -
                                       UE->frame_parms.nb_prefix_samples0 -
@@ -1055,6 +1072,14 @@ void *UE_thread(void *arg) {
 #ifdef SAIF_ENABLED
 						g_ue_rx_thread_busy++;
 #endif
+	              if ( getenv("RFSIMULATOR") != NULL ) {
+		         do {
+			    AssertFatal (pthread_mutex_unlock(&proc->mutex_rxtx) == 0, "");
+			    usleep(100);
+			    AssertFatal (pthread_mutex_lock(&proc->mutex_rxtx) == 0, "");
+			 } while ( proc->instance_cnt_rxtx >= 0);
+
+		      } else
                       LOG_E( PHY, "[SCHED][UE %d] !! UE RX thread busy (IC %d)!!\n", UE->Mod_id, proc->instance_cnt_rxtx);
                       if (proc->instance_cnt_rxtx > 4)
                       {

targets/RT/USER/nr-uesoftmodem.c

@@ -986,23 +986,16 @@ int main( int argc, char **argv ) {
     for (uint8_t i=0; i<RX_NB_TH_MAX; i++) {
       //UE[CC_id]->pdcch_vars[i][0]->agregationLevel = agregation_Level;
       //UE[CC_id]->pdcch_vars[i][0]->dciFormat     = dci_Format;
-    }
     
     /*compute_prach_seq(&UE[CC_id]->frame_parms.prach_config_common,
       UE[CC_id]->frame_parms.frame_type,
       UE[CC_id]->X_u);*/
     
     if (UE[CC_id]->mac_enabled == 1)
-      {
-	UE[CC_id]->pdcch_vars[0][0]->crnti = 0x1234;
-	UE[CC_id]->pdcch_vars[1][0]->crnti = 0x1234;
-      }
+	UE[CC_id]->pdcch_vars[i][0]->crnti = 0x1234;
     else
-      {
-	UE[CC_id]->pdcch_vars[0][0]->crnti = 0x1235;
-	UE[CC_id]->pdcch_vars[1][0]->crnti = 0x1235;
-      }
-    
+	UE[CC_id]->pdcch_vars[i][0]->crnti = 0x1235;
+    }
     
     UE[CC_id]->rx_total_gain_dB =  (int)rx_gain[CC_id][0] + rx_gain_off;
     UE[CC_id]->tx_power_max_dBm = tx_max_power[CC_id];