Merge branch '409-merge-ulschsim-containing-pusch-encoding-and-decoding' into 'develop-nr'

Resolve "Merge ulschsim containing PUSCH encoding and decoding"

See merge request oai/openairinterface5g!532

.gitignore

 cmake_targets/log/
-cmake_targets/ran_build/
+cmake_targets/*/build/
 targets/bin/
 

ci-scripts/oai-ci-vm-tool

@@ -252,9 +252,9 @@ case $key in
     VM_NAME=ci-phy-sim
     ARCHIVES_LOC=phy_sim
     LOG_PATTERN=.Rel15.txt
-    NB_PATTERN_FILES=8
+    NB_PATTERN_FILES=9
     BUILD_OPTIONS="--phy_simulators"
-    VM_MEMORY=4096
+    VM_MEMORY=8192
     RUN_OPTIONS="./run_exec_autotests.bash -g \"01510*\" -q -np -b"
     NBARGS=$[$NBARGS+256]
     shift
@@ -331,9 +331,9 @@ case $key in
         VM_NAME=ci-phy-sim
         ARCHIVES_LOC=phy_sim
         LOG_PATTERN=.Rel15.txt
-        NB_PATTERN_FILES=8
+        NB_PATTERN_FILES=9
         BUILD_OPTIONS="--phy_simulators"
-	VM_MEMORY=4096
+	VM_MEMORY=8192
         RUN_OPTIONS="./run_exec_autotests.bash -g \"01510*\" -q -np -b"
         NBARGS=$[$NBARGS+256]
         ;;

cmake_targets/CMakeLists.txt

@@ -671,7 +671,7 @@ add_boolean_option(EXMIMO_IOT              True "????")
 add_boolean_option(LOCALIZATION            False "???")
 add_integer_option(MAX_NUM_CCs             1     "????")
 add_boolean_option(MU_RECEIVER             False "????")
-add_boolean_option(PHYSIM                  True  "for L1 simulators (dlsim, ulsim, ...)")
+add_boolean_option(PHYSIM                  False  "for L1 simulators (dlsim, ulsim, ...)")
 add_boolean_option(PHY_CONTEXT             True "not clear: must remain False for dlsim")
 add_boolean_option(PHY_EMUL                False "not clear: must remain False for dlsim")
 add_boolean_option(SMBV                    False "Rohde&Schwarz SMBV100A vector signal generator")
@@ -1275,6 +1275,7 @@ set(PHY_SRC_UE
   ${OPENAIR1_DIR}/PHY/NR_TRANSPORT/nr_dlsch.c
   ${OPENAIR1_DIR}/PHY/NR_TRANSPORT/nr_dlsch_tools.c
   ${OPENAIR1_DIR}/PHY/NR_TRANSPORT/nr_dlsch_coding.c
+  ${OPENAIR1_DIR}/PHY/NR_TRANSPORT/nr_ulsch_decoding.c
   ${OPENAIR1_DIR}/PHY/NR_TRANSPORT/nr_tbs_tools.c
   ${OPENAIR1_DIR}/PHY/NR_TRANSPORT/nr_sch_dmrs.c
   ${OPENAIR1_DIR}/PHY/NR_REFSIG/nr_gold.c
@@ -1304,6 +1305,7 @@ set(PHY_SRC_UE
   ${OPENAIR1_DIR}/PHY/NR_UE_TRANSPORT/nr_initial_sync.c
   ${OPENAIR1_DIR}/PHY/NR_UE_TRANSPORT/nr_pbch.c
   ${OPENAIR1_DIR}/PHY/NR_UE_TRANSPORT/nr_dlsch_demodulation.c
+  ${OPENAIR1_DIR}/PHY/NR_UE_TRANSPORT/nr_ulsch_coding.c
   ${OPENAIR1_DIR}/PHY/NR_UE_TRANSPORT/nr_dlsch_decoding.c
   ${OPENAIR1_DIR}/PHY/NR_UE_TRANSPORT/nr_dlsch_llr_computation.c
   ${OPENAIR1_DIR}/PHY/NR_TRANSPORT/nr_tbs_tools.c
@@ -2526,6 +2528,12 @@ add_executable(nr_dlsim
   ${T_SOURCE})   
 target_link_libraries(nr_dlsim  -Wl,--start-group UTIL SIMU PHY_COMMON PHY_NR PHY_NR_UE SCHED_NR_LIB SCHED_NR_UE_LIB MAC_NR MAC_UE_NR MAC_NR_COMMON RRC_LIB NR_RRC_LIB CONFIG_LIB L2_NR -Wl,--end-group m pthread ${ATLAS_LIBRARIES} ${T_LIB} dl)
 
+add_executable(nr_ulschsim
+  ${OPENAIR1_DIR}/SIMULATION/NR_PHY/ulschsim.c
+  ${OPENAIR_DIR}/common/utils/backtrace.c
+  ${T_SOURCE})
+target_link_libraries(nr_ulschsim -Wl,--start-group UTIL SIMU PHY_COMMON PHY_NR PHY_NR_UE SCHED_NR_LIB CONFIG_LIB -Wl,--end-group m pthread ${ATLAS_LIBRARIES} ${T_LIB} dl)
+
 
 foreach(myExe dlsim dlsim_tm7 ulsim pbchsim scansim mbmssim pdcchsim pucchsim prachsim syncsim)
   

cmake_targets/build_oai

@@ -691,7 +691,7 @@ function main() {
     echo_info "Compiling unitary tests simulators"
     # TODO: fix: dlsim_tm4 pucchsim prachsim pdcchsim pbchsim mbmssim
     #simlist="dlsim_tm4 dlsim ulsim pucchsim prachsim pdcchsim pbchsim mbmssim"
-    simlist="dlsim ulsim polartest ldpctest nr_pbchsim nr_dlschsim nr_dlsim"
+    simlist="dlsim ulsim polartest ldpctest nr_pbchsim nr_dlschsim nr_dlsim nr_ulschsim"
     for f in $simlist ; do
       compilations \
       phy_simulators $f \

nfapi/open-nFAPI/nfapi/public_inc/nfapi_nr_interface.h

@@ -673,4 +673,45 @@ typedef struct {
   nfapi_vendor_extension_tlv_t vendor_extension;
 } nfapi_nr_dl_config_request_t;
 
+
+typedef enum {nr_pusch_freq_hopping_disabled = 0 , 
+              nr_pusch_freq_hopping_enabled = 1
+              } nr_pusch_freq_hopping_t;
+
+typedef struct{
+    uint8_t aperiodicSRS_ResourceTrigger;
+} nfapi_nr_ul_srs_config_t;
+
+typedef struct {
+    uint8_t bandwidth_part_ind;
+    uint16_t number_rbs;
+    uint16_t start_rb;
+    uint8_t frame_offset;
+    uint16_t number_symbols;
+    uint16_t start_symbol;
+    nr_pusch_freq_hopping_t pusch_freq_hopping;
+    uint8_t mcs;
+    uint8_t Qm;
+    uint8_t ndi;
+    uint8_t rv;
+    uint8_t harq_process_nbr;
+    int8_t accumulated_delta_PUSCH;
+    int8_t absolute_delta_PUSCH;
+    uint8_t n_layers;
+    uint8_t tpmi;
+    uint8_t n_dmrs_cdm_groups;
+    uint8_t dmrs_ports[4];
+    uint8_t n_front_load_symb;
+    nfapi_nr_ul_srs_config_t srs_config;
+    uint8_t csi_reportTriggerSize;
+    uint8_t maxCodeBlockGroupsPerTransportBlock;
+    uint8_t ptrs_dmrs_association_port;
+    uint8_t beta_offset_ind;
+} nfapi_nr_ul_config_ulsch_pdu_rel15_t;
+
+typedef struct {
+  uint16_t rnti;
+  nfapi_nr_ul_config_ulsch_pdu_rel15_t ulsch_pdu_rel15;
+} nfapi_nr_ul_config_ulsch_pdu;
+
 #endif

openair1/PHY/CODING/crc_byte.c

@@ -32,6 +32,7 @@
 
 
 #include "coding_defs.h"
+#include "assertions.h"
 
 /*ref 36-212 v8.6.0 , pp 8-9 */
 /* the highest degree is set by default */
