format 2 up to 64 bits tested for 8 and 16 PRBs PUCCH format

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

@@ -1498,7 +1498,7 @@ typedef struct
   //for dci_pusch_pdu
 typedef struct
 {
-  uint8_t  pdu_bit_map;
+  uint8_t  pduBitmap;
   uint32_t handle;
   uint16_t rnti;
   uint8_t  ul_cqi;
@@ -1513,7 +1513,7 @@ typedef struct
 //for PUCCH PDU Format 0/1
 typedef struct
 {
-  uint8_t  pdu_bit_map;
+  uint8_t  pduBitmap;
   uint32_t handle;
   uint16_t rnti;
   uint8_t  pucch_format;//PUCCH format Value: 0 -> 1 0: PUCCH Format0 1: PUCCH Format1
@@ -1529,7 +1529,7 @@ typedef struct
 //PUCCH PDU Format 2/3/4
 typedef struct
 {
-  uint8_t  pdu_bit_map;
+  uint8_t  pduBitmap;
   uint32_t handle;
   uint16_t rnti;
   uint8_t  pucch_format;//PUCCH format Value: 0 -> 2 0: PUCCH Format2 1: PUCCH Format3 2: PUCCH Format4

openair1/PHY/CODING/nr_polar_init.c

@@ -43,11 +43,12 @@ static void nr_polar_init(t_nrPolar_params * *polarParams,
                           uint8_t aggregation_level,
 			  int decoder_flag) {
   t_nrPolar_params *currentPtr = *polarParams;
-  uint16_t aggregation_prime = nr_polar_aggregation_prime(aggregation_level);
+  uint16_t aggregation_prime = (messageType >= 2) ? aggregation_level : nr_polar_aggregation_prime(aggregation_level);
 
   //Parse the list. If the node is already created, return without initialization.
   while (currentPtr != NULL) {
     //printf("currentPtr->idx %d, (%d,%d)\n",currentPtr->idx,currentPtr->payloadBits,currentPtr->encoderLength);
+    LOG_D(PHY,"Looking for index %d\n",(messageType * messageLength * aggregation_prime));
     if (currentPtr->idx == (messageType * messageLength * aggregation_prime)) return;
     else currentPtr = currentPtr->nextPtr;
   }
@@ -57,6 +58,7 @@ static void nr_polar_init(t_nrPolar_params * *polarParams,
   t_nrPolar_params *newPolarInitNode = calloc(sizeof(t_nrPolar_params),1);
 
   if (newPolarInitNode != NULL) {
+    LOG_D(PHY,"Setting new polarParams index %d, messageType %d, messageLength %d, aggregation_prime %d\n",(messageType * messageLength * aggregation_prime),messageType,messageLength,aggregation_prime);
     newPolarInitNode->idx = (messageType * messageLength * aggregation_prime);
     newPolarInitNode->nextPtr = NULL;
     //printf("newPolarInitNode->idx %d, (%d,%d,%d:%d)\n",newPolarInitNode->idx,messageType,messageLength,aggregation_prime,aggregation_level);
@@ -116,6 +118,7 @@ static void nr_polar_init(t_nrPolar_params * *polarParams,
       newPolarInitNode->payloadBits = messageLength;
       newPolarInitNode->crcCorrectionBits = NR_POLAR_PUCCH_CRC_ERROR_CORRECTION_BITS;
       //newPolarInitNode->crc_generator_matrix=crc24c_generator_matrix(newPolarInitNode->payloadBits+newPolarInitNode->crcParityBits);//G_P
+      LOG_D(PHY,"New polar node, encoderLength %d, aggregation_level %d\n",newPolarInitNode->encoderLength,aggregation_level);
     } else {
       AssertFatal(1 == 0, "[nr_polar_init] Incorrect Message Type(%d)", messageType);
     }
@@ -219,16 +222,19 @@ t_nrPolar_params *nr_polar_params (int8_t messageType,
   nr_polar_init(polarList_ext != NULL ? polarList_ext : &polarList, 
 		messageType,messageLength,aggregation_level,decoding_flag);
   t_nrPolar_params *polarParams=polarList_ext != NULL ? *polarList_ext : polarList;
-  const int tag=messageType * messageLength * nr_polar_aggregation_prime(aggregation_level);
+  const int tag=messageType * messageLength * (messageType>=2 ? aggregation_level : nr_polar_aggregation_prime(aggregation_level));
 
+
+	
   while (polarParams != NULL) {
+    LOG_D(PHY,"nr_polar_params : tag %d (from nr_polar_init %d)\n",tag,polarParams->idx);
     if (polarParams->idx == tag)
       return polarParams;
 
     polarParams = polarParams->nextPtr;
   }
 
-  AssertFatal(false,"Polar Init tables internal failure\n");
+  AssertFatal(false,"Polar Init tables internal failure, no polarParams found\n");
   return NULL;
 }
 

openair1/PHY/NR_UE_TRANSPORT/pucch_nr.c

@@ -798,8 +798,8 @@ void nr_generate_pucch1_old(PHY_VARS_NR_UE *ue,
 }
 #endif //0
 
-inline void nr_pucch2_3_4_scrambling(uint16_t M_bit,uint16_t rnti,uint16_t n_id,uint32_t B,uint8_t *btilde) __attribute__((always_inline));
-inline void nr_pucch2_3_4_scrambling(uint16_t M_bit,uint16_t rnti,uint16_t n_id,uint32_t B,uint8_t *btilde) {
+inline void nr_pucch2_3_4_scrambling(uint16_t M_bit,uint16_t rnti,uint16_t n_id,uint64_t *B64,uint8_t *btilde) __attribute__((always_inline));
+inline void nr_pucch2_3_4_scrambling(uint16_t M_bit,uint16_t rnti,uint16_t n_id,uint64_t *B64,uint8_t *btilde) {
   uint32_t x1, x2, s=0;
   int i;
   uint8_t c;
@@ -807,14 +807,26 @@ inline void nr_pucch2_3_4_scrambling(uint16_t M_bit,uint16_t rnti,uint16_t n_id,
   //x2 = (rnti) + ((uint32_t)(1+nr_tti_tx)<<16)*(1+(fp->Nid_cell<<1));
   x2 = ((rnti)<<15)+n_id;
 #ifdef DEBUG_NR_PUCCH_TX
-  printf("\t\t [nr_pucch2_3_4_scrambling] gold sequence s=%x\n",s);
+  printf("\t\t [nr_pucch2_3_4_scrambling] gold sequence s=%x, M_bit %d\n",s,M_bit);
 #endif
 
   uint8_t *btildep=btilde;
   int M_bit2=M_bit > 31 ? 32 : (M_bit&31), M_bit3=M_bit;
+  uint32_t B;
   for (int iprime=0;iprime<=(M_bit>>5);iprime++,btildep+=32) {
     s = lte_gold_generic(&x1, &x2, (iprime==0) ? 1 : 0);
-
+    B=((uint32_t*)B64)[iprime];
+    for (int n=0;n<M_bit2;n+=8)
+      LOG_D(PHY,"PUCCH2 encoded %d : %d,%d,%d,%d,%d,%d,%d,%d\n",n,
+	    (B>>n)&1,
+	    (B>>(n+1))&1,
+	    (B>>(n+2))&1,
+	    (B>>(n+3))&1,
+	    (B>>(n+4))&1,
+	    (B>>(n+5))&1,
+	    (B>>(n+6))&1,
+	    (B>>(n+7))&1
+	    );
     for (i=0; i<M_bit2; i++) {
       c = (uint8_t)((s>>i)&1);
       btildep[i] = (((B>>i)&1) ^ c);
@@ -946,7 +958,7 @@ void nr_generate_pucch2(PHY_VARS_NR_UE *ue,
   printf("\t [nr_generate_pucch2] start function at slot(nr_tti_tx)=%d  with payload=%lu and nr_bit=%d\n",nr_tti_tx, payload, nr_bit);
 #endif
   // b is the block of bits transmitted on the physical channel after payload coding
-  uint64_t b;
+  uint64_t b[16]; // limit to 1024-bit encoded length
   // M_bit is the number of bits of block b (payload after encoding)
   uint16_t M_bit;
   nr_uci_encoding(payload,nr_bit,pucch_format2_nr,0,nrofSymbols,nrofPRB,1,0,0,&b,&M_bit);

openair1/PHY/defs_gNB.h

@@ -667,6 +667,8 @@ typedef struct PHY_VARS_gNB_s {
   NR_gNB_ULSCH_t     *ulsch[NUMBER_OF_NR_ULSCH_MAX][2];  // [Nusers times][2 codewords] 
   NR_gNB_DLSCH_t     *dlsch_SI,*dlsch_ra,*dlsch_p;
   NR_gNB_DLSCH_t     *dlsch_PCH;
+  t_nrPolar_params    *uci_polarParams;
+
   uint8_t pbch_configured;
   char gNB_generate_rar;
 

openair1/SIMULATION/NR_PHY/pucchsim.c

@@ -457,6 +457,8 @@ int main(int argc, char **argv)
   pucch_GroupHopping_t PUCCH_GroupHopping=UE->pucch_config_common_nr->pucch_GroupHopping;
   uint32_t hopping_id=UE->pucch_config_common_nr->hoppingId;
   uint32_t dmrs_scrambling_id = 0, data_scrambling_id=0;
+  t_nrPolar_params *currentPtr;
+
   if(format==0){
   // for now we are not considering SR just HARQ-ACK
     if (nr_bit ==0) 
@@ -467,7 +469,8 @@ int main(int argc, char **argv)
       mcs=table2_mcs[actual_payload];
     else AssertFatal(1==0,"Either nr_bit %d or sr_flag %d must be non-zero\n");
   }
-
+  else if (format == 2 && nr_bit > 11) gNB->uci_polarParams = nr_polar_params(2, nr_bit, nrofPRB, 1, NULL);
+  
   for(SNR=snr0;SNR<=snr1;SNR=SNR+1){
     ack_nack_errors=0;
     n_errors = 0;
@@ -506,6 +509,8 @@ int main(int argc, char **argv)
 	pucch_pdu.group_hop_flag        = PUCCH_GroupHopping&1;
 	pucch_pdu.sequence_hop_flag     = (PUCCH_GroupHopping>>1)&1;
 	pucch_pdu.bit_len_harq          = nr_bit;
+	pucch_pdu.bit_len_csi_part1     = 0;
+	pucch_pdu.bit_len_csi_part2     = 0;
 	pucch_pdu.sr_flag               = sr_flag;
 	pucch_pdu.nr_of_symbols         = nrofSymbols;
 	pucch_pdu.hopping_id            = hopping_id;
@@ -534,7 +539,9 @@ int main(int argc, char **argv)
 	pucch_pdu.subcarrier_spacing    = 1;
 	pucch_pdu.group_hop_flag        = PUCCH_GroupHopping&1;
 	pucch_pdu.sequence_hop_flag     = (PUCCH_GroupHopping>>1)&1;
-	pucch_pdu.bit_len_harq          = nr_bit;
+	pucch_pdu.bit_len_csi_part1     = nr_bit;
+	pucch_pdu.bit_len_harq          = 0;
+	pucch_pdu.bit_len_csi_part2     = 0;
 	pucch_pdu.sr_flag               = 0;
 	pucch_pdu.nr_of_symbols         = nrofSymbols;
 	pucch_pdu.hopping_id            = hopping_id;
@@ -545,14 +552,15 @@ int main(int argc, char **argv)
 	pucch_pdu.dmrs_scrambling_id    = dmrs_scrambling_id;
 	pucch_pdu.data_scrambling_id    = data_scrambling_id;
         nr_decode_pucch2(gNB,nr_tti_tx,&uci_pdu,&pucch_pdu);
-	int harq_bytes=pucch_pdu.bit_len_harq>>3;
-	if ((pucch_pdu.bit_len_harq&7) > 0) harq_bytes++;
-	for (int i=0;i<harq_bytes;i++)
-	  if (uci_pdu.harq.harq_payload[i] != ((int8_t*)&actual_payload)[i]) {
+	int csi_part1_bytes=pucch_pdu.bit_len_csi_part1>>3;
+	if ((pucch_pdu.bit_len_csi_part1&7) > 0) csi_part1_bytes++;
+	for (int i=0;i<csi_part1_bytes;i++) {
+	  if (uci_pdu.csi_part1.csi_part1_payload[i] != ((uint8_t*)&actual_payload)[i]) {
 	    ack_nack_errors++;
 	    break;
 	  }
-	free(uci_pdu.harq.harq_payload);
+	}
+	free(uci_pdu.csi_part1.csi_part1_payload);
 
       }
       n_errors=((actual_payload^payload_received)&1)+(((actual_payload^payload_received)&2)>>1)+(((actual_payload^payload_received)&4)>>2)+n_errors;