@@ -275,7 +276,7 @@ int check_crc(uint8_t* decoded_bytes, uint32_t n, uint32_t F, uint8_t crc_type)
     break;
 
   default:
-    crc_len=3;
+    AssertFatal(1,"Invalid crc_type \n");
   }
 
   for (int i=0; i<crc_len; i++)
@@ -309,6 +310,9 @@ int check_crc(uint8_t* decoded_bytes, uint32_t n, uint32_t F, uint8_t crc_type)
       crc = crc8(decoded_bytes,
                  n-8)>>24;
       break;
+
+    default:
+      AssertFatal(1,"Invalid crc_type \n");
     }
 
     if (crc == oldcrc)

openair1/PHY/CODING/nr_segmentation.c

@@ -34,7 +34,7 @@ int32_t nr_segmentation(unsigned char *input_buffer,
                      unsigned int B,
                      unsigned int *C,
                      unsigned int *K,
-					 unsigned int *Zout,
+                     unsigned int *Zout, // [hna] Zout is Zc
                      unsigned int *F)
 {
 

openair1/PHY/INIT/nr_init.c

@@ -33,6 +33,7 @@
 #include "assertions.h"
 #include <math.h>
 
+#include "PHY/NR_TRANSPORT/nr_ulsch.h"
 #include "PHY/NR_REFSIG/nr_refsig.h"
 #include "PHY/LTE_REFSIG/lte_refsig.h"
 #include "SCHED_NR/fapi_nr_l1.h"
@@ -82,7 +83,9 @@ int phy_init_nr_gNB(PHY_VARS_gNB *gNB,
   LTE_eNB_PUSCH **const pusch_vars  = gNB->pusch_vars;
   LTE_eNB_SRS *const srs_vars       = gNB->srs_vars;
   LTE_eNB_PRACH *const prach_vars   = &gNB->prach_vars;
+
   int i, UE_id;
+
   LOG_I(PHY,"[gNB %d] %s() About to wait for gNB to be configured\n", gNB->Mod_id, __FUNCTION__);
   gNB->total_dlsch_bitrate = 0;
   gNB->total_transmitted_bits = 0;
@@ -110,7 +113,6 @@ int phy_init_nr_gNB(PHY_VARS_gNB *gNB,
   init_dfts();
   // PBCH DMRS gold sequences generation
   nr_init_pbch_dmrs(gNB);
-  // Polar encoder init for PBCH
   //PDCCH DMRS init
   gNB->nr_gold_pdcch_dmrs = (uint32_t ***)malloc16(fp->slots_per_frame*sizeof(uint32_t **));
   uint32_t ***pdcch_dmrs             = gNB->nr_gold_pdcch_dmrs;
@@ -148,6 +150,7 @@ int phy_init_nr_gNB(PHY_VARS_gNB *gNB,
   }
 
   nr_init_pdsch_dmrs(gNB, cfg->sch_config.physical_cell_id.value);
+
   /// Transport init necessary for NR synchro
   init_nr_transport(gNB);
 
@@ -167,11 +170,12 @@ int phy_init_nr_gNB(PHY_VARS_gNB *gNB,
   gNB->first_run_I0_measurements =
     1; ///This flag used to be static. With multiple gNBs this does no longer work, hence we put it in the structure. However it has to be initialized with 1, which is performed here.
   common_vars->rxdata  = (int32_t **)NULL;
-  common_vars->txdataF = (int32_t **)malloc16(15*sizeof(int32_t *));
-  common_vars->rxdataF = (int32_t **)malloc16(64*sizeof(int32_t *));
+  common_vars->txdataF = (int32_t **)malloc16(15*sizeof(int32_t*));
+  common_vars->rxdataF = (int32_t **)malloc16(64*sizeof(int32_t*));
+
+  for (i=0;i<15;i++){
+      common_vars->txdataF[i] = (int32_t*)malloc16_clear(fp->samples_per_frame_wCP*sizeof(int32_t) ); // [hna] samples_per_frame without CP
 
-  for (i=0; i<15; i++) {
-    common_vars->txdataF[i] = (int32_t *)malloc16_clear(fp->samples_per_frame_wCP*sizeof(int32_t) );
       LOG_D(PHY,"[INIT] common_vars->txdataF[%d] = %p (%lu bytes)\n",
             i,common_vars->txdataF[i],
             fp->samples_per_frame_wCP*sizeof(int32_t));
@@ -422,6 +426,7 @@ void nr_phy_config_request(NR_PHY_Config_t *phy_config) {
         gNB_config->rf_config.ul_carrier_bandwidth.value,
         gNB_config->sch_config.physical_cell_id.value,
         fp->dl_CarrierFreq );
+
   nr_init_frame_parms(gNB_config, fp);
 
   if (RC.gNB[Mod_id][CC_id]->configured == 1) {
@@ -441,6 +446,7 @@ void init_nr_transport(PHY_VARS_gNB *gNB) {
   LOG_I(PHY, "Initialise nr transport\n");
 
   for (i=0; i<NUMBER_OF_UE_MAX; i++) {
+
     LOG_I(PHY,"Allocating Transport Channel Buffers for DLSCH, UE %d\n",i);
 
     for (j=0; j<2; j++) {
@@ -450,29 +456,38 @@ void init_nr_transport(PHY_VARS_gNB *gNB) {
         LOG_E(PHY,"Can't get gNB dlsch structures for UE %d \n", i);
         exit(-1);
       }/* else {
-
         gNB->dlsch[i][j]->rnti=0;
         LOG_D(PHY,"dlsch[%d][%d] => %p rnti:%d\n",i,j,gNB->dlsch[i][j], gNB->dlsch[i][j]->rnti);
       }*/
+
+      ///////////////////////// Initializing gNB ULSCH /////////////////////////
+      LOG_I(PHY,"Allocating Transport Channel Buffer for ULSCH, UE %d\n",i);
+
+      // ULSCH for RA
+      if(i==0) {
+        gNB->ulsch[i][j] = new_gNB_ulsch(5, fp->N_RB_UL, 0);
+
+        if (!gNB->ulsch[i][j]) {
+          LOG_E(PHY,"Can't get gNB ulsch structures\n");
+          exit(-1);
+        }
       }
 
-    //LOG_I(PHY,"Allocating Transport Channel Buffer for ULSCH, UE %d\n",i);
-    //gNB->ulsch[1+i] = new_gNB_ulsch(MAX_TURBO_ITERATIONS,fp->N_RB_UL, 0);
-    /*if (!gNB->ulsch[1+i]) {
+      // ULSCH for data
+      gNB->ulsch[i+1][j] = new_gNB_ulsch(5, fp->N_RB_UL, 0);
+
+      if (!gNB->ulsch[i+1][j]) {
         LOG_E(PHY,"Can't get gNB ulsch structures\n");
         exit(-1);
-    }*/
+      }
+      //////////////////////////////////////////////////////////////////////////
+    }
+
     // this is the transmission mode for the signalling channels
     // this will be overwritten with the real transmission mode by the RRC once the UE is connected
     //gNB->transmission_mode[i] = fp->nb_antenna_ports_gNB==1 ? 1 : 2;
   }
 
-  // ULSCH for RA
-  //gNB->ulsch[0] = new_gNB_ulsch(MAX_TURBO_ITERATIONS, fp->N_RB_UL, 0);
-  /*if (!gNB->ulsch[0]) {
-    LOG_E(PHY,"Can't get gNB ulsch structures\n");
-    exit(-1);
-  }*/
   gNB->dlsch_SI  = new_gNB_dlsch(1,8,NSOFT, 0, fp, cfg);
   LOG_D(PHY,"gNB %d.%d : SI %p\n",gNB->Mod_id,gNB->CC_id,gNB->dlsch_SI);
   gNB->dlsch_ra  = new_gNB_dlsch(1,8,NSOFT, 0, fp, cfg);

openair1/PHY/INIT/nr_init_ue.c

@@ -361,8 +361,13 @@ void phy_config_harq_ue(module_id_t Mod_id,int CC_id,uint8_t eNB_id,
                         uint16_t max_harq_tx )
 {
 
+  int num_of_threads,num_of_code_words;
+
   PHY_VARS_NR_UE *phy_vars_ue = PHY_vars_UE_g[Mod_id][CC_id];
-  phy_vars_ue->ulsch[eNB_id]->Mlimit = max_harq_tx;
+
+  for (num_of_threads=0;num_of_threads<RX_NB_TH_MAX;num_of_threads++)
+    for (num_of_code_words=0;num_of_code_words<NR_MAX_NB_CODEWORDS;num_of_code_words++)
+      phy_vars_ue->ulsch[eNB_id][num_of_threads][num_of_code_words]->Mlimit = max_harq_tx;
 }
 
 extern uint16_t beta_cqi[16];
@@ -921,13 +926,13 @@ void init_nr_ue_transport(PHY_VARS_NR_UE *ue,int abstraction_flag) {
     for (j=0; j<2; j++) {
       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[k][i][j]);
+
+        AssertFatal((ue->ulsch[k][i][j]  = new_nr_ue_ulsch(ue->frame_parms.N_RB_UL, NUMBER_OF_HARQ_PID_MAX, abstraction_flag))!=NULL,"Can't get ue ulsch structures\n");
+        LOG_D(PHY,"ulsch[%d][%d][%d] => %p\n",k,i,j,ue->ulsch[k][i][j]);
       }
     }
 
-    //AssertFatal((ue->ulsch[i]  = new_ue_ulsch(ue->frame_parms.N_RB_UL, abstraction_flag))!=NULL,"Can't get ue ulsch structures\n");
-
     ue->dlsch_SI[i]  = new_nr_ue_dlsch(1,1,NSOFT,MAX_LDPC_ITERATIONS,ue->frame_parms.N_RB_DL, abstraction_flag);
     ue->dlsch_ra[i]  = new_nr_ue_dlsch(1,1,NSOFT,MAX_LDPC_ITERATIONS,ue->frame_parms.N_RB_DL, abstraction_flag);
 

openair1/PHY/NR_TRANSPORT/nr_dlsch_coding.c

@@ -69,7 +69,7 @@ void free_gNB_dlsch(NR_gNB_DLSCH_t *dlsch)
 #endif
 
         if (dlsch->harq_processes[i]->b) {
-          free16(dlsch->harq_processes[i]->b,MAX_DLSCH_PAYLOAD_BYTES);
+          free16(dlsch->harq_processes[i]->b,MAX_DLSCH_PAYLOAD_BYTES); //this should be MAX_NR_DLSCH_PAYLOAD_BYTES
           dlsch->harq_processes[i]->b = NULL;
 #ifdef DEBUG_DLSCH_FREE
           printf("Freeing dlsch process %d b (%p)\n",i,dlsch->harq_processes[i]->b);
@@ -195,8 +195,11 @@ NR_gNB_DLSCH_t *new_gNB_dlsch(unsigned char Kmimo,
         if (abstraction_flag==0) {
           for (r=0; r<MAX_NUM_NR_DLSCH_SEGMENTS/bw_scaling; r++) {
             // account for filler in first segment and CRCs for multiple segment case
+            // [hna] 8448 is the maximum CB size in NR
+            //       68*348 = 68*(maximum size of Zc)
+            //       In section 5.3.2 in 38.212, the for loop is up to N + 2*Zc (maximum size of N is 66*Zc, therefore 68*Zc)
             dlsch->harq_processes[i]->c[r] = (uint8_t*)malloc16(8448);
-            dlsch->harq_processes[i]->d[r] = (uint8_t*)malloc16(68*384);
+            dlsch->harq_processes[i]->d[r] = (uint8_t*)malloc16(68*384); //max size for coded output
             if (dlsch->harq_processes[i]->c[r]) {
               bzero(dlsch->harq_processes[i]->c[r],8448);
             } else {
@@ -272,7 +275,6 @@ int nr_dlsch_encoding(unsigned char *a,
 
   unsigned int G;
   unsigned int crc=1;
-
   uint8_t harq_pid = dlsch->harq_ids[slot];
   nfapi_nr_dl_config_dlsch_pdu_rel15_t rel15 = dlsch->harq_processes[harq_pid]->dlsch_pdu.dlsch_pdu_rel15;
   uint16_t nb_rb = rel15.n_prb;
@@ -302,8 +304,10 @@ int nr_dlsch_encoding(unsigned char *a,
   A = rel15.transport_block_size;
 
   G = nr_get_G(nb_rb, nb_symb_sch, nb_re_dmrs, length_dmrs,mod_order,rel15.nb_layers);
+
   LOG_D(PHY,"dlsch coding A %d G %d mod_order %d\n", A,G, mod_order);
   
+
   Tbslbrm = nr_compute_tbs(28,nb_rb,frame_parms->symbols_per_slot,0,0, rel15.nb_layers);
 
   //  if (dlsch->harq_processes[harq_pid]->Ndi == 1) {  // this is a new packet
@@ -328,6 +332,7 @@ int nr_dlsch_encoding(unsigned char *a,
 
     dlsch->harq_processes[harq_pid]->B = A+24;
     //    dlsch->harq_processes[harq_pid]->b = a;
+    
     memcpy(dlsch->harq_processes[harq_pid]->b,a,(A/8)+4);
 
     nr_segmentation(dlsch->harq_processes[harq_pid]->b,
@@ -335,7 +340,7 @@ int nr_dlsch_encoding(unsigned char *a,
 		    dlsch->harq_processes[harq_pid]->B,
 		    &dlsch->harq_processes[harq_pid]->C,
 		    &dlsch->harq_processes[harq_pid]->K,
-		    pz,
+		    pz, // [hna] pz is Zc
 		    &dlsch->harq_processes[harq_pid]->F);
 
     F = dlsch->harq_processes[harq_pid]->F;
@@ -388,6 +393,7 @@ int nr_dlsch_encoding(unsigned char *a,
     //stop_meas(te_stats);
     //printf("end ldpc encoder -- output\n");
 
+    //write_output("enc_input0.m","enc_in0",&dlsch->harq_processes[harq_pid]->c[0][0],Kr_bytes,1,4);
 #ifdef DEBUG_DLSCH_CODING
       write_output("enc_input0.m","enc_in0",&dlsch->harq_processes[harq_pid]->c[0][0],Kr_bytes,1,4);
       write_output("enc_output0.m","enc0",&dlsch->harq_processes[harq_pid]->d[0][0],(3*8*Kr_bytes)+12,1,4);
@@ -429,6 +435,7 @@ int nr_dlsch_encoding(unsigned char *a,
                           rel15.redundancy_version,
                           E);
 
+    
 #ifdef DEBUG_DLSCH_CODING
     for (int i =0; i<16; i++)
       printf("output ratematching e[%d]= %d r_offset %d\n", i,dlsch->harq_processes[harq_pid]->e[i+r_offset], r_offset);
@@ -442,6 +449,7 @@ int nr_dlsch_encoding(unsigned char *a,
 						dlsch->harq_processes[harq_pid]->f+r_offset);
     //stop_meas(i_stats);
 
+
 #ifdef DEBUG_DLSCH_CODING
     for (int i =0; i<16; i++)
       printf("output interleaving f[%d]= %d r_offset %d\n", i,dlsch->harq_processes[harq_pid]->f[i+r_offset], r_offset);
@@ -455,5 +463,5 @@ int nr_dlsch_encoding(unsigned char *a,
 
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_DLSCH_ENCODING, VCD_FUNCTION_OUT);
 
-  return(0);
+  return 0;
 }

openair1/PHY/NR_TRANSPORT/nr_transport_common_proto.h

@@ -38,7 +38,7 @@
 #define MAX_NUM_NR_ULSCH_SEGMENTS MAX_NUM_NR_DLSCH_SEGMENTS
 
 #define MAX_NR_DLSCH_PAYLOAD_BYTES (MAX_NUM_NR_DLSCH_SEGMENTS*1056)
-#define MAX_NR_ULSCH_PAYLOAD_BYTES (MAX_NUM_NR_DLSCH_SEGMENTS*1056)
+#define MAX_NR_ULSCH_PAYLOAD_BYTES (MAX_NUM_NR_ULSCH_SEGMENTS*1056)
 
 #define MAX_NUM_NR_CHANNEL_BITS (14*273*12*6)  // 14 symbols, 273 RB
 #define MAX_NUM_NR_RE (14*273*12)

openair1/PHY/NR_TRANSPORT/nr_ulsch.h

+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+/*! \file PHY/NR_TRANSPORT/nr_ulsch.h
+* \brief functions used for PUSCH/ULSCH physical and transport channels for gNB
+* \author Ahmed Hussein
+* \date 2019
+* \version 0.1
+* \company Fraunhofer IIS
+* \email: ahmed.hussein@iis.fraunhofer.de
+* \note
+* \warning
+*/
+
+#include "PHY/defs_gNB.h"
+
+void free_gNB_ulsch(NR_gNB_ULSCH_t *ulsch);
+
+NR_gNB_ULSCH_t *new_gNB_ulsch(uint8_t max_ldpc_iterations,uint8_t N_RB_UL, uint8_t abstraction_flag);
+
+uint32_t nr_ulsch_decoding(PHY_VARS_gNB *phy_vars_gNB,
+                           uint8_t UE_id,
+                           short *ulsch_llr,
+                           NR_DL_FRAME_PARMS *frame_parms,
+                           uint32_t frame,
+                           uint16_t nb_symb_sch,
+                           uint8_t nr_tti_rx,
+                           uint8_t harq_pid,
+                           uint8_t is_crnti,
+                           uint8_t llr8_flag);
+

openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_decoding.c

@@ -309,8 +309,9 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
                     harq_process->B,
                     &harq_process->C,
                     &harq_process->K,
-     						&harq_process->Z,
+                    &harq_process->Z, // [hna] Z is Zc
                     &harq_process->F);
+
     p_decParams->Z = harq_process->Z;
 
 #ifdef DEBUG_DLSCH_DECODING
@@ -319,8 +320,10 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
       printf("K %d C %d Z %d nl %d \n", harq_process->K, harq_process->C, p_decParams->Z, harq_process->Nl);
 #endif
   }
+
   Coderate = (float) A /(float) G;
-      if ((A <=292) || ((A<=3824) && (Coderate <= 0.6667)) || Coderate <= 0.25){
+  if ((A <=292) || ((A<=3824) && (Coderate <= 0.6667)) || Coderate <= 0.25)
+  {
     p_decParams->BG = 2;
     if (Coderate < 0.3333){
       p_decParams->R = 15;
@@ -356,14 +359,12 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
   p_decParams->numMaxIter = dlsch->max_ldpc_iterations;
   p_decParams->outMode= 0;
 
-
   err_flag = 0;
   r_offset = 0;
 
   unsigned char bw_scaling =1;
 
   switch (frame_parms->N_RB_DL) {
-
     case 106:
       bw_scaling =2;
       break;
@@ -377,13 +378,14 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
     LOG_E(PHY,"Illegal harq_process->C %d > %d\n",harq_process->C,MAX_NUM_NR_DLSCH_SEGMENTS/bw_scaling);
     return((1+dlsch->max_ldpc_iterations));
   }
+
 #ifdef DEBUG_DLSCH_DECODING
   printf("Segmentation: C %d, K %d\n",harq_process->C,harq_process->K);
 #endif
 
   opp_enabled=1;
 
-  Kr = harq_process->K;
+  Kr = harq_process->K; // [hna] overwrites this line "Kr = p_decParams->Z*kb"
   Kr_bytes = Kr>>3;
 
   K_bytes_F = Kr_bytes-(harq_process->F>>3);
@@ -400,7 +402,7 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
 #endif
     nr_deinterleaving_ldpc(E,
                            harq_process->Qm,
-                           harq_process->w[r],
+                           harq_process->w[r], // [hna] w is e
                            dlsch_llr+r_offset);
 
     //for (int i =0; i<16; i++)
@@ -441,8 +443,7 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
 #endif
       LOG_E(PHY,"dlsch_decoding.c: Problem in rate_matching\n");
       return(dlsch->max_ldpc_iterations);
-    } else
-    {
+    } else {
 #if UE_TIMING_TRACE
       stop_meas(dlsch_rate_unmatching_stats);
 #endif
@@ -460,12 +461,12 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
     }
 
     printf("decoder input(segment %d) :",r);
-    int i; for (i=0;i<(3*8*Kr_bytes)+12;i++)
+    int i;
+    for (i=0;i<(3*8*Kr_bytes)+12;i++)
       printf("%d : %d\n",i,harq_process->d[r][i]);
     printf("\n");
 #endif
 
-
     //    printf("Clearing c, %p\n",harq_process->c[r]);
     memset(harq_process->c[r],0,Kr_bytes);
 
@@ -489,7 +490,6 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
 
       //printf("harq process dr iteration %d\n", p_decParams->numMaxIter);
 
-
       memset(pv,0,2*harq_process->Z*sizeof(int16_t));
       //memset(pl,0,2*p_decParams->Z*sizeof(int8_t));
       memset((pv+K_bytes_F),127,harq_process->F*sizeof(int16_t));
@@ -506,9 +506,7 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
 
       for (i=0, j=0; j < ((kc*p_decParams->Z)>>4);  i+=2, j++)
       {
-      				
         pl[j] = _mm_packs_epi16(pv[i],pv[i+1]);
-      	      		
       }
 
       no_iteration_ldpc = nrLDPC_decoder(p_decParams,
@@ -527,7 +525,6 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
         ret = 1+dlsch->max_ldpc_iterations;
       }
 
-
       nb_total_decod++;
       if (no_iteration_ldpc > dlsch->max_ldpc_iterations){
         nb_error_decod++;
@@ -792,6 +789,7 @@ uint32_t  nr_dlsch_decoding_mthread(PHY_VARS_NR_UE *phy_vars_ue,
                       &harq_process->K,
                       &harq_process->Z,
                       &harq_process->F);
+
       p_decParams->Z = harq_process->Z;
 
     }
@@ -842,7 +840,7 @@ uint32_t  nr_dlsch_decoding_mthread(PHY_VARS_NR_UE *phy_vars_ue,
 #endif
 
   opp_enabled=1;
-if (harq_process->C>1) { // wakeup worker if more than 1 segment
+  if (harq_process->C>1) { // wakeup worker if more than 1 segment
     if (pthread_mutex_lock(&proc->mutex_dlsch_td) != 0) {
       LOG_E( PHY, "[SCHED][UE %d][Slot0] error locking mutex for UE dlsch td\n",phy_vars_ue->Mod_id );
       exit_fun("nothing to add");
@@ -883,7 +881,6 @@ if (harq_process->C>1) { // wakeup worker if more than 1 segment
         LOG_E( PHY, "[SCHED][UE %d][Slot0] error unlocking mutex for UE dlsch td \n",phy_vars_ue->Mod_id );
         exit_fun("nothing to add");
       }
-
     } else
     {
       LOG_E( PHY, "[SCHED][UE %d] UE dlsch td thread busy (IC %d)!!\n", phy_vars_ue->Mod_id, proc->instance_cnt_dlsch_td);
@@ -916,7 +913,6 @@ if (harq_process->C>1) { // wakeup worker if more than 1 segment
           LOG_E( PHY, "[SCHED][UE %d][Slot0] error unlocking mutex for UE dlsch td \n",phy_vars_ue->Mod_id );
           exit_fun("nothing to add");
         }
-
       } else
       {
         LOG_E( PHY, "[SCHED][UE %d] UE dlsch td thread 1 busy (IC %d)!!\n", phy_vars_ue->Mod_id, proc->instance_cnt_dlsch_td1);
@@ -968,7 +964,7 @@ if (harq_process->C>1) { // wakeup worker if more than 1 segment
     Cby2 = 1;
   }
 
-  //for (r=0; r<Cby2; r++) {
+//for (r=0; r<Cby2; r++) {
     r = 0;  
     if (r==0) r_offset =0;
 
@@ -1112,9 +1108,7 @@ if (harq_process->C>1) { // wakeup worker if more than 1 segment
 
       for (i=0, j=0; j < ((kc*p_decParams->Z)>>4);  i+=2, j++)
       {
-
         pl[j] = _mm_packs_epi16(pv[i],pv[i+1]);
-
       }
 
       no_iteration_ldpc = nrLDPC_decoder(p_decParams,
@@ -1163,9 +1157,7 @@ if (harq_process->C>1) { // wakeup worker if more than 1 segment
 
       for (int j=0; j < Kr>>3; j ++)
       {
-
         printf(" %d \n", ullrProcBuf[j]);
-
       }
       printf(" \n");*/
     //printf("output channel decoder %d %d %d %d %d \n", harq_process->c[r][0], harq_process->c[r][1], harq_process->c[r][2],harq_process->c[r][3], harq_process->c[r][4]);

openair1/PHY/NR_UE_TRANSPORT/nr_transport_proto_ue.h

@@ -61,10 +61,10 @@ void free_nr_ue_dlsch(NR_UE_DLSCH_t *dlsch);
 NR_UE_DLSCH_t *new_nr_ue_dlsch(uint8_t Kmimo,uint8_t Mdlharq,uint32_t Nsoft,uint8_t max_turbo_iterations,uint8_t N_RB_DL, uint8_t abstraction_flag);
 
 
-void free_ue_ulsch(NR_UE_ULSCH_t *ulsch);
+void free_nr_ue_ulsch(NR_UE_ULSCH_t *ulsch);
 
 
-NR_UE_ULSCH_t *new_ue_ulsch(unsigned char N_RB_UL, uint8_t abstraction_flag);
+NR_UE_ULSCH_t *new_nr_ue_ulsch(unsigned char N_RB_UL, int number_of_harq_pids, uint8_t abstraction_flag);
 
 void fill_UE_dlsch_MCH(PHY_VARS_NR_UE *ue,int mcs,int ndi,int rvidx,int eNB_id);
 
@@ -1006,6 +1006,25 @@ uint32_t  nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
                          uint8_t is_crnti,
                          uint8_t llr8_flag);
 
+int nr_ulsch_encoding(NR_UE_ULSCH_t *ulsch,
+                     NR_DL_FRAME_PARMS* frame_parms,
+                     uint8_t harq_pid);
+
+/*! \brief Perform PUSCH scrambling. TS 38.211 V15.4.0 subclause 6.3.1.1
+  @param[in] in Pointer to input bits
+  @param[in] size of input bits
+  @param[in] Nid cell id
+  @param[in] n_RNTI CRNTI
+  @param[out] out the scrambled bits
+*/
+
+void nr_pusch_codeword_scrambling(uint8_t *in,
+                         uint16_t size,
+                         uint32_t Nid,
+                         uint32_t n_RNTI,
+                         uint32_t* out);
+
+
 uint32_t  nr_dlsch_decoding_mthread(PHY_VARS_NR_UE *phy_vars_ue,
 						 UE_nr_rxtx_proc_t *proc,
                          int eNB_id,

openair1/PHY/NR_UE_TRANSPORT/nr_transport_ue.h

@@ -102,6 +102,8 @@ typedef struct {
   uint16_t first_rb;
   /// Current Number of RBs
   uint16_t nb_rb;
+  /// number of layers
+  uint8_t Nl;
   /// Last TPC command
   uint8_t TPC;
   /// Transport block size
@@ -110,20 +112,24 @@ typedef struct {
   uint32_t B;
   /// Length of ACK information (bits)
   uint8_t O_ACK;
-  /// Pointer to the payload
-  uint8_t *b;
-  /// Pointers to transport block segments
-  uint8_t *c[MAX_NUM_ULSCH_SEGMENTS];
   /// Index of current HARQ round for this ULSCH
   uint8_t round;
   /// MCS format of this ULSCH
   uint8_t mcs;
   /// Redundancy-version of the current sub-frame
   uint8_t rvidx;
+  /// pointer to pdu from MAC interface (TS 36.212 V15.4.0, Sec 5.1 p. 8)
+  unsigned char *a;
+  /// Pointer to the payload + CRC 
+  uint8_t *b;
+  /// Pointers to transport block segments
+  uint8_t *c[MAX_NUM_NR_ULSCH_SEGMENTS];
   /// LDPC-code outputs
-  uint8_t d[MAX_NUM_ULSCH_SEGMENTS][3*8448];
-  /// Interleaver outputs
-  uint8_t w[MAX_NUM_ULSCH_SEGMENTS][3*8448];
+  uint8_t *d[MAX_NUM_NR_ULSCH_SEGMENTS];
+  /// LDPC-code outputs (TS 36.212 V15.4.0, Sec 5.3.2 p. 17)
+  uint8_t e[MAX_NUM_NR_CHANNEL_BITS] __attribute__((aligned(32))); 
+  /// Rate matching (Interleaving) outputs (TS 36.212 V15.4.0, Sec 5.4.2.2 p. 30)
+  uint8_t f[MAX_NUM_NR_CHANNEL_BITS] __attribute__((aligned(32))); 
   /// Number of code segments
   uint32_t C;
   /// Number of bits in code segments
@@ -158,6 +164,8 @@ typedef struct {
 typedef struct {
   /// Current Number of Symbols
   uint8_t Nsymb_pusch;
+  /// number of DMRS resource elements
+  uint8_t nb_re_dmrs;
   /// SRS active flag
   uint8_t srs_active; 
 //#if defined(UPGRADE_RAT_NR)
@@ -168,6 +176,7 @@ typedef struct {
   // UL number of harq processes
   uint8_t number_harq_processes_for_pusch;
 #endif 
+  /*
   /// Pointer to CQI data (+1 for 8 bits crc)
   uint8_t o[1+MAX_CQI_BYTES];
   /// Length of CQI data (bits)
@@ -180,22 +189,25 @@ typedef struct {
   uint8_t O_RI;
   /// Pointer to ACK
   uint8_t o_ACK[4];
+  */
   /// Minimum number of CQI bits for PUSCH (36-212 r8.6, Sec 5.2.4.1 p. 37)
   uint8_t O_CQI_MIN;
   /// ACK/NAK Bundling flag
   uint8_t bundling;
-  /// Concatenated "e"-sequences (for definition see 36-212 V8.6 2009-03, p.17-18)
-  uint8_t e[MAX_NUM_CHANNEL_BITS];
+  /// Concatenated "g"-sequences (for definition see 36-212 V15.4.0 2018-12, p.31)
+  uint8_t g[MAX_NUM_NR_CHANNEL_BITS];
   /// Interleaved "h"-sequences (for definition see 36-212 V8.6 2009-03, p.17-18)
-  uint8_t h[MAX_NUM_CHANNEL_BITS];
+  uint8_t h[MAX_NUM_NR_CHANNEL_BITS];
   /// Scrambled "b"-sequences (for definition see 36-211 V8.6 2009-03, p.14)
-  uint8_t b_tilde[MAX_NUM_CHANNEL_BITS];
+  uint8_t b_tilde[MAX_NUM_NR_CHANNEL_BITS];
   /// Modulated "d"-sequences (for definition see 36-211 V8.6 2009-03, p.14)
-  int32_t d[MAX_NUM_RE];
+  int32_t d[MAX_NUM_NR_RE];
   /// Transform-coded "z"-sequences (for definition see 36-211 V8.6 2009-03, p.14-15)
-  int32_t z[MAX_NUM_RE];
+  int32_t z[MAX_NUM_NR_RE];
+  /*
   /// "q" sequences for CQI/PMI (for definition see 36-212 V8.6 2009-03, p.27)
   uint8_t q[MAX_CQI_PAYLOAD];
+  
   /// coded and interleaved CQI bits
   uint8_t o_w[(MAX_CQI_BITS+8)*3];
   /// coded CQI bits
@@ -204,6 +216,7 @@ typedef struct {
   uint8_t q_ACK[MAX_ACK_PAYLOAD];
   /// coded RI bits
   uint8_t q_RI[MAX_RI_PAYLOAD];
+  */
   /// beta_offset_cqi times 8
   uint16_t beta_offset_cqi_times8;
   /// beta_offset_ri times 8
@@ -229,9 +242,9 @@ typedef struct {
   /// num active cba group
   uint8_t num_active_cba_groups;
   /// num dci found for cba
-  uint8_t num_cba_dci[10];
+  //uint8_t num_cba_dci[10];
   /// allocated CBA RNTI
-  uint16_t cba_rnti[4];//NUM_MAX_CBA_GROUP];
+  //uint16_t cba_rnti[4];//NUM_MAX_CBA_GROUP];
   /// UL max-harq-retransmission
   uint8_t Mlimit;
 } NR_UE_ULSCH_t;

openair1/PHY/defs_gNB.h

@@ -38,6 +38,10 @@
 #include "CODING/nrPolar_tools/nr_polar_pbch_defs.h"
 #include "openair2/NR_PHY_INTERFACE/NR_IF_Module.h"
 #include "PHY/NR_TRANSPORT/nr_transport_common_proto.h"
+#include "PHY/impl_defs_top.h"
+#include "PHY/defs_common.h"
+#include "PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.h"
+#include "PHY/CODING/nrLDPC_decoder/nrLDPC_types.h"
 
 #define MAX_NUM_RU_PER_gNB MAX_NUM_RU_PER_eNB
 
@@ -72,6 +76,7 @@ typedef struct {
   uint64_t dci_pdu[2];
 } NR_gNB_DCI_ALLOC_t;
 
+
 typedef struct {
   uint8_t     num_dci;
   uint8_t     num_pdsch_rnti;
@@ -79,6 +84,14 @@ typedef struct {
 } NR_gNB_PDCCH;
 
 
+typedef enum {
+  NR_SCH_IDLE,
+  NR_ACTIVE,
+  NR_CBA_ACTIVE,
+  NR_DISABLED
+} NR_SCH_status_t;
+
+
 typedef struct {
   /// Nfapi DLSCH PDU
   nfapi_nr_dl_config_dlsch_pdu dlsch_pdu;
@@ -114,7 +127,6 @@ typedef struct {
 
 
 typedef struct {
-
   /// Pointers to 16 HARQ processes for the DLSCH
   NR_DL_gNB_HARQ_t *harq_processes[NR_MAX_NB_HARQ_PROCESSES];
   /// TX buffers for UE-spec transmission (antenna ports 5 or 7..14, prior to precoding)
@@ -160,6 +172,170 @@ typedef struct {
 } NR_gNB_DLSCH_t;
 
 
+typedef struct {
+  /// Nfapi ULSCH PDU
+  nfapi_nr_ul_config_ulsch_pdu ulsch_pdu;
+  /// Frame where current HARQ round was sent
+  uint32_t frame;
+  /// Subframe where current HARQ round was sent
+  uint32_t subframe;
+  /// Index of current HARQ round for this DLSCH
+  uint8_t round;
+  /// Last TPC command
+  uint8_t TPC;
+  /// MIMO mode for this DLSCH
+  MIMO_mode_t mimo_mode;
+  /// Flag indicating that this ULSCH has been allocated by a DCI (otherwise it is a retransmission based on PHICH NAK)
+  uint8_t dci_alloc;
+  /// Flag indicating that this ULSCH has been allocated by a RAR (otherwise it is a retransmission based on PHICH NAK or DCI)
+  uint8_t rar_alloc;
+  /// Status Flag indicating for this ULSCH (idle,active,disabled)
+  NR_SCH_status_t status;
+  /// Subframe scheduling indicator (i.e. Transmission opportunity indicator)
+  uint8_t subframe_scheduling_flag;
+  /// Subframe cba scheduling indicator (i.e. CBA Transmission opportunity indicator)
+  uint8_t subframe_cba_scheduling_flag;
+  /// PHICH active flag
+  uint8_t phich_active;
+  /// PHICH ACK
+  uint8_t phich_ACK;
+  /// First Allocated RB - previous scheduling. This is needed for PHICH generation which is done after a new scheduling
+  uint16_t previous_first_rb;
+  /// Flag to indicate that the UL configuration has been handled. Used to remove a stale ULSCH when frame wraps around
+  uint8_t handled;
+  /// Flag to indicate that this ULSCH is for calibration information sent from UE (i.e. no MAC SDU to pass up)
+  //  int calibration_flag;
+  /// delta_TF for power control
+  int32_t delta_TF;
+
+  
+  /////////////////////// ulsch decoding ///////////////////////
+  /// Transport block size (This is A from 38.212 V15.4.0 section 5.1)
+  uint32_t TBS;
+  /// Pointer to the payload (38.212 V15.4.0 section 5.1)
+  uint8_t *b;
+  /// The payload + CRC (24 bits) in bits (38.212 V15.4.0 section 5.1)
+  uint32_t B;
+  /// Pointers to code blocks after code block segmentation and CRC attachment (38.212 V15.4.0 section 5.2.2)
+  uint8_t *c[MAX_NUM_NR_ULSCH_SEGMENTS];
+  /// Number of bits in each code block (38.212 V15.4.0 section 5.2.2)
+  uint32_t K;
+  /// Number of "Filler" bits added in the code block segmentation (38.212 V15.4.0 section 5.2.2)
+  uint32_t F;
+  /// Number of code blocks after code block segmentation (38.212 V15.4.0 section 5.2.2)
+  uint32_t C;
+  /// Pointers to code blocks after LDPC coding (38.212 V15.4.0 section 5.3.2)
+  int16_t *d[MAX_NUM_NR_ULSCH_SEGMENTS];
+  /// LDPC processing buffer
+  t_nrLDPC_procBuf* p_nrLDPC_procBuf[MAX_NUM_NR_ULSCH_SEGMENTS];
+  /// LDPC lifting size (38.212 V15.4.0 table 5.3.2-1)
+  uint32_t Z;
+  /// code blocks after bit selection in rate matching for LDPC code (38.212 V15.4.0 section 5.4.2.1)
+  int16_t e[MAX_NUM_NR_DLSCH_SEGMENTS][3*8448];
+  /// Number of bits in each code block after rate matching for LDPC code (38.212 V15.4.0 section 5.4.2.1)
+  uint32_t E;
+  /// Number of soft channel bits after code block concatenation (38.212 V15.4.0 section 5.5)
+  uint32_t G;
+  //////////////////////////////////////////////////////////////
+
+
+  /////////////////////////// DMRS /////////////////////////////
+  /// n_DMRS  for cyclic shift of DMRS (36.213 Table 9.1.2-2)
+  uint8_t n_DMRS;
+  /// n_DMRS 2 for cyclic shift of DMRS (36.211 Table 5.5.1.1.-1)
+  uint8_t n_DMRS2;
+  /// n_DMRS  for cyclic shift of DMRS (36.213 Table 9.1.2-2) - previous scheduling
+  /// This is needed for PHICH generation which
+  /// is done after a new scheduling
+  uint8_t previous_n_DMRS;
+  //////////////////////////////////////////////////////////////
+
+
+  ///////////////////// UCI multiplexing ///////////////////////
+  /// CQI CRC status
+  uint8_t cqi_crc_status;
+  /// Pointer to CQI data
+  uint8_t o[MAX_CQI_BYTES];
+  /// Format of CQI data
+  UCI_format_t uci_format;
+  /// Length of CQI data under RI=1 assumption(bits)
+  uint8_t Or1;
+  /// Length of CQI data under RI=2 assumption(bits)
+  uint8_t Or2;
+  /// Rank information
+  uint8_t o_RI[2];
+  /// Length of rank information (bits)
+  uint8_t O_RI;
+  /// Pointer to ACK
+  uint8_t o_ACK[4];
+  /// Length of ACK information (bits)
+  uint8_t O_ACK;
+  /// The value of DAI in DCI format 0
+  uint8_t V_UL_DAI;
+  /// "q" sequences for CQI/PMI (for definition see 36-212 V8.6 2009-03, p.27)
+  int8_t q[MAX_CQI_PAYLOAD];
+  /// number of coded CQI bits after interleaving
+  uint8_t o_RCC;
+  /// coded and interleaved CQI bits
+  int8_t o_w[(MAX_CQI_BITS+8)*3];
+  /// coded CQI bits
+  int8_t o_d[96+((MAX_CQI_BITS+8)*3)];
+  /// coded ACK bits
+  int16_t q_ACK[MAX_ACK_PAYLOAD];
+  /// coded RI bits
+  int16_t q_RI[MAX_RI_PAYLOAD];
+  /// Temporary h sequence to flag PUSCH_x/PUSCH_y symbols which are not scrambled
+  uint8_t h[MAX_NUM_CHANNEL_BITS];
+  /// soft bits for each received segment ("w"-sequence)(for definition see 36-212 V8.6 2009-03, p.15)
+  int16_t w[MAX_NUM_ULSCH_SEGMENTS][3*(6144+64)];
+  //////////////////////////////////////////////////////////////
+} NR_UL_gNB_HARQ_t;
+
+
+typedef struct {
+  /// Pointers to 16 HARQ processes for the ULSCH
+  NR_UL_gNB_HARQ_t *harq_processes[NR_MAX_ULSCH_HARQ_PROCESSES];
+  /// Current HARQ process id
+  int harq_process_id[NR_MAX_SLOTS_PER_FRAME];
+  /// HARQ process mask, indicates which processes are currently active
+  uint16_t harq_mask;
+  /// ACK/NAK Bundling flag
+  uint8_t bundling;
+  /// beta_offset_cqi times 8
+  uint16_t beta_offset_cqi_times8;
+  /// beta_offset_ri times 8
+  uint16_t beta_offset_ri_times8;
+  /// beta_offset_harqack times 8
+  uint16_t beta_offset_harqack_times8;
+  /// Flag to indicate that gNB awaits UE Msg3
+  uint8_t Msg3_active;
+  /// Flag to indicate that gNB should decode UE Msg3
+  uint8_t Msg3_flag;
+  /// Subframe for Msg3
+  uint8_t Msg3_subframe;
+  /// Frame for Msg3
+  uint32_t Msg3_frame;
+  /// Allocated RNTI for this ULSCH
+  uint16_t rnti;
+  /// RNTI type
+  uint8_t rnti_type;
+  /// cyclic shift for DM RS
+  uint8_t cyclicShift;
+  /// for cooperative communication
+  uint8_t cooperation_flag;
+  /// Maximum number of HARQ rounds
+  uint8_t Mlimit;
+  /// Maximum number of LDPC iterations
+  uint8_t max_ldpc_iterations;
+  /// number of iterations used in last LDPC decoding
+  uint8_t last_iteration_cnt;  
+  /// num active cba group
+  uint8_t num_active_cba_groups;
+  /// num active cba group
+  uint16_t cba_rnti[NUM_MAX_CBA_GROUP];
+} NR_gNB_ULSCH_t;
+
+
 typedef struct {
   /// \brief Pointers (dynamic) to the received data in the time domain.
   /// - first index: rx antenna [0..nb_antennas_rx[
@@ -399,7 +575,8 @@ typedef struct PHY_VARS_gNB_s {
   LTE_eNB_PUSCH      *pusch_vars[NUMBER_OF_UE_MAX];
   LTE_eNB_PRACH       prach_vars;
   NR_gNB_DLSCH_t     *dlsch[NUMBER_OF_UE_MAX][2];    // Nusers times two spatial streams
-  LTE_eNB_ULSCH_t     *ulsch[NUMBER_OF_UE_MAX+1];      // Nusers + number of RA
+  NR_gNB_ULSCH_t     *ulsch[NUMBER_OF_UE_MAX+1][2];  // [Nusers times + number of RA][2 codewords], index 0 in [NUMBER_OF_UE_MAX+1] is for RA
+  // LTE_eNB_ULSCH_t     *ulsch[NUMBER_OF_UE_MAX+1];     // Nusers + number of RA
   NR_gNB_DLSCH_t     *dlsch_SI,*dlsch_ra,*dlsch_p;
   NR_gNB_DLSCH_t     *dlsch_MCH;
   NR_gNB_DLSCH_t     *dlsch_PCH;

openair1/PHY/defs_nr_UE.h

@@ -1054,8 +1054,8 @@ typedef struct {
   NR_UE_PBCH      *pbch_vars[NUMBER_OF_CONNECTED_eNB_MAX];
   NR_UE_PDCCH     *pdcch_vars[RX_NB_TH_MAX][NUMBER_OF_CONNECTED_eNB_MAX];
   NR_UE_PRACH     *prach_vars[NUMBER_OF_CONNECTED_eNB_MAX];
-  NR_UE_DLSCH_t   *dlsch[RX_NB_TH_MAX][NUMBER_OF_CONNECTED_eNB_MAX][2]; // two RxTx Threads
-  NR_UE_ULSCH_t   *ulsch[NUMBER_OF_CONNECTED_eNB_MAX];
+  NR_UE_DLSCH_t   *dlsch[RX_NB_TH_MAX][NUMBER_OF_CONNECTED_eNB_MAX][NR_MAX_NB_CODEWORDS]; // two RxTx Threads
+  NR_UE_ULSCH_t   *ulsch[RX_NB_TH_MAX][NUMBER_OF_CONNECTED_eNB_MAX][NR_MAX_NB_CODEWORDS]; // two code words
   NR_UE_DLSCH_t   *dlsch_SI[NUMBER_OF_CONNECTED_eNB_MAX];
   NR_UE_DLSCH_t   *dlsch_ra[NUMBER_OF_CONNECTED_eNB_MAX];
   NR_UE_DLSCH_t   *dlsch_p[NUMBER_OF_CONNECTED_eNB_MAX];

openair1/PHY/defs_nr_common.h

@@ -87,10 +87,10 @@
 #define NR_MAX_CSET_DURATION 3
 
 #define NR_MAX_NB_RBG 18
-#define NR_MAX_NB_LAYERS 8
+#define NR_MAX_NB_LAYERS 8 // SU-MIMO (3GPP TS 38.211 V15.4.0 section 7.3.1.3)
 #define NR_MAX_NB_CODEWORDS 2
 #define NR_MAX_NB_HARQ_PROCESSES 16
-#define NR_MAX_PDSCH_ENCODED_LENGTH 950984
+#define NR_MAX_PDSCH_ENCODED_LENGTH NR_MAX_NB_RB*NR_SYMBOLS_PER_SLOT*NR_NB_SC_PER_RB*8*NR_MAX_NB_LAYERS // 8 is the maximum modulation order (it was 950984 before !!) 
 #define NR_MAX_PDSCH_TBS 3824
 
 typedef enum {

openair1/SCHED_NR_UE/harq_nr.c

@@ -150,7 +150,7 @@ void get_dci_info_for_harq(PHY_VARS_NR_UE *ue, NR_DCI_INFO_EXTRACTED_t *nr_dci_i
 *
 *********************************************************************/
 
-void config_uplink_harq_process(PHY_VARS_NR_UE *ue, int gNB_id, uint8_t number_harq_processes_pusch)
+void config_uplink_harq_process(PHY_VARS_NR_UE *ue, int gNB_id, int thread_id, int code_word_idx, uint8_t number_harq_processes_pusch)
 {
   NR_UE_ULSCH_t *ulsch;
 
@@ -160,7 +160,7 @@ void config_uplink_harq_process(PHY_VARS_NR_UE *ue, int gNB_id, uint8_t number_h
 
     memset(ulsch,0,sizeof(NR_UE_ULSCH_t));
 
-    ue->ulsch[gNB_id] = ulsch;
+    ue->ulsch[thread_id][gNB_id][code_word_idx] = ulsch;
   }
   else {
     LOG_E(PHY, "Fatal memory allocation problem at line %d in function %s of file %s \n", __LINE__ , __func__, __FILE__);
@@ -185,7 +185,7 @@ void config_uplink_harq_process(PHY_VARS_NR_UE *ue, int gNB_id, uint8_t number_h
   }
 
   for (int slot_tx = 0; slot_tx < NR_MAX_SLOTS_PER_FRAME; slot_tx++) {
-    ue->ulsch[gNB_id]->harq_process_id[slot_tx] = NR_MAX_HARQ_PROCESSES;
+    ue->ulsch[thread_id][gNB_id][code_word_idx]->harq_process_id[slot_tx] = NR_MAX_HARQ_PROCESSES;
   }
 }
 
@@ -202,9 +202,9 @@ void config_uplink_harq_process(PHY_VARS_NR_UE *ue, int gNB_id, uint8_t number_h
 *
 *********************************************************************/
 
-void release_uplink_harq_process(PHY_VARS_NR_UE *ue, int gNB_id)
+void release_uplink_harq_process(PHY_VARS_NR_UE *ue, int gNB_id, int thread_id, int code_word_idx)
 {
-  NR_UE_ULSCH_t *ulsch = ue->ulsch[gNB_id];
+  NR_UE_ULSCH_t *ulsch = ue->ulsch[thread_id][gNB_id][code_word_idx];
 
   for (int process_id = 0; process_id < ulsch->number_harq_processes_for_pusch; process_id++) {
 
@@ -215,7 +215,7 @@ void release_uplink_harq_process(PHY_VARS_NR_UE *ue, int gNB_id)
 
   free16(ulsch, sizeof(NR_UE_ULSCH_t));
 
-  ue->ulsch[gNB_id] = NULL;
+  ue->ulsch[thread_id][gNB_id][code_word_idx] = NULL;
 }
 
 /*******************************************************************

openair1/SCHED_NR_UE/harq_nr.h

@@ -83,17 +83,21 @@ void get_dci_info_for_harq(PHY_VARS_NR_UE *ue, NR_DCI_INFO_EXTRACTED_t *nr_dci_i
 /** \brief This function configures uplink HARQ context
     @param PHY_VARS_NR_UE ue context
     @param gNB_id gNodeB identifier
+    @param thread_id RXTX thread index
+    @param code_word_idx code word index
     @param number_harq_processes_pusch maximum number of uplink HARQ processes
     @returns none */
 
-void config_uplink_harq_process(PHY_VARS_NR_UE *ue, int gNB_id, uint8_t number_harq_processes_pusch);
+void config_uplink_harq_process(PHY_VARS_NR_UE *ue, int gNB_id, int thread_id, int code_word_idx, uint8_t number_harq_processes_pusch);
 
 /** \brief This function releases uplink HARQ context
     @param PHY_VARS_NR_UE ue context
     @param gNB_id gNodeB identifier
+    @param thread_id RXTX thread index
+    @param code_word_idx code word index
     @returns none */
 
-void release_uplink_harq_process(PHY_VARS_NR_UE *ue, int gNB_id);
+void release_uplink_harq_process(PHY_VARS_NR_UE *ue, int gNB_id, int thread_id, int code_word_idx);
 
 /** \brief This function stores slot for transmission in HARQ context
     @param ulsch uplink context

openair1/SIMULATION/NR_PHY/dlschsim.c

@@ -409,7 +409,7 @@ int main(int argc, char **argv) {
 		r_im[i] = malloc(frame_length_complex_samples * sizeof(double));
 		bzero(r_im[i], frame_length_complex_samples * sizeof(double));
 		txdata[i] = malloc(frame_length_complex_samples * sizeof(int));
-		bzero(r_re[i], frame_length_complex_samples * sizeof(int));
+		bzero(r_re[i], frame_length_complex_samples * sizeof(int)); // [hna] r_re should be txdata
 	}
 
 	if (pbch_file_fd != NULL) {
@@ -485,7 +485,7 @@ int main(int argc, char **argv) {
 	rel15->nb_layers = Nl;
 	rel15->nb_re_dmrs = nb_re_dmrs;
 	rel15->transport_block_size = TBS;
-	double *modulated_input = malloc16(sizeof(double) * 16 * 68 * 384);
+	double *modulated_input = malloc16(sizeof(double) * 16 * 68 * 384); // [hna] 16 segments, 68*Zc
 	short *channel_output_fixed = malloc16(sizeof(short) * 16 * 68 * 384);
 	short *channel_output_uncoded = malloc16(sizeof(unsigned short) * 16 * 68 * 384);
 	double errors_bit_uncoded = 0;

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

@@ -54,6 +54,8 @@
 int test_harq_uplink(PHY_VARS_NR_UE *phy_vars_ue)
 {
   int gNB_id = 0;
+  int thread_number = 0;
+  int code_word_idx = 0;
   int harq_pid = 0;
   int ndi = 1;
   uint8_t rnti_type = _C_RNTI_;
@@ -61,7 +63,7 @@ int test_harq_uplink(PHY_VARS_NR_UE *phy_vars_ue)
 
   printf("\nHARQ Uplink \n");
 
-  config_uplink_harq_process(phy_vars_ue , gNB_id, NR_DEFAULT_DLSCH_HARQ_PROCESSES);
+  config_uplink_harq_process(phy_vars_ue , gNB_id, thread_number, code_word_idx, NR_DEFAULT_DLSCH_HARQ_PROCESSES);
 
   NR_UE_ULSCH_t *ulsch_harq = phy_vars_ue->ulsch[gNB_id];
 
@@ -91,7 +93,7 @@ int test_harq_uplink(PHY_VARS_NR_UE *phy_vars_ue)
     }
   }
 
-  release_uplink_harq_process(phy_vars_ue , gNB_id);
+  release_uplink_harq_process(phy_vars_ue , gNB_id, thread_number, code_word_idx);
 
   return 0;
 }

openair2/LAYER2/MAC/mac_extern.h

@@ -58,11 +58,7 @@ extern eNB_DLSCH_INFO eNB_dlsch_info[NUMBER_OF_eNB_MAX][MAX_NUM_CCs][MAX_MOBILES
 
 
 
-#ifndef PHYSIM
-#define NB_INST 1
-#else
 extern unsigned char NB_INST;
-#endif
 extern unsigned char NB_eNB_INST;
 extern unsigned char NB_UE_INST;
 extern unsigned char NB_RN_INST;

openair2/RRC/LTE/rrc_extern.h

@@ -44,17 +44,11 @@ extern LogicalChannelConfig_t SRB1_logicalChannelConfig_defaultValue;
 extern LogicalChannelConfig_t SRB2_logicalChannelConfig_defaultValue;
 
 
-#ifndef PHY_EMUL
-#ifndef PHYSIM
-//#define NB_INST 1
-#else
 extern unsigned char NB_INST;
-#endif
 extern unsigned char NB_eNB_INST;
 extern unsigned char NB_UE_INST;
 extern unsigned short NODE_ID[1];
 extern void* bigphys_malloc(int);
-#endif
 
 
 //CONSTANTS

openair2/RRC/NR/nr_rrc_extern.h

@@ -43,17 +43,11 @@ extern LogicalChannelConfig_t SRB1_logicalChannelConfig_defaultValue;
 extern LogicalChannelConfig_t SRB2_logicalChannelConfig_defaultValue;
 
 
-#ifndef PHY_EMUL
-#ifndef PHYSIM
-//#define NB_INST 1
-#else
 extern unsigned char NB_INST;
-#endif
 extern unsigned char NB_eNB_INST;
 extern unsigned char NB_UE_INST;
 extern unsigned short NODE_ID[1];
 extern void* bigphys_malloc(int);
-#endif
 
 
 //CONSTANTS

targets/COMMON/openairinterface5g_limits.h

 #ifndef OPENAIRINTERFACE5G_LIMITS_H_
 #define OPENAIRINTERFACE5G_LIMITS_H_
 
-#if defined(CBMIMO1) || defined(EXMIMO) || defined(OAI_USRP) || defined(OAI_LMSSDR) || defined(OAI_ADRV9371_ZC706)
+#if 1 /*defined(CBMIMO1) || defined(EXMIMO) || defined(OAI_USRP) || defined(OAI_LMSSDR) || defined(OAI_ADRV9371_ZC706)*/
 #        define NUMBER_OF_eNB_MAX 1
 #        define NUMBER_OF_gNB_MAX 1
 #        define NUMBER_OF_RU_MAX 2
 #        define NUMBER_OF_NR_RU_MAX 2
+#        ifndef PHYSIM
 #        ifndef UE_EXPANSION
 #                define NUMBER_OF_UE_MAX 16
 #                define NUMBER_OF_NR_UE_MAX 16
@@ -17,6 +18,12 @@
 #                define NUMBER_OF_CONNECTED_eNB_MAX 1
 #                define NUMBER_OF_CONNECTED_gNB_MAX 1
 #        endif
+#        else
+#                define NUMBER_OF_UE_MAX 1
+#                define NUMBER_OF_NR_UE_MAX 1
+#                define NUMBER_OF_CONNECTED_eNB_MAX 1
+#                define NUMBER_OF_CONNECTED_gNB_MAX 1
+#        endif
 #else
 #        define NUMBER_OF_eNB_MAX 7
 #        define NUMBER_OF_gNB_MAX 7