changing paramters for demo

Working PBCH version

cmake_targets/autotests/test_case_list.xml

@@ -1035,14 +1035,16 @@
 
     <testCase id="015103">
       <class>execution</class>
-      <desc>polartest Test cases. (Test1: PBCH polar test)</desc>
+      <desc>polartest Test cases. (Test1: PBCH polar test),
+                                  (Test2: DCI polar test)</desc>
       <pre_compile_prog></pre_compile_prog>
       <compile_prog>$OPENAIR_DIR/cmake_targets/build_oai</compile_prog>
       <compile_prog_args> --phy_simulators  -c </compile_prog_args>
       <pre_exec>$OPENAIR_DIR/cmake_targets/autotests/tools/free_mem.bash</pre_exec>
       <pre_exec_args></pre_exec_args>
       <main_exec> $OPENAIR_DIR/targets/bin/polartest.Rel15</main_exec>
-      <main_exec_args>-q -s-10 -f0</main_exec_args>
+      <main_exec_args>-q -s-10 -f0
+                      -q -s-10 -f0 -m1</main_exec_args>
       <tags>polartest.test1</tags>
       <search_expr_true>BLER= 0.000000</search_expr_true>
       <search_expr_false>segmentation fault|assertion|exiting|fatal</search_expr_false>

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

@@ -72,7 +72,7 @@ typedef struct
 
   // These TLVs are used by the VNF to configure the RF in the PNF
   // nfapi_uint16_tlv_t max_transmit_power;
-  nfapi_uint16_tlv_t earfcn;
+  nfapi_uint16_tlv_t nrarfcn;
 
   // nfapi_nmm_frequency_bands_t nmm_gsm_frequency_bands;
   // nfapi_nmm_frequency_bands_t nmm_umts_frequency_bands;
@@ -95,7 +95,7 @@ typedef struct
 #define NFAPI_NR_NFAPI_TIMING_INFO_MODE_TAG 0x511F
 #define NFAPI_NR_NFAPI_TIMING_INFO_PERIOD_TAG 0x5120
 #define NFAPI_NR_NFAPI_MAXIMUM_TRANSMIT_POWER_TAG 0x5128
-#define NFAPI_NR_NFAPI_EARFCN_TAG 0x5129
+#define NFAPI_NR_NFAPI_NRARFCN_TAG 0x5129
 #define NFAPI_NR_NFAPI_NMM_GSM_FREQUENCY_BANDS_TAG 0x5130
 #define NFAPI_NR_NFAPI_NMM_UMTS_FREQUENCY_BANDS_TAG 0x5131
 #define NFAPI_NR_NFAPI_NMM_LTE_FREQUENCY_BANDS_TAG 0x5132
@@ -511,6 +511,8 @@ typedef struct {
   uint16_t rnti;
   uint8_t rnti_type;
   uint8_t dci_format;
+  /// Number of CRB in BWP that this DCI configures 
+  uint8_t n_RB_BWP;
   uint8_t config_type;
   uint8_t search_space_type;
   uint8_t common_search_space_type;  

openair1/PHY/CODING/TESTBENCH/ldpctest.c

@@ -310,19 +310,21 @@ int test_ldpc(short No_iteration,
     }
     stop_meas(&time);
 
-/*    start_meas(time_optim);
+    start_meas(time_optim);
     ldpc_encoder_optim_8seg(test_input,channel_input_optim,block_length,BG,n_segments,&tinput,&tprep,&tparity,&toutput);
-    for(j=0;j<n_segments;j++) {
+    /*
+      for(j=0;j<n_segments;j++) {
       ldpc_encoder_optim(test_input[j],channel_input_optim[j],block_length,BG,&tinput,&tprep,&tparity,&toutput);
       }
-    stop_meas(time_optim);*/
-
+    */
+    stop_meas(time_optim);
+    /*
     for(j=0;j<(n_segments%8+1);j++) {
     	start_meas(time_optim);
     	ldpc_encoder_optim_8seg_multi(test_input,channel_input_optim,block_length, BG, n_segments,j,&tinput,&tprep,&tparity,&toutput);
     	stop_meas(time_optim);
     }
-    
+    */  
     if (ntrials==1)    
       for (j=0;j<n_segments;j++)
     for (i = 0; i < block_length+(nrows-no_punctured_columns) * Zc - removed_bit; i++)
@@ -416,6 +418,11 @@ int test_ldpc(short No_iteration,
 	stop_meas(time_decoder);
       }
 
+<<<<<<< HEAD
+=======
+      n_iter = nrLDPC_decoder(&decParams, (int8_t*) channel_output_fixed, (int8_t*) estimated_output, NULL);
+      printf("nrLDPC_decoder n_iter=%d\n",n_iter);
+>>>>>>> florian/nr-polar-encoder-optimizations-florian
 
       //for (i=(Kb+nrows) * Zc-5;i<(Kb+nrows) * Zc;i++)
       //  printf("esimated_output[%d]=%d\n",i,esimated_output[i]);
@@ -430,11 +437,17 @@ int test_ldpc(short No_iteration,
           ///printf("test_input[0][%d]: %d \n",i,test_input[0][i]);
         if (estimated_output[j][i] != test_input[j][i])
         {
+<<<<<<< HEAD
 
 
       //////printf("error pos %d (%d, %d)\n\n",i,estimated_output[i],test_input[0][i]);
           segment_bler = segment_bler + 1;
           break;
+=======
+        	printf("error pos %d (%d, %d)\n",i,estimated_output[i],test_input[0][i]);
+        	*errors = (*errors) + 1;
+        	break;
+>>>>>>> florian/nr-polar-encoder-optimizations-florian
         }
       }
 

openair1/PHY/CODING/TESTBENCH/polartest.c

@@ -20,11 +20,8 @@ int main(int argc, char *argv[]) {
 
 	//Initiate timing. (Results depend on CPU Frequency. Therefore, might change due to performance variances during simulation.)
 	time_stats_t timeEncoder,timeDecoder;
-	time_stats_t polar_decoder_init,polar_rate_matching,decoding,bit_extraction,deinterleaving;
-	time_stats_t path_metric,sorting,update_LLR;
 	opp_enabled=1;
 	int decoder_int16=0;
-	int generate_optim_code=0;
 	cpu_freq_GHz = get_cpu_freq_GHz();
 	reset_meas(&timeEncoder);
 	reset_meas(&timeDecoder);
@@ -37,7 +34,7 @@ int main(int argc, char *argv[]) {
 
 	double SNR, SNR_lin;
 	int16_t nBitError = 0; // -1 = Decoding failed (All list entries have failed the CRC checks).
-	int8_t decoderState=0, blockErrorState=0; //0 = Success, -1 = Decoding failed, 1 = Block Error.
+	uint32_t decoderState=0, blockErrorState=0; //0 = Success, -1 = Decoding failed, 1 = Block Error.
 	uint16_t testLength = 0, coderLength = 0, blockErrorCumulative=0, bitErrorCumulative=0;
 	double timeEncoderCumulative = 0, timeDecoderCumulative = 0;
 	uint8_t aggregation_level = 8, decoderListSize = 8, pathMetricAppr = 0;
@@ -73,21 +70,20 @@ int main(int argc, char *argv[]) {
 			pathMetricAppr = (uint8_t) atoi(optarg);
 			break;
 
-  	        case 'q':
-		        decoder_int16=1;
-		        break;
+		case 'q':
+			decoder_int16 = 1;
+			break;
 
-    	        case 'g':
-		  generate_optim_code=1;
-                  iterations=1;
-		  SNRstart=-6.0;
-		  SNRstop =-6.0;
-		  decoder_int16=1;
-                  break;
+		case 'g':
+			iterations = 1;
+			SNRstart = -6.0;
+			SNRstop = -6.0;
+			decoder_int16 = 1;
+			break;
 
-	        case 'h':
-		  printf("./polartest -s SNRstart -d SNRinc -f SNRstop -m [0=PBCH|1=DCI|2=UCI] -i iterations -l decoderListSize -a pathMetricAppr -q (use fixed point decoder)\n");
-		  exit(-1);
+		case 'h':
+			printf("./polartest -s SNRstart -d SNRinc -f SNRstop -m [0=PBCH|1=DCI|2=UCI] -i iterations -l decoderListSize -a pathMetricAppr\n");
+			exit(-1);
 
 		default:
 			perror("[polartest.c] Problem at argument parsing with getopt");
@@ -95,13 +91,13 @@ int main(int argc, char *argv[]) {
 	}
 
 	if (polarMessageType == 0) { //PBCH
-		testLength = NR_POLAR_PBCH_PAYLOAD_BITS;
+	  testLength = 64;//NR_POLAR_PBCH_PAYLOAD_BITS;
 		coderLength = NR_POLAR_PBCH_E;
 		aggregation_level = NR_POLAR_PBCH_AGGREGATION_LEVEL;
 	} else if (polarMessageType == 1) { //DCI
 		//testLength = nr_get_dci_size(params_rel15->dci_format, params_rel15->rnti_type, &fp->initial_bwp_dl, cfg);
-		testLength = 20;
-		coderLength = 108; //to be changed by aggregate level function.
+	  testLength = 41; //20;
+	  coderLength = 108*8; //to be changed by aggregate level function.
 	} else if (polarMessageType == -1) { //UCI
 		//testLength = ;
 		//coderLength = ;
@@ -149,18 +145,18 @@ int main(int argc, char *argv[]) {
     uint8_t testArrayLength = ceil(testLength / 32.0);
     uint8_t coderArrayLength = ceil(coderLength / 32.0);
 
-	uint32_t *testInput = malloc(sizeof(uint32_t) * testArrayLength); //generate randomly
-	uint32_t *encoderOutput = malloc(sizeof(uint32_t) * coderArrayLength);
-	uint32_t *estimatedOutput = malloc(sizeof(uint32_t) * testArrayLength); //decoder output
+	uint32_t testInput[testArrayLength]; //generate randomly
+	uint32_t encoderOutput[coderArrayLength];
+	uint32_t estimatedOutput[testArrayLength]; //decoder output
 	memset(testInput,0,sizeof(uint32_t) * testArrayLength);
 	memset(encoderOutput,0,sizeof(uint32_t) * coderArrayLength);
 	memset(estimatedOutput,0,sizeof(uint32_t) * testArrayLength);
 
-	uint8_t *encoderOutputByte = malloc(sizeof(uint8_t) * coderLength);
-	double *modulatedInput = malloc (sizeof(double) * coderLength); //channel input
-	double *channelOutput  = malloc (sizeof(double) * coderLength); //add noise
-	int16_t *channelOutput_int16;
-	if (decoder_int16 == 1) channelOutput_int16 = (int16_t*)malloc (sizeof(int16_t) * coderLength);
+	uint8_t encoderOutputByte[coderLength];
+	double modulatedInput[coderLength]; //channel input
+	double channelOutput[coderLength];  //add noise
+
+	int16_t channelOutput_int16[coderLength];
  
 	t_nrPolar_paramsPtr nrPolar_params = NULL, currentPtr = NULL;
 	nr_polar_init(&nrPolar_params, polarMessageType, testLength, aggregation_level);
@@ -211,6 +207,8 @@ int main(int argc, char *argv[]) {
 									 rnti);
 	printf("dci_estimation: [0]->0x%08x \t [1]->0x%08x \t [2]->0x%08x \t [3]->0x%08x\n",
 			dci_estimation[0], dci_estimation[1], dci_estimation[2], dci_estimation[3]);
+	free(encoder_outputByte);
+	free(channel_output);
 	return 0;
 #endif
 
@@ -270,7 +268,7 @@ int main(int argc, char *argv[]) {
     uint8_t nr_polar_A[32] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,1};
     uint8_t nr_polar_crc[24];
     uint8_t **crc_generator_matrix = crc24c_generator_matrix(32);
-	nr_matrix_multiplication_uint8_t_1D_uint8_t_2D(nr_polar_A,
+	nr_matrix_multiplication_uint8_1D_uint8_2D(nr_polar_A,
 												   crc_generator_matrix,
 												   nr_polar_crc,
 												   32,
@@ -326,10 +324,18 @@ int main(int argc, char *argv[]) {
 			for (int i=0; i<32; i++)
 				printf("%d\n",(testInput[0]>>i)&1);*/
 
-			start_meas(&timeEncoder);
-			polar_encoder(testInput, encoderOutput, currentPtr);
-			stop_meas(&timeEncoder);
 
+
+			int len_mod64=currentPtr->payloadBits&63;
+			((uint64_t*)testInput)[currentPtr->payloadBits/64]&=((((uint64_t)1)<<len_mod64)-1);
+
+			start_meas(&timeEncoder);
+			if (decoder_int16==0)
+			  polar_encoder(testInput, encoderOutput, currentPtr);
+			else
+				polar_encoder_fast((uint64_t*)testInput, encoderOutput,0, currentPtr);
+			  //polar_encoder_fast((uint64_t*)testInput, (uint64_t*)encoderOutput,0, currentPtr);
+			stop_meas(&timeEncoder);
 			/*printf("encoderOutput: [0]->0x%08x\n", encoderOutput[0]);
 			printf("encoderOutput: [1]->0x%08x\n", encoderOutput[1]);*/
 
@@ -371,7 +377,7 @@ int main(int argc, char *argv[]) {
 							       aPrioriArray);
 			else 
 			  decoderState = polar_decoder_int16(channelOutput_int16,
-							     estimatedOutput,
+							     (uint64_t*)estimatedOutput,
 							     currentPtr);
 
 			  
@@ -381,17 +387,20 @@ int main(int argc, char *argv[]) {
 
 
 			//calculate errors
-			if (decoderState==-1) {
+			if (decoderState!=0) {
 				blockErrorState=-1;
 				nBitError=-1;
 			} else {
-				for (int i = 0; i < testArrayLength; i++) {
-					for (int j = 0; j < (sizeof(testInput[0])*8); j++) {
-						if (((estimatedOutput[i]>>j) & 1) != ((testInput[i]>>j) & 1)) nBitError++;
-					}
-				}
+			  for (int j = 0; j < currentPtr->payloadBits; j++) {
+			    if (((estimatedOutput[0]>>j) & 1) != ((testInput[0]>>j) & 1)) nBitError++;
+			    //			    printf("bit %d: %d => %d\n",j,(testInput[0]>>j)&1,(estimatedOutput[0]>>j)&1);
+			  }
+			
 
-				if (nBitError>0) blockErrorState=1;
+			  if (nBitError>0) { 
+			    blockErrorState=1; 
+			    //			    printf("Error: Input %x, Output %x\n",testInput[0],estimatedOutput[0]);
+			  }
 			}
 
 			//Iteration times are in microseconds.
@@ -417,7 +426,8 @@ int main(int argc, char *argv[]) {
 		printf("[ListSize=%d, Appr=%d] SNR=%+8.3f, BLER=%9.6f, BER=%12.9f, t_Encoder=%9.3fus, t_Decoder=%9.3fus\n",
 				decoderListSize, pathMetricAppr, SNR, ((double)blockErrorCumulative/iterations),
 				((double)bitErrorCumulative / (iterations*testLength)),
-				(timeEncoderCumulative/iterations),timeDecoderCumulative/iterations);
+		       (double)timeEncoder.diff/timeEncoder.trials/(cpu_freq_GHz*1000.0),(double)timeDecoder.diff/timeDecoder.trials/(cpu_freq_GHz*1000.0));
+		       //(timeEncoderCumulative/iterations),timeDecoderCumulative/iterations);
 
 		if (blockErrorCumulative==0 && bitErrorCumulative==0)
 		  break;
@@ -430,14 +440,5 @@ int main(int argc, char *argv[]) {
 	print_meas(&timeDecoder,"polar_decoder",NULL,NULL);
 
 	fclose(logFile);
-	//Bit
-	free(testInput);
-	free(encoderOutput);
-	free(estimatedOutput);
-	//Byte
-	free(encoderOutputByte);
-	free(modulatedInput);
-	free(channelOutput);
-
 	return (0);
 }

openair1/PHY/CODING/coding_defs.h

@@ -342,7 +342,7 @@ void ccodedab_init_inv(void);
 
 /*!\fn void crcTableInit(void)
 \brief This function initializes the different crc tables.*/
-//void crcTableInit (void);
+void crcTableInit (void);
 
 
 

openair1/PHY/CODING/crc_byte.c

@@ -58,8 +58,8 @@ The first bit is in the MSB of each byte
 
 *********************************************************/
 unsigned int crcbit (unsigned char * inputptr,
-					 int octetlen,
-					 unsigned int poly)
+		     int octetlen,
+		     unsigned int poly)
 {
   unsigned int i, crc = 0, c;
 
@@ -170,14 +170,12 @@ unsigned int crc24c (unsigned char * inptr,
   resbit = (bitlen % 8);
 
   while (octetlen-- > 0) {
-/*#ifdef DEBUG_CRC24C
-	  printf("crc24c: in %x => crc %x (%x)\n",crc,*inptr,crc24cTable[(*inptr) ^ (crc >> 24)]);
-#endif*/
     crc = (crc << 8) ^ crc24cTable[(*inptr++) ^ (crc >> 24)];
   }
 
-  if (resbit > 0)
+  if (resbit > 0) {
     crc = (crc << resbit) ^ crc24cTable[((*inptr) >> (8 - resbit)) ^ (crc >> (32 - resbit))];
+  }
 
   return crc;
 }

openair1/PHY/CODING/nrLDPC_encoder/ldpc_encoder2.c

@@ -201,7 +201,13 @@ void encode_parity_check_part_optim(uint8_t *c,uint8_t *d, short BG,short Zc,sho
 int ldpc_encoder_optim(unsigned char *test_input,unsigned char *channel_input,short block_length,short BG,time_stats_t *tinput,time_stats_t *tprep,time_stats_t *tparity,time_stats_t *toutput)
 {
 
-  short Zc,Kb,nrows,ncols;
+  short Zc;
+
+  //initialize for BG == 1
+  short Kb = 22;
+  short nrows = 46;//parity check bits
+  short ncols = 22;//info bits
+
   int i,i1;
   int no_punctured_columns,removed_bit;
 
@@ -211,31 +217,20 @@ int ldpc_encoder_optim(unsigned char *test_input,unsigned char *channel_input,sh
   int simd_size;
 
   //determine number of bits in codeword
-  //determine number of bits in codeword
-   //if (block_length>3840)
-   if (BG==1)
-     {
-       //BG=1;
-       Kb = 22;
-       nrows=46; //parity check bits
-       ncols=22; //info bits
-     }
-     //else if (block_length<=3840)
-    else if	(BG==2)
-     {
-       //BG=2;
-       nrows=42; //parity check bits
-       ncols=10; // info bits
-
-       if (block_length>640)
- 	Kb = 10;
-       else if (block_length>560)
- 	Kb = 9;
-       else if (block_length>192)
-       Kb = 8;
-     else
-       Kb = 6;
-       }
+    if (BG==2)
+    {
+      nrows=42; //parity check bits
+      ncols=10; // info bits
+      
+      if (block_length>640)
+	Kb = 10;
+      else if (block_length>560)
+	Kb = 9;
+      else if (block_length>192)
+      Kb = 8;
+    else
+      Kb = 6;
+    }
 
   //find minimum value in all sets of lifting size
   Zc=0;
@@ -256,7 +251,7 @@ int ldpc_encoder_optim(unsigned char *test_input,unsigned char *channel_input,sh
 #endif
 
   if ((Zc&31) > 0) simd_size = 16;
-  else          simd_size = 32;
+  else simd_size = 32;
 
   unsigned char c[22*Zc] __attribute__((aligned(32))); //padded input, unpacked, max size
   unsigned char d[46*Zc] __attribute__((aligned(32))); //coded parity part output, unpacked, max size
@@ -321,7 +316,13 @@ int ldpc_encoder_optim(unsigned char *test_input,unsigned char *channel_input,sh
 int ldpc_encoder_optim_8seg(unsigned char **test_input,unsigned char **channel_input,short block_length,short BG,int n_segments,time_stats_t *tinput,time_stats_t *tprep,time_stats_t *tparity,time_stats_t *toutput)
 {
 
-  short Zc,Kb,nrows,ncols;
+  short Zc;
+
+  //initialize for BG == 1
+  short Kb = 22;
+  short nrows = 46;//parity check bits
+  short ncols = 22;//info bits
+
   int i,i1,j;
   int no_punctured_columns,removed_bit;
   //Table of possible lifting sizes
@@ -348,16 +349,7 @@ int ldpc_encoder_optim_8seg(unsigned char **test_input,unsigned char **channel_i
   AssertFatal(n_segments>0&&n_segments<=8,"0 < n_segments %d <= 8\n",n_segments);
 
   //determine number of bits in codeword
-  //if (block_length>3840)
-  if (BG==1)
-    {
-      //BG=1;
-      Kb = 22;
-      nrows=46; //parity check bits
-      ncols=22; //info bits
-    }
-    //else if (block_length<=3840)
-   else if	(BG==2)
+    if (BG==2)
     {
       //BG=2;
       nrows=42; //parity check bits

openair1/PHY/CODING/nrLDPC_encoder/ldpc_generate_coefficient.c

@@ -367,7 +367,13 @@ int ldpc_encoder_orig(unsigned char *test_input,unsigned char *channel_input,sho
   unsigned char d[68*384]; //coded output, unpacked, max size
   unsigned char channel_temp,temp;
   short *Gen_shift_values, *no_shift_values, *pointer_shift_values;
-  short Zc,Kb,nrows,ncols;
+  short Zc;
+  //initialize for BG == 1
+  short Kb = 22;
+  short nrows = 46;//parity check bits
+  short ncols = 22;//info bits
+
+
   int i,i1,i2,i3,i4,i5,temp_prime,var;
   int no_punctured_columns,removed_bit;
   //Table of possible lifting sizes
@@ -378,30 +384,20 @@ int ldpc_encoder_orig(unsigned char *test_input,unsigned char *channel_input,sho
   int indlist2[1000];
 
   //determine number of bits in codeword
-  //if (block_length>3840)
-     if (BG==1)
-       {
-         //BG=1;
-         Kb = 22;
-         nrows=46; //parity check bits
-         ncols=22; //info bits
-       }
-       //else if (block_length<=3840)
-      else if	(BG==2)
-       {
-         //BG=2;
-         nrows=42; //parity check bits
-         ncols=10; // info bits
+  if (BG==2)
+  {
+    nrows=42;  //parity check bits
+    ncols=10;  // info bits
 
-         if (block_length>640)
-   	Kb = 10;
-         else if (block_length>560)
-   	Kb = 9;
-         else if (block_length>192)
-         Kb = 8;
-       else
-         Kb = 6;
-         }
+    if (block_length>640)
+      Kb = 10;
+    else if (block_length>560)
+      Kb = 9;
+    else if (block_length>192)
+      Kb = 8;
+    else
+      Kb = 6;
+  }
 
   //find minimum value in all sets of lifting size
   Zc=0;
@@ -419,6 +415,8 @@ int ldpc_encoder_orig(unsigned char *test_input,unsigned char *channel_input,sho
     return(-1);
   }
 
+  //int K = ncols*Zc; //unused variable
+
   Gen_shift_values=choose_generator_matrix(BG,Zc);
   if (Gen_shift_values==NULL) {
     printf("ldpc_encoder_orig: could not find generator matrix\n");

openair1/PHY/CODING/nrPolar_tools/nr_polar_decoder.c

@@ -37,7 +37,7 @@
  */
 
 #include "PHY/CODING/nrPolar_tools/nr_polar_defs.h"
-
+#include "assertions.h"
 
 int8_t polar_decoder(
 		double *input,
@@ -48,11 +48,11 @@ int8_t polar_decoder(
 {
 	//Assumes no a priori knowledge.
 
-	uint8_t ***bit = nr_alloc_uint8_t_3D_array(polarParams->N, (polarParams->n+1), 2*listSize);
-	uint8_t **bitUpdated = nr_alloc_uint8_t_2D_array(polarParams->N, (polarParams->n+1)); //0=False, 1=True
-	uint8_t **llrUpdated = nr_alloc_uint8_t_2D_array(polarParams->N, (polarParams->n+1)); //0=False, 1=True
+	uint8_t ***bit = nr_alloc_uint8_3D_array(polarParams->N, (polarParams->n+1), 2*listSize);
+	uint8_t **bitUpdated = nr_alloc_uint8_2D_array(polarParams->N, (polarParams->n+1)); //0=False, 1=True
+	uint8_t **llrUpdated = nr_alloc_uint8_2D_array(polarParams->N, (polarParams->n+1)); //0=False, 1=True
 	double ***llr = nr_alloc_double_3D_array(polarParams->N, (polarParams->n+1), 2*listSize);
-	uint8_t **crcChecksum = nr_alloc_uint8_t_2D_array(polarParams->crcParityBits, 2*listSize);
+	uint8_t **crcChecksum = nr_alloc_uint8_2D_array(polarParams->crcParityBits, 2*listSize);
 	double *pathMetric = malloc(sizeof(double)*(2*listSize));
 	uint8_t *crcState = malloc(sizeof(uint8_t)*(2*listSize)); //0=False, 1=True
 
@@ -231,9 +231,9 @@ int8_t polar_decoder(
 				free(d_tilde);
 				free(pathMetric);
 				free(crcState);
-				nr_free_uint8_t_3D_array(bit, polarParams->N, (polarParams->n+1));
+				nr_free_uint8_3D_array(bit, polarParams->N, (polarParams->n+1));
 				nr_free_double_3D_array(llr, polarParams->N, (polarParams->n+1));
-				nr_free_uint8_t_2D_array(crcChecksum, polarParams->crcParityBits);
+				nr_free_uint8_2D_array(crcChecksum, polarParams->crcParityBits);
 				return(-1);
 			}
 
@@ -256,6 +256,7 @@ int8_t polar_decoder(
 			//Deinterleaving (ĉ to b)
 			nr_polar_deinterleaver(polarParams->nr_polar_CPrime, polarParams->nr_polar_B, polarParams->interleaving_pattern, polarParams->K);
 
+			
 			//Remove the CRC (â)
 			for (int j = 0; j < polarParams->payloadBits; j++) polarParams->nr_polar_A[j]=polarParams->nr_polar_B[j];
 
@@ -266,11 +267,11 @@ int8_t polar_decoder(
 	free(d_tilde);
 	free(pathMetric);
 	free(crcState);
-	nr_free_uint8_t_3D_array(bit, polarParams->N, (polarParams->n+1));
+	nr_free_uint8_3D_array(bit, polarParams->N, (polarParams->n+1));
 	nr_free_double_3D_array(llr, polarParams->N, (polarParams->n+1));
-	nr_free_uint8_t_2D_array(crcChecksum, polarParams->crcParityBits);
-	nr_free_uint8_t_2D_array(extended_crc_generator_matrix, polarParams->K);
-	nr_free_uint8_t_2D_array(tempECGM, polarParams->K);
+	nr_free_uint8_2D_array(crcChecksum, polarParams->crcParityBits);
+	nr_free_uint8_2D_array(extended_crc_generator_matrix, polarParams->K);
+	nr_free_uint8_2D_array(tempECGM, polarParams->K);
 
 	/*
 	 * Return bits.
@@ -280,17 +281,17 @@ int8_t polar_decoder(
 }
 
 int8_t polar_decoder_aPriori(double *input,
-							 uint32_t *out,
-							 t_nrPolar_paramsPtr polarParams,
-							 uint8_t listSize,
-							 uint8_t pathMetricAppr,
-							 double *aPrioriPayload)
+			     uint32_t *out,
+			     t_nrPolar_paramsPtr polarParams,
+			     uint8_t listSize,
+			     uint8_t pathMetricAppr,
+			     double *aPrioriPayload)
 {
-	uint8_t ***bit = nr_alloc_uint8_t_3D_array(polarParams->N, (polarParams->n+1), 2*listSize);
-	uint8_t **bitUpdated = nr_alloc_uint8_t_2D_array(polarParams->N, (polarParams->n+1)); //0=False, 1=True
-	uint8_t **llrUpdated = nr_alloc_uint8_t_2D_array(polarParams->N, (polarParams->n+1)); //0=False, 1=True
+  uint8_t ***bit = nr_alloc_uint8_3D_array(polarParams->N, (polarParams->n+1), 2*listSize);
+	uint8_t **bitUpdated = nr_alloc_uint8_2D_array(polarParams->N, (polarParams->n+1)); //0=False, 1=True
+	uint8_t **llrUpdated = nr_alloc_uint8_2D_array(polarParams->N, (polarParams->n+1)); //0=False, 1=True
 	double ***llr = nr_alloc_double_3D_array(polarParams->N, (polarParams->n+1), 2*listSize);
-	uint8_t **crcChecksum = nr_alloc_uint8_t_2D_array(polarParams->crcParityBits, 2*listSize);
+	uint8_t **crcChecksum = nr_alloc_uint8_2D_array(polarParams->crcParityBits, 2*listSize);
 	double *pathMetric = malloc(sizeof(double)*(2*listSize));
 	uint8_t *crcState = malloc(sizeof(uint8_t)*(2*listSize)); //0=False, 1=True
 
@@ -483,9 +484,9 @@ int8_t polar_decoder_aPriori(double *input,
 				free(d_tilde);
 				free(pathMetric);
 				free(crcState);
-				nr_free_uint8_t_3D_array(bit, polarParams->N, (polarParams->n+1));
+				nr_free_uint8_3D_array(bit, polarParams->N, (polarParams->n+1));
 				nr_free_double_3D_array(llr, polarParams->N, (polarParams->n+1));
-				nr_free_uint8_t_2D_array(crcChecksum, polarParams->crcParityBits);
+				nr_free_uint8_2D_array(crcChecksum, polarParams->crcParityBits);
 				return(-1);
 			}
 
@@ -509,8 +510,8 @@ int8_t polar_decoder_aPriori(double *input,
 			nr_polar_deinterleaver(polarParams->nr_polar_CPrime, polarParams->nr_polar_B, polarParams->interleaving_pattern, polarParams->K);
 
 			//Remove the CRC (â)
-			for (int j = 0; j < polarParams->payloadBits; j++) polarParams->nr_polar_A[j]=polarParams->nr_polar_B[j];
-
+			for (int j = 0; j < polarParams->payloadBits; j++)
+			  polarParams->nr_polar_A[j]=polarParams->nr_polar_B[j];
 			break;
 		}
 	}
@@ -518,16 +519,17 @@ int8_t polar_decoder_aPriori(double *input,
 	free(d_tilde);
 	free(pathMetric);
 	free(crcState);
-	nr_free_uint8_t_3D_array(bit, polarParams->N, (polarParams->n+1));
+	nr_free_uint8_3D_array(bit, polarParams->N, (polarParams->n+1));
 	nr_free_double_3D_array(llr, polarParams->N, (polarParams->n+1));
-	nr_free_uint8_t_2D_array(crcChecksum, polarParams->crcParityBits);
-	nr_free_uint8_t_2D_array(extended_crc_generator_matrix, polarParams->K);
-	nr_free_uint8_t_2D_array(tempECGM, polarParams->K);
+	nr_free_uint8_2D_array(crcChecksum, polarParams->crcParityBits);
+	nr_free_uint8_2D_array(extended_crc_generator_matrix, polarParams->K);
+	nr_free_uint8_2D_array(tempECGM, polarParams->K);
 
 	/*
 	 * Return bits.
 	 */
 	nr_byte2bit_uint8_32_t(polarParams->nr_polar_A, polarParams->payloadBits, out);
+
 	return(0);
 
 }
@@ -544,11 +546,11 @@ int8_t polar_decoder_aPriori_timing(double *input,
 									FILE* logFile)
 {
 
-	uint8_t ***bit = nr_alloc_uint8_t_3D_array(polarParams->N, (polarParams->n+1), 2*listSize);
-	uint8_t **bitUpdated = nr_alloc_uint8_t_2D_array(polarParams->N, (polarParams->n+1)); //0=False, 1=True
-	uint8_t **llrUpdated = nr_alloc_uint8_t_2D_array(polarParams->N, (polarParams->n+1)); //0=False, 1=True
+	uint8_t ***bit = nr_alloc_uint8_3D_array(polarParams->N, (polarParams->n+1), 2*listSize);
+	uint8_t **bitUpdated = nr_alloc_uint8_2D_array(polarParams->N, (polarParams->n+1)); //0=False, 1=True
+	uint8_t **llrUpdated = nr_alloc_uint8_2D_array(polarParams->N, (polarParams->n+1)); //0=False, 1=True
 	double ***llr = nr_alloc_double_3D_array(polarParams->N, (polarParams->n+1), 2*listSize);
-	uint8_t **crcChecksum = nr_alloc_uint8_t_2D_array(polarParams->crcParityBits, 2*listSize);
+	uint8_t **crcChecksum = nr_alloc_uint8_2D_array(polarParams->crcParityBits, 2*listSize);
 	double *pathMetric = malloc(sizeof(double)*(2*listSize));
 	uint8_t *crcState = malloc(sizeof(uint8_t)*(2*listSize)); //0=False, 1=True
 
@@ -740,9 +742,9 @@ int8_t polar_decoder_aPriori_timing(double *input,
 				free(d_tilde);
 				free(pathMetric);
 				free(crcState);
-				nr_free_uint8_t_3D_array(bit, polarParams->N, (polarParams->n+1));
+				nr_free_uint8_3D_array(bit, polarParams->N, (polarParams->n+1));
 				nr_free_double_3D_array(llr, polarParams->N, (polarParams->n+1));
-				nr_free_uint8_t_2D_array(crcChecksum, polarParams->crcParityBits);
+				nr_free_uint8_2D_array(crcChecksum, polarParams->crcParityBits);
 				return(-1);
 			}
 
@@ -775,11 +777,11 @@ int8_t polar_decoder_aPriori_timing(double *input,
 	free(d_tilde);
 	free(pathMetric);
 	free(crcState);
-	nr_free_uint8_t_3D_array(bit, polarParams->N, (polarParams->n+1));
+	nr_free_uint8_3D_array(bit, polarParams->N, (polarParams->n+1));
 	nr_free_double_3D_array(llr, polarParams->N, (polarParams->n+1));
-	nr_free_uint8_t_2D_array(crcChecksum, polarParams->crcParityBits);
-	nr_free_uint8_t_2D_array(extended_crc_generator_matrix, polarParams->K);
-	nr_free_uint8_t_2D_array(tempECGM, polarParams->K);
+	nr_free_uint8_2D_array(crcChecksum, polarParams->crcParityBits);
+	nr_free_uint8_2D_array(extended_crc_generator_matrix, polarParams->K);
+	nr_free_uint8_2D_array(tempECGM, polarParams->K);
 
 	/*
 	 * Return bits.
@@ -797,11 +799,11 @@ int8_t polar_decoder_dci(double *input,
 						 uint16_t n_RNTI)
 {
 
-	uint8_t ***bit = nr_alloc_uint8_t_3D_array(polarParams->N, (polarParams->n+1), 2*listSize);
-	uint8_t **bitUpdated = nr_alloc_uint8_t_2D_array(polarParams->N, (polarParams->n+1)); //0=False, 1=True
-	uint8_t **llrUpdated = nr_alloc_uint8_t_2D_array(polarParams->N, (polarParams->n+1)); //0=False, 1=True
+	uint8_t ***bit = nr_alloc_uint8_3D_array(polarParams->N, (polarParams->n+1), 2*listSize);
+	uint8_t **bitUpdated = nr_alloc_uint8_2D_array(polarParams->N, (polarParams->n+1)); //0=False, 1=True
+	uint8_t **llrUpdated = nr_alloc_uint8_2D_array(polarParams->N, (polarParams->n+1)); //0=False, 1=True
 	double ***llr = nr_alloc_double_3D_array(polarParams->N, (polarParams->n+1), 2*listSize);
-	uint8_t **crcChecksum = nr_alloc_uint8_t_2D_array(polarParams->crcParityBits, 2*listSize);
+	uint8_t **crcChecksum = nr_alloc_uint8_2D_array(polarParams->crcParityBits, 2*listSize);
 	double *pathMetric = malloc(sizeof(double)*(2*listSize));
 	uint8_t *crcState = malloc(sizeof(uint8_t)*(2*listSize)); //0=False, 1=True
 	uint8_t extended_crc_scrambling_pattern[polarParams->crcParityBits];
@@ -989,9 +991,9 @@ int8_t polar_decoder_dci(double *input,
 				free(d_tilde);
 				free(pathMetric);
 				free(crcState);
-				nr_free_uint8_t_3D_array(bit, polarParams->N, (polarParams->n+1));
+				nr_free_uint8_3D_array(bit, polarParams->N, (polarParams->n+1));
 				nr_free_double_3D_array(llr, polarParams->N, (polarParams->n+1));
-				nr_free_uint8_t_2D_array(crcChecksum, polarParams->crcParityBits);
+				nr_free_uint8_2D_array(crcChecksum, polarParams->crcParityBits);
 				return(-1);
 			}
 
@@ -1024,11 +1026,11 @@ int8_t polar_decoder_dci(double *input,
 	free(d_tilde);
 	free(pathMetric);
 	free(crcState);
-	nr_free_uint8_t_3D_array(bit, polarParams->N, (polarParams->n+1));
+	nr_free_uint8_3D_array(bit, polarParams->N, (polarParams->n+1));
 	nr_free_double_3D_array(llr, polarParams->N, (polarParams->n+1));
-	nr_free_uint8_t_2D_array(crcChecksum, polarParams->crcParityBits);
-	nr_free_uint8_t_2D_array(extended_crc_generator_matrix, polarParams->K);
-	nr_free_uint8_t_2D_array(tempECGM, polarParams->K);
+	nr_free_uint8_2D_array(crcChecksum, polarParams->crcParityBits);
+	nr_free_uint8_2D_array(extended_crc_generator_matrix, polarParams->K);
+	nr_free_uint8_2D_array(tempECGM, polarParams->K);
 
 	/*
 	 * Return bits.
@@ -1037,10 +1039,41 @@ int8_t polar_decoder_dci(double *input,
 	return(0);
 }
 
+void init_polar_deinterleaver_table(t_nrPolar_params *polarParams) {
 
-int8_t polar_decoder_int16(int16_t *input,
-			   uint8_t *out,
-			   t_nrPolar_params *polarParams)
+  AssertFatal(polarParams->K > 32, "K = %d < 33, is not supported yet\n",polarParams->K);
+  AssertFatal(polarParams->K < 129, "K = %d > 128, is not supported yet\n",polarParams->K);
+  
+  int bit_i,ip,ipmod64;
+
+  int numbytes = polarParams->K>>3;
+  int residue = polarParams->K&7;
+  int numbits;
+  if (residue>0) numbytes++;
+  for (int byte=0;byte<numbytes;byte++) {
+    if (byte<(polarParams->K>>3)) numbits=8;
+    else numbits=residue;
+    for (int i=0;i<numbits;i++) {
+      // flip bit endian for B
+      ip=polarParams->K - 1 - polarParams->interleaving_pattern[(8*byte)+i];
+#if 0
+      printf("byte %d, i %d => ip %d\n",byte,i,ip);
+#endif
+      ipmod64 = ip&63;
+      AssertFatal(ip<128,"ip = %d\n",ip);
+      for (int val=0;val<256;val++) {
+	bit_i=(val>>i)&1;
+	if (ip<64) polarParams->B_tab0[byte][val] |= (((uint64_t)bit_i)<<ipmod64);
+	else       polarParams->B_tab1[byte][val] |= (((uint64_t)bit_i)<<ipmod64);
+      }
+    }
+  }
+ 
+}
+
+uint32_t polar_decoder_int16(int16_t *input,
+			     uint64_t *out,
+			     t_nrPolar_params *polarParams)
 {
   
 
@@ -1053,33 +1086,81 @@ int8_t polar_decoder_int16(int16_t *input,
   }
   memcpy((void*)&polarParams->tree.root->alpha[0],(void*)&d_tilde[0],sizeof(int16_t)*polarParams->N);
   
-  /*
-   * SCL polar decoder.
-   */
-
-
   generic_polar_decoder(polarParams,polarParams->tree.root);
 
 
   //Extract the information bits (û to ĉ)
-  nr_polar_info_bit_extraction(polarParams->nr_polar_U, polarParams->nr_polar_CPrime, polarParams->information_bit_pattern, polarParams->N);
+  uint64_t Cprime[4]={0,0,0,0};
+  uint64_t B[4]={0,0,0,0};
+  for (int i=0;i<polarParams->K;i++) Cprime[i>>6] = Cprime[i>>6] | ((uint64_t)polarParams->nr_polar_U[polarParams->Q_I_N[i]])<<(i&63);
 
   //Deinterleaving (ĉ to b)
-
-  nr_polar_deinterleaver(polarParams->nr_polar_CPrime, polarParams->nr_polar_B, polarParams->interleaving_pattern, polarParams->K);
-
-  //Remove the CRC (â)
-  //for (int j = 0; j < polarParams->payloadBits; j++) polarParams->nr_polar_A[j]=polarParams->nr_polar_B[j];  
-
-  // Check the CRC
-  for (int j=0;j<polarParams->crcParityBits;j++) {
-    int crcbit=0;
-    for (int i=0;i<polarParams->payloadBits;i++)
-      crcbit = crcbit ^ (polarParams->crc_generator_matrix[i][j] & polarParams->nr_polar_B[i]);
-    if (crcbit != polarParams->nr_polar_B[polarParams->payloadBits+j]) return(-1); 
+  uint8_t *Cprimebyte = (uint8_t*)Cprime;
+  if (polarParams->K<65) {
+    B[0] = polarParams->B_tab0[0][Cprimebyte[0]] |
+      polarParams->B_tab0[1][Cprimebyte[1]] |
+      polarParams->B_tab0[2][Cprimebyte[2]] |
+      polarParams->B_tab0[3][Cprimebyte[3]] |
+      polarParams->B_tab0[4][Cprimebyte[4]] |
+      polarParams->B_tab0[5][Cprimebyte[5]] |
+      polarParams->B_tab0[6][Cprimebyte[6]] |
+      polarParams->B_tab0[7][Cprimebyte[7]];
   }
-  // pack into ceil(payloadBits/32) 32 bit words, lowest index in MSB
-  //  nr_byte2bit_uint8_32_t(polarParams->nr_polar_A, polarParams->payloadBits, out);
-  nr_byte2bit_uint8_32_t(polarParams->nr_polar_B, polarParams->payloadBits, (unsigned int *)out);
-  return(0);
+  else if (polarParams->K<129) {
+    int len = polarParams->K/8;
+    if ((polarParams->K&7) > 0) len++;
+    for (int k=0;k<len;k++) {
+      B[0] |= polarParams->B_tab0[k][Cprimebyte[k]];
+      B[1] |= polarParams->B_tab1[k][Cprimebyte[k]];
+    }
+  }
+
+
+  int len=polarParams->payloadBits;
+  int len_mod64=len&63;
+  int crclen = polarParams->crcParityBits;
+  uint64_t rxcrc=B[0]&((1<<crclen)-1);
+  uint32_t crc;
+  uint64_t Ar;
+
+  AssertFatal(len<65,"A must be less than 65 bits\n");
+  if (len<=32) {
+    Ar = (uint32_t)(B[0]>>crclen);
+    uint8_t A32_flip[4];
+    uint32_t Aprime= (uint32_t)(Ar<<(32-len));
+    A32_flip[0]=((uint8_t*)&Aprime)[3];
+    A32_flip[1]=((uint8_t*)&Aprime)[2];
+    A32_flip[2]=((uint8_t*)&Aprime)[1];
+    A32_flip[3]=((uint8_t*)&Aprime)[0];
+    crc = (uint64_t)(crc24c(A32_flip,len)>>8);
+  }
+  else if (len<=64) {
+    Ar = (B[0]>>crclen) | (B[1]<<(64-crclen));;
+    uint8_t A64_flip[4];
+    uint64_t Aprime= (uint32_t)(Ar<<(64-len));
+    A64_flip[0]=((uint8_t*)&Aprime)[7];
+    A64_flip[1]=((uint8_t*)&Aprime)[6];
+    A64_flip[2]=((uint8_t*)&Aprime)[5];
+    A64_flip[3]=((uint8_t*)&Aprime)[4];
+    A64_flip[4]=((uint8_t*)&Aprime)[3];
+    A64_flip[5]=((uint8_t*)&Aprime)[2];
+    A64_flip[6]=((uint8_t*)&Aprime)[1];
+    A64_flip[7]=((uint8_t*)&Aprime)[0];
+    crc = (uint64_t)(crc24c(A64_flip,len)>>8);
+  }
+
+#if 0
+  printf("A %llx B %llx|%llx Cprime %llx|%llx  (crc %x,rxcrc %llx %d)\n",
+	 Ar,
+	 B[1],B[0],Cprime[1],Cprime[0],crc,
+   	 rxcrc,polarParams->payloadBits);
+#endif
+
+  out[0]=Ar;
+
+
+  return(crc^rxcrc);
+  
+
+
 }

openair1/PHY/CODING/nrPolar_tools/nr_polar_decoding_tools.c

@@ -34,18 +34,18 @@
 #include "PHY/sse_intrin.h"
 #include "PHY/impl_defs_top.h"
 
-//#define DEBUG_NEW_IMPL
+//#define DEBUG_NEW_IMPL 1
 
 void updateLLR(double ***llr,
-			   uint8_t **llrU,
-			   uint8_t ***bit,
-			   uint8_t **bitU,
-			   uint8_t listSize,
-			   uint16_t row,
-			   uint16_t col,
-			   uint16_t xlen,
-			   uint8_t ylen,
-			   uint8_t approximation)
+	       uint8_t **llrU,
+	       uint8_t ***bit,
+	       uint8_t **bitU,
+	       uint8_t listSize,
+	       uint16_t row,
+	       uint16_t col,
+	       uint16_t xlen,
+	       uint8_t ylen,
+	       uint8_t approximation)
 {
 	uint16_t offset = (xlen/(pow(2,(ylen-col-1))));
 	for (uint8_t i=0; i<listSize; i++) {
@@ -219,8 +219,8 @@ decoder_node_t *add_nodes(int level,int first_leaf_index,t_nrPolar_params *pp) {
   decoder_node_t *new_node = new_decoder_node(first_leaf_index,level);
 #ifdef DEBUG_NEW_IMPL
   printf("New node %d order %d, level %d\n",pp->tree.num_nodes,Nv,level);
-  pp->tree.num_nodes++;
 #endif
+  pp->tree.num_nodes++;
   if (level==0) {
 #ifdef DEBUG_NEW_IMPL
     printf("leaf %d (%s)\n",first_leaf_index,pp->information_bit_pattern[first_leaf_index]==1 ? "information or crc" : "frozen");
@@ -233,16 +233,19 @@ decoder_node_t *add_nodes(int level,int first_leaf_index,t_nrPolar_params *pp) {
   for (int i=0;i<Nv;i++) {
     if (pp->information_bit_pattern[i+first_leaf_index]>0) all_frozen_below=0; 
   }
-if (all_frozen_below==0) new_node->left=add_nodes(level-1,first_leaf_index,pp);
- else {
+  if (all_frozen_below==0) new_node->left=add_nodes(level-1,first_leaf_index,pp);
+  else {
 #ifdef DEBUG_NEW_IMPL
-   printf("aggregating frozen bits %d ... %d at level %d (%s)\n",first_leaf_index,first_leaf_index+Nv-1,level,((first_leaf_index/Nv)&1)==0?"left":"right");
+    printf("aggregating frozen bits %d ... %d at level %d (%s)\n",first_leaf_index,first_leaf_index+Nv-1,level,((first_leaf_index/Nv)&1)==0?"left":"right");
 #endif
     new_node->leaf=1;
     new_node->all_frozen=1;
   }
   if (all_frozen_below==0) new_node->right=add_nodes(level-1,first_leaf_index+(Nv/2),pp);
 
+#ifdef DEBUG_NEW_IMPL
+  printf("new_node (%d): first_leaf_index %d, left %p, right %p\n",Nv,first_leaf_index,new_node->left,new_node->right);
+#endif  
   return(new_node);
 }
 
@@ -251,7 +254,9 @@ void build_decoder_tree(t_nrPolar_params *pp) {
 
   pp->tree.num_nodes=0;
   pp->tree.root = add_nodes(pp->n,0,pp);
-  			       
+#ifdef DEBUG_NEW_IMPL
+  printf("root : left %p, right %p\n",pp->tree.root->left,pp->tree.root->right);
+#endif
 }
 
 #if defined(__arm__) || defined(__aarch64__)

openair1/PHY/CODING/nrPolar_tools/nr_polar_defs.h

@@ -78,54 +78,62 @@ typedef struct decoder_tree_t_s {
 } decoder_tree_t;
 
 struct nrPolar_params {
-	//messageType: 0=PBCH, 1=DCI, -1=UCI
-	int idx; //idx = (messageType * messageLength * aggregation_prime);
-	struct nrPolar_params *nextPtr;
-
-	uint8_t n_max;
-	uint8_t i_il;
-	uint8_t i_seg;
-	uint8_t n_pc;
-	uint8_t n_pc_wm;
-	uint8_t i_bil;
-	uint16_t payloadBits;
-	uint16_t encoderLength;
-	uint8_t crcParityBits;
-	uint8_t crcCorrectionBits;
-	uint16_t K;
-	uint16_t N;
-	uint8_t n;
-	uint32_t crcBit;
-
-	uint16_t *interleaving_pattern;
-	uint16_t *rate_matching_pattern;
-	const uint16_t *Q_0_Nminus1;
-	int16_t *Q_I_N;
-	int16_t *Q_F_N;
-	int16_t *Q_PC_N;
-	uint8_t *information_bit_pattern;
-	uint16_t *channel_interleaver_pattern;
-	uint32_t crc_polynomial;
-
-	uint8_t **crc_generator_matrix; //G_P
-	uint8_t **G_N;
-	uint32_t* crc256Table;
+  //messageType: 0=PBCH, 1=DCI, -1=UCI
+  int idx; //idx = (messageType * messageLength * aggregation_prime);
+  struct nrPolar_params *nextPtr;
+  
+  uint8_t n_max;
+  uint8_t i_il;
+  uint8_t i_seg;
+  uint8_t n_pc;
+  uint8_t n_pc_wm;
+  uint8_t i_bil;
+  uint16_t payloadBits;
+  uint16_t encoderLength;
+  uint8_t crcParityBits;
+  uint8_t crcCorrectionBits;
+  uint16_t K;
+  uint16_t N;
+  uint8_t n;
+  uint32_t crcBit;
+  
+  uint16_t *interleaving_pattern;
+  uint16_t *deinterleaving_pattern;
+  uint16_t *rate_matching_pattern;
+  const uint16_t *Q_0_Nminus1;
+  int16_t *Q_I_N;
+  int16_t *Q_F_N;
+  int16_t *Q_PC_N;
+  uint8_t *information_bit_pattern;
+  uint16_t *channel_interleaver_pattern;
+  uint32_t crc_polynomial;
+  
+  uint8_t **crc_generator_matrix; //G_P
+  uint8_t **G_N;
+  uint64_t **G_N_tab;
+  int groupsize;
+  int     *rm_tab;
+  uint64_t cprime_tab0[32][256];
+  uint64_t cprime_tab1[32][256];
+  uint64_t B_tab0[32][256];
+  uint64_t B_tab1[32][256];
+  uint32_t* crc256Table;
   uint8_t **extended_crc_generator_matrix;
-	//lowercase: bits, Uppercase: Bits stored in bytes
-	//polar_encoder vectors
-	uint8_t *nr_polar_crc;
-	uint8_t *nr_polar_aPrime;
-	uint8_t *nr_polar_APrime;
-	uint8_t *nr_polar_D;
-	uint8_t *nr_polar_E;
-
-	//Polar Coding vectors
-	uint8_t *nr_polar_A;
-	uint8_t *nr_polar_CPrime;
-	uint8_t *nr_polar_B;
-	uint8_t *nr_polar_U;
-
-decoder_tree_t tree;
+  //lowercase: bits, Uppercase: Bits stored in bytes
+  //polar_encoder vectors
+  uint8_t *nr_polar_crc;
+  uint8_t *nr_polar_aPrime;
+  uint8_t *nr_polar_APrime;
+  uint8_t *nr_polar_D;
+  uint8_t *nr_polar_E;
+  
+  //Polar Coding vectors
+  uint8_t *nr_polar_A;
+  uint8_t *nr_polar_CPrime;
+  uint8_t *nr_polar_B;
+  uint8_t *nr_polar_U;
+  
+  decoder_tree_t tree;
 } __attribute__ ((__packed__));
 typedef struct nrPolar_params t_nrPolar_params;
 typedef t_nrPolar_params *t_nrPolar_paramsPtr;
@@ -139,11 +147,10 @@ void polar_encoder_dci(uint32_t *in,
 					   t_nrPolar_paramsPtr polarParams,
 					   uint16_t n_RNTI);
 
-void polar_encoder_timing(uint32_t *in,
-						  uint32_t *out,
-						  t_nrPolar_paramsPtr polarParams,
-						  double cpuFreqGHz,
-						  FILE* logFile);
+void polar_encoder_fast(uint64_t *A,
+			uint32_t *out,
+			int32_t crcmask,
+			t_nrPolar_paramsPtr polarParams);
 
 int8_t polar_decoder(double *input,
 		 	 	 	 uint8_t *output,
@@ -151,6 +158,10 @@ int8_t polar_decoder(double *input,
 					 uint8_t listSize,
 					 uint8_t pathMetricAppr);
 
+uint32_t polar_decoder_int16(int16_t *input,
+			     uint64_t *out,
+			     t_nrPolar_params *polarParams);
+
 int8_t polar_decoder_aPriori(double *input,
 							 uint32_t *output,
 							 t_nrPolar_paramsPtr polarParams,
@@ -174,7 +185,12 @@ int8_t polar_decoder_dci(double *input,
 						 uint8_t pathMetricAppr,
 						 uint16_t n_RNTI);
 
-void generic_polar_decoder(t_nrPolar_params *,decoder_node_t *);
+void generic_polar_decoder(t_nrPolar_params *,
+		decoder_node_t *);
+
+void build_decoder_tree(t_nrPolar_params *pp);
+void build_polar_tables(t_nrPolar_paramsPtr polarParams);
+void init_polar_deinterleaver_table(t_nrPolar_params *polarParams);
 
 void nr_polar_init(t_nrPolar_paramsPtr *polarParams,
 				   int8_t messageType,
@@ -200,153 +216,168 @@ const uint16_t* nr_polar_sequence_pattern(uint8_t n);
  * @param E
  * @param n_max */
 uint32_t nr_polar_output_length(uint16_t K,
-								uint16_t E,
-								uint8_t n_max);
+		uint16_t E,
+		uint8_t n_max);
 
 void nr_polar_channel_interleaver_pattern(uint16_t *cip,
-										  uint8_t I_BIL,
-										  uint16_t E);
+		uint8_t I_BIL,
+		uint16_t E);
 
 void nr_polar_rate_matching_pattern(uint16_t *rmp,
-									uint16_t *J,
-									const uint8_t *P_i_,
-									uint16_t K,
-									uint16_t N,
-									uint16_t E);
+		uint16_t *J,
+		const uint8_t *P_i_,
+		uint16_t K,
+		uint16_t N,
+		uint16_t E);
 
 void nr_polar_rate_matching(double *input,
-							double *output,
-							uint16_t *rmp,
-							uint16_t K,
-							uint16_t N,
-							uint16_t E);
+		double *output,
+		uint16_t *rmp,
+		uint16_t K,
+		uint16_t N,
+		uint16_t E);
 
-void nr_polar_rate_matching_int16(int16_t *input, int16_t *output, uint16_t *rmp, uint16_t K, uint16_t N, uint16_t E);
+void nr_polar_rate_matching_int16(int16_t *input,
+		int16_t *output,
+		uint16_t *rmp,
+		uint16_t K,
+		uint16_t N,
+		uint16_t E);
 
 void nr_polar_interleaving_pattern(uint16_t K,
-								   uint8_t I_IL,
-								   uint16_t *PI_k_);
+		uint8_t I_IL,
+		uint16_t *PI_k_);
 
 void nr_polar_info_bit_pattern(uint8_t *ibp,
-							   int16_t *Q_I_N,
-							   int16_t *Q_F_N,
-							   uint16_t *J,
-							   const uint16_t *Q_0_Nminus1,
-							   uint16_t K,
-							   uint16_t N,
-							   uint16_t E,
-							   uint8_t n_PC);
+		int16_t *Q_I_N,
+		int16_t *Q_F_N,
+		uint16_t *J,
+		const uint16_t *Q_0_Nminus1,
+		uint16_t K,
+		uint16_t N,
+		uint16_t E,
+		uint8_t n_PC);
 
 void nr_polar_info_bit_extraction(uint8_t *input,
-								  uint8_t *output,
-								  uint8_t *pattern,
-								  uint16_t size);
+		uint8_t *output,
+		uint8_t *pattern,
+		uint16_t size);
 
 void nr_bit2byte_uint32_8_t(uint32_t *in,
-							uint16_t arraySize,
-							uint8_t *out);
+		uint16_t arraySize,
+		uint8_t *out);
 
 void nr_byte2bit_uint8_32_t(uint8_t *in,
-							uint16_t arraySize,
-							uint32_t *out);
+		uint16_t arraySize,
+		uint32_t *out);
 
 void nr_crc_bit2bit_uint32_8_t(uint32_t *in,
-							   uint16_t arraySize,
-							   uint8_t *out);
+		uint16_t arraySize,
+		uint8_t *out);
 
 void nr_polar_bit_insertion(uint8_t *input,
-							uint8_t *output,
-							uint16_t N,
-							uint16_t K,
-							int16_t *Q_I_N,
-							int16_t *Q_PC_N,
-							uint8_t n_PC);
+		uint8_t *output,
+		uint16_t N,
+		uint16_t K,
+		int16_t *Q_I_N,
+		int16_t *Q_PC_N,
+		uint8_t n_PC);
 
-void nr_matrix_multiplication_uint8_t_1D_uint8_t_2D(uint8_t *matrix1,
-													uint8_t **matrix2,
-													uint8_t *output,
-													uint16_t row,
-													uint16_t col);
+void nr_matrix_multiplication_uint8_1D_uint8_2D(uint8_t *matrix1,
+		uint8_t **matrix2,
+		uint8_t *output,
+		uint16_t row,
+		uint16_t col);
 
-uint8_t ***nr_alloc_uint8_t_3D_array(uint16_t xlen,
-									 uint16_t ylen,
-									 uint16_t zlen);
+uint8_t ***nr_alloc_uint8_3D_array(uint16_t xlen,
+		uint16_t ylen,
+		uint16_t zlen);
 
-uint8_t **nr_alloc_uint8_t_2D_array(uint16_t xlen,
-									uint16_t ylen);
+uint8_t **nr_alloc_uint8_2D_array(uint16_t xlen,
+		uint16_t ylen);
 
 double ***nr_alloc_double_3D_array(uint16_t xlen,
-								   uint16_t ylen,
-								   uint16_t zlen);
+		uint16_t ylen,
+		uint16_t zlen);
 
-void nr_free_uint8_t_3D_array(uint8_t ***input,
-							  uint16_t xlen,
-							  uint16_t ylen);
-
-void nr_free_uint8_t_2D_array(uint8_t **input,
-							  uint16_t xlen);
+double **nr_alloc_double_2D_array(uint16_t xlen,
+		uint16_t ylen);
 
 void nr_free_double_3D_array(double ***input,
-							 uint16_t xlen,
-							 uint16_t ylen);
+		uint16_t xlen,
+		uint16_t ylen);
+
+void nr_free_double_2D_array(double **input,
+		uint16_t xlen);
+
+void nr_free_uint8_3D_array(uint8_t ***input,
+		uint16_t xlen,
+		uint16_t ylen);
+
+void nr_free_uint8_2D_array(uint8_t **input,
+		uint16_t xlen);
+
+void nr_sort_asc_double_1D_array_ind(double *matrix,
+		uint8_t *ind,
+		uint8_t len);
+
+void nr_sort_asc_int16_1D_array_ind(int32_t *matrix,
+		int *ind,
+		int len);
 
 void nr_free_double_2D_array(double **input, uint16_t xlen);
 
 
 void updateLLR(double ***llr,
-			   uint8_t **llrU,
-			   uint8_t ***bit,
-			   uint8_t **bitU,
-			   uint8_t listSize,
-			   uint16_t row,
-			   uint16_t col,
-			   uint16_t xlen,
-			   uint8_t ylen,
-			   uint8_t approximation);
+		uint8_t **llrU,
+		uint8_t ***bit,
+		uint8_t **bitU,
+		uint8_t listSize,
+		uint16_t row,
+		uint16_t col,
+		uint16_t xlen,
+		uint8_t ylen,
+		uint8_t approximation);
 
 void updateBit(uint8_t ***bit,
-			   uint8_t **bitU,
-			   uint8_t listSize,
-			   uint16_t row,
-			   uint16_t col,
-			   uint16_t xlen,
-			   uint8_t ylen);
+		uint8_t **bitU,
+		uint8_t listSize,
+		uint16_t row,
+		uint16_t col,
+		uint16_t xlen,
+		uint8_t ylen);
 
 void updatePathMetric(double *pathMetric,
-					  double ***llr,
-					  uint8_t listSize,
-					  uint8_t bitValue,
-					  uint16_t row,
-					  uint8_t approximation);
+		double ***llr,
+		uint8_t listSize,
+		uint8_t bitValue,
+		uint16_t row,
+		uint8_t approximation);
 
 void updatePathMetric2(double *pathMetric,
-					   double ***llr,
-					   uint8_t listSize,
-					   uint16_t row,
-					   uint8_t approximation);
+		double ***llr,
+		uint8_t listSize,
+		uint16_t row,
+		uint8_t approximation);
 
 void computeLLR(double ***llr,
-				uint16_t row,
-				uint16_t col,
-				uint8_t i,
-				uint16_t offset,
-				uint8_t approximation);
+		uint16_t row,
+		uint16_t col,
+		uint8_t i,
+		uint16_t offset,
+		uint8_t approximation);
 
 void updateCrcChecksum(uint8_t **crcChecksum,
-					   uint8_t **crcGen,
-					   uint8_t listSize,
-					   uint32_t i2,
-					   uint8_t len);
+		uint8_t **crcGen,
+		uint8_t listSize,
+		uint32_t i2,
+		uint8_t len);
 
 void updateCrcChecksum2(uint8_t **crcChecksum,
-						uint8_t **crcGen,
-						uint8_t listSize,
-						uint32_t i2,
-						uint8_t len);
-
-void nr_sort_asc_double_1D_array_ind(double *matrix,
-									 uint8_t *ind,
-									 uint8_t len);
+		uint8_t **crcGen,
+		uint8_t listSize,
+		uint32_t i2,
+		uint8_t len);
 
 uint8_t **crc24c_generator_matrix(uint16_t payloadSizeBits);
 
@@ -356,11 +387,11 @@ uint8_t **crc6_generator_matrix(uint16_t payloadSizeBits);
 
 //Also nr_polar_rate_matcher
 static inline void nr_polar_interleaver(uint8_t *input,
-										uint8_t *output,
-										uint16_t *pattern,
-										uint16_t size)
+					uint8_t *output,
+					uint16_t *pattern,
+					uint16_t size)
 {
-	for (int i=0; i<size; i++) output[i]=input[pattern[i]];
+  for (int i=0; i<size; i++) output[i]=input[pattern[i]];
 }
 
 static inline void nr_polar_deinterleaver(uint8_t *input,
@@ -375,7 +406,4 @@ static inline void nr_polar_deinterleaver(uint8_t *input,
 
 void build_decoder_tree(t_nrPolar_params *pp);
 
-int8_t polar_decoder_int16(int16_t *input,
-			   uint8_t *out,
-			   t_nrPolar_params *polarParams);
 #endif

openair1/PHY/CODING/nrPolar_tools/nr_polar_encoder.c

@@ -21,296 +21,540 @@
 
 /*!\file PHY/CODING/nrPolar_tools/nr_polar_encoder.c
  * \brief
- * \author Turker Yilmaz
+ * \author Raymond Knopp, Turker Yilmaz
  * \date 2018
  * \version 0.1
  * \company EURECOM
- * \email turker.yilmaz@eurecom.fr
+ * \email raymond.knopp@eurecom.fr, turker.yilmaz@eurecom.fr
  * \note
  * \warning
-*/
+ */
 
 //#define DEBUG_POLAR_ENCODER
 //#define DEBUG_POLAR_ENCODER_DCI
 //#define DEBUG_POLAR_ENCODER_TIMING
 
 #include "PHY/CODING/nrPolar_tools/nr_polar_defs.h"
+#include "assertions.h"
 
 //input  [a_31 a_30 ... a_0]
 //output [f_31 f_30 ... f_0] [f_63 f_62 ... f_32] ...
 
 void polar_encoder(uint32_t *in,
-				   uint32_t *out,
-				   t_nrPolar_paramsPtr polarParams)
+		   uint32_t *out,
+		   t_nrPolar_paramsPtr polarParams)
 {
-	if (polarParams->idx == 0){//PBCH
-		nr_bit2byte_uint32_8_t(in, polarParams->payloadBits, polarParams->nr_polar_A);
-		/*
-		 * Bytewise operations
-		 */
-		//Calculate CRC.
-		nr_matrix_multiplication_uint8_t_1D_uint8_t_2D(polarParams->nr_polar_A,
-													   polarParams->crc_generator_matrix,
-													   polarParams->nr_polar_crc,
-													   polarParams->payloadBits,
-													   polarParams->crcParityBits);
-		for (uint8_t i = 0; i < polarParams->crcParityBits; i++) 
-			polarParams->nr_polar_crc[i] = (polarParams->nr_polar_crc[i] % 2);
-
-		//Attach CRC to the Transport Block. (a to b)
-		for (uint16_t i = 0; i < polarParams->payloadBits; i++)
-			polarParams->nr_polar_B[i] = polarParams->nr_polar_A[i];
-		for (uint16_t i = polarParams->payloadBits; i < polarParams->K; i++)
-			polarParams->nr_polar_B[i]= polarParams->nr_polar_crc[i-(polarParams->payloadBits)];
-	} else { //UCI
-
-	}
-
-	//Interleaving (c to c')
-	nr_polar_interleaver(polarParams->nr_polar_B,
-						 polarParams->nr_polar_CPrime,
-						 polarParams->interleaving_pattern,
-						 polarParams->K);
-
-	//Bit insertion (c' to u)
-	nr_polar_bit_insertion(polarParams->nr_polar_CPrime,
-						   polarParams->nr_polar_U,
-						   polarParams->N,
-						   polarParams->K,
-						   polarParams->Q_I_N,
-						   polarParams->Q_PC_N,
-						   polarParams->n_pc);
-
-	//Encoding (u to d)
-	nr_matrix_multiplication_uint8_t_1D_uint8_t_2D(polarParams->nr_polar_U,
-												   polarParams->G_N,
-												   polarParams->nr_polar_D,
-												   polarParams->N,
-												   polarParams->N);
-	for (uint16_t i = 0; i < polarParams->N; i++)
-		polarParams->nr_polar_D[i] = (polarParams->nr_polar_D[i] % 2);
-
-	//Rate matching
-	//Sub-block interleaving (d to y) and Bit selection (y to e)
-	nr_polar_interleaver(polarParams->nr_polar_D,
-						 polarParams->nr_polar_E,
-						 polarParams->rate_matching_pattern,
-						 polarParams->encoderLength);
-
-	/*
-	 * Return bits.
-	 */
+  if (polarParams->idx == 0){//PBCH
+    /*
+    uint64_t B = (((uint64_t)*in)&((((uint64_t)1)<<32)-1)) | (((uint64_t)crc24c((uint8_t*)in,polarParams->payloadBits)>>8)<<polarParams->payloadBits);
 #ifdef DEBUG_POLAR_ENCODER
-	for (int i=0; i< polarParams->encoderLength;i++) printf("f[%d]=%d\n", i, polarParams->nr_polar_E[i]);
+    printf("polar_B %llx (crc %x)\n",B,crc24c((uint8_t*)in,polarParams->payloadBits)>>8);
+#endif
+nr_bit2byte_uint32_8_t((uint32_t*)&B, polarParams->K, polarParams->nr_polar_B);*/
+
+    nr_bit2byte_uint32_8_t((uint32_t*)in, polarParams->payloadBits, polarParams->nr_polar_A);
+    /*
+     * Bytewise operations
+     */
+    //Calculate CRC.
+    
+      nr_matrix_multiplication_uint8_1D_uint8_2D(polarParams->nr_polar_A,
+						     polarParams->crc_generator_matrix,
+						     polarParams->nr_polar_crc,
+						     polarParams->payloadBits,
+						     polarParams->crcParityBits);
+      for (uint8_t i = 0; i < polarParams->crcParityBits; i++) 
+	polarParams->nr_polar_crc[i] = (polarParams->nr_polar_crc[i] % 2);
+      
+      
+      //Attach CRC to the Transport Block. (a to b)
+      for (uint16_t i = 0; i < polarParams->payloadBits; i++)
+	polarParams->nr_polar_B[i] = polarParams->nr_polar_A[i];
+      for (uint16_t i = polarParams->payloadBits; i < polarParams->K; i++)
+	polarParams->nr_polar_B[i]= polarParams->nr_polar_crc[i-(polarParams->payloadBits)];
+    
+#ifdef DEBUG_POLAR_ENCODER
+    uint64_t B2=0;
+    for (int i = 0;i<polarParams->K;i++) B2 = B2 | ((uint64_t)polarParams->nr_polar_B[i] << i);
+    printf("polar_B %llx\n",B2);
+#endif
+    /*    for (int j=0;j<polarParams->crcParityBits;j++) {
+      for (int i=0;i<polarParams->payloadBits;i++) 
+	printf("%1d.%1d+",polarParams->crc_generator_matrix[i][j],polarParams->nr_polar_A[i]);
+      printf(" => %d\n",polarParams->nr_polar_crc[j]);
+      }*/
+	  
+  } else { //UCI
+
+  }
+
+  //Interleaving (c to c')
+  nr_polar_interleaver(polarParams->nr_polar_B,
+		       polarParams->nr_polar_CPrime,
+		       polarParams->interleaving_pattern,
+		       polarParams->K);
+
+
+#ifdef DEBUG_POLAR_ENCODER    
+  uint64_t Cprime=0;
+  for (int i = 0;i<polarParams->K;i++) {
+    Cprime = Cprime | ((uint64_t)polarParams->nr_polar_CPrime[i] << i);
+    if (polarParams->nr_polar_CPrime[i] == 1) printf("pos %d : %llx\n",i,Cprime);
+  }
+  printf("polar_Cprime %llx\n",Cprime);
+#endif  
+  //Bit insertion (c' to u)
+  nr_polar_bit_insertion(polarParams->nr_polar_CPrime,
+			 polarParams->nr_polar_U,
+			 polarParams->N,
+			 polarParams->K,
+			 polarParams->Q_I_N,
+			 polarParams->Q_PC_N,
+			 polarParams->n_pc);
+
+  //Encoding (u to d)
+  /*  memset(polarParams->nr_polar_U,0,polarParams->N);
+  polarParams->nr_polar_U[247]=1;
+  polarParams->nr_polar_U[253]=1;*/
+  nr_matrix_multiplication_uint8_1D_uint8_2D(polarParams->nr_polar_U,
+						 polarParams->G_N,
+						 polarParams->nr_polar_D,
+						 polarParams->N,
+						 polarParams->N);
+  for (uint16_t i = 0; i < polarParams->N; i++)
+    polarParams->nr_polar_D[i] = (polarParams->nr_polar_D[i] % 2);
+
+  uint64_t D[8];
+  memset((void*)D,0,8*sizeof(int64_t));
+#ifdef DEBUG_POLAR_ENCODER
+  for (int i=0;i<polarParams->N;i++)  D[i/64] |= ((uint64_t)polarParams->nr_polar_D[i])<<(i&63);
+  printf("D %llx,%llx,%llx,%llx,%llx,%llx,%llx,%llx\n",
+	 D[0],D[1],D[2],D[3],D[4],D[5],D[6],D[7]);
 #endif
 
-	nr_byte2bit_uint8_32_t(polarParams->nr_polar_E, polarParams->encoderLength, out);
+  //Rate matching
+  //Sub-block interleaving (d to y) and Bit selection (y to e)
+  nr_polar_interleaver(polarParams->nr_polar_D,
+		       polarParams->nr_polar_E,
+		       polarParams->rate_matching_pattern,
+		       polarParams->encoderLength);
+
+  /*
+   * Return bits.
+   */
+#ifdef DEBUG_POLAR_ENCODER
+  for (int i=0; i< polarParams->encoderLength;i++) printf("f[%d]=%d\n", i, polarParams->nr_polar_E[i]);
+#endif
+
+  nr_byte2bit_uint8_32_t(polarParams->nr_polar_E, polarParams->encoderLength, out);
 }
 
 void polar_encoder_dci(uint32_t *in,
-					   uint32_t *out,
-					   t_nrPolar_paramsPtr polarParams,
-					   uint16_t n_RNTI)
+		       uint32_t *out,
+		       t_nrPolar_paramsPtr polarParams,
+		       uint16_t n_RNTI)
 {
 #ifdef DEBUG_POLAR_ENCODER_DCI
-	printf("[polar_encoder_dci] in: [0]->0x%08x \t [1]->0x%08x \t [2]->0x%08x \t [3]->0x%08x\n", in[0], in[1], in[2], in[3]);
+  printf("[polar_encoder_dci] in: [0]->0x%08x \t [1]->0x%08x \t [2]->0x%08x \t [3]->0x%08x\n", in[0], in[1], in[2], in[3]);
 #endif
 
-	/*
-	 * Bytewise operations
-	 */
-	//(a to a')
-	nr_bit2byte_uint32_8_t(in, polarParams->payloadBits, polarParams->nr_polar_A);
-	for (int i=0; i<polarParams->crcParityBits; i++) polarParams->nr_polar_APrime[i]=1;
-	for (int i=0; i<polarParams->payloadBits; i++) polarParams->nr_polar_APrime[i+(polarParams->crcParityBits)]=polarParams->nr_polar_A[i];
+  /*
+   * Bytewise operations
+   */
+  //(a to a')
+  nr_bit2byte_uint32_8_t(in, polarParams->payloadBits, polarParams->nr_polar_A);
+  for (int i=0; i<polarParams->crcParityBits; i++) polarParams->nr_polar_APrime[i]=1;
+  for (int i=0; i<polarParams->payloadBits; i++) polarParams->nr_polar_APrime[i+(polarParams->crcParityBits)]=polarParams->nr_polar_A[i];
 #ifdef DEBUG_POLAR_ENCODER_DCI
-	printf("[polar_encoder_dci] A: ");
-	for (int i=0; i<polarParams->payloadBits; i++) printf("%d-", polarParams->nr_polar_A[i]);
-	printf("\n");
-	printf("[polar_encoder_dci] APrime: ");
-	for (int i=0; i<polarParams->K; i++) printf("%d-", polarParams->nr_polar_APrime[i]);
-	printf("\n");
-	printf("[polar_encoder_dci] GP: ");
-	for (int i=0; i<polarParams->crcParityBits; i++) printf("%d-", polarParams->crc_generator_matrix[0][i]);
-	printf("\n");
+  printf("[polar_encoder_dci] A: ");
+  for (int i=0; i<polarParams->payloadBits; i++) printf("%d-", polarParams->nr_polar_A[i]);
+  printf("\n");
+  printf("[polar_encoder_dci] APrime: ");
+  for (int i=0; i<polarParams->K; i++) printf("%d-", polarParams->nr_polar_APrime[i]);
+  printf("\n");
+  printf("[polar_encoder_dci] GP: ");
+  for (int i=0; i<polarParams->crcParityBits; i++) printf("%d-", polarParams->crc_generator_matrix[0][i]);
+  printf("\n");
 #endif
-	//Calculate CRC.
-	nr_matrix_multiplication_uint8_t_1D_uint8_t_2D(polarParams->nr_polar_APrime,
-												   polarParams->crc_generator_matrix,
-												   polarParams->nr_polar_crc,
-												   polarParams->K,
-												   polarParams->crcParityBits);
-	for (uint8_t i = 0; i < polarParams->crcParityBits; i++) polarParams->nr_polar_crc[i] = (polarParams->nr_polar_crc[i] % 2);
+  //Calculate CRC.
+  nr_matrix_multiplication_uint8_1D_uint8_2D(polarParams->nr_polar_APrime,
+						 polarParams->crc_generator_matrix,
+						 polarParams->nr_polar_crc,
+						 polarParams->K,
+						 polarParams->crcParityBits);
+  for (uint8_t i = 0; i < polarParams->crcParityBits; i++) polarParams->nr_polar_crc[i] = (polarParams->nr_polar_crc[i] % 2);
 #ifdef DEBUG_POLAR_ENCODER_DCI
-	printf("[polar_encoder_dci] CRC: ");
-	for (int i=0; i<polarParams->crcParityBits; i++) printf("%d-", polarParams->nr_polar_crc[i]);
-	printf("\n");
+  printf("[polar_encoder_dci] CRC: ");
+  for (int i=0; i<polarParams->crcParityBits; i++) printf("%d-", polarParams->nr_polar_crc[i]);
+  printf("\n");
 #endif
 
-	//Attach CRC to the Transport Block. (a to b)
-	for (uint16_t i = 0; i < polarParams->payloadBits; i++)
-		polarParams->nr_polar_B[i] = polarParams->nr_polar_A[i];
-	for (uint16_t i = polarParams->payloadBits; i < polarParams->K; i++)
-		polarParams->nr_polar_B[i]= polarParams->nr_polar_crc[i-(polarParams->payloadBits)];
-	//Scrambling (b to c)
-	for (int i=0; i<16; i++) {
-		polarParams->nr_polar_B[polarParams->payloadBits+8+i] =
-				( polarParams->nr_polar_B[polarParams->payloadBits+8+i] + ((n_RNTI>>(15-i))&1) ) % 2;
-	}
+  //Attach CRC to the Transport Block. (a to b)
+  for (uint16_t i = 0; i < polarParams->payloadBits; i++)
+    polarParams->nr_polar_B[i] = polarParams->nr_polar_A[i];
+  for (uint16_t i = polarParams->payloadBits; i < polarParams->K; i++)
+    polarParams->nr_polar_B[i]= polarParams->nr_polar_crc[i-(polarParams->payloadBits)];
+  //Scrambling (b to c)
+  for (int i=0; i<16; i++) {
+    polarParams->nr_polar_B[polarParams->payloadBits+8+i] =
+      ( polarParams->nr_polar_B[polarParams->payloadBits+8+i] + ((n_RNTI>>(15-i))&1) ) % 2;
+  }
 
-/*	//(a to a')
+  /*	//(a to a')
 	nr_crc_bit2bit_uint32_8_t(in, polarParams->payloadBits, polarParams->nr_polar_aPrime);
 	//Parity bits computation (p)
 	polarParams->crcBit = crc24c(polarParams->nr_polar_aPrime, (polarParams->payloadBits+polarParams->crcParityBits));
-#ifdef DEBUG_POLAR_ENCODER_DCI
+	#ifdef DEBUG_POLAR_ENCODER_DCI
 	printf("[polar_encoder_dci] crc: 0x%08x\n", polarParams->crcBit);
 	for (int i=0; i<32; i++)
 	{
-		printf("%d\n",((polarParams->crcBit)>>i)&1);
+	printf("%d\n",((polarParams->crcBit)>>i)&1);
 	}
-#endif
+	#endif
 	//(a to b)
 	//
 	// Bytewise operations
 	//
 	uint8_t arrayInd = ceil(polarParams->payloadBits / 8.0);
 	for (int i=0; i<arrayInd-1; i++){
-		for (int j=0; j<8; j++) {
-			polarParams->nr_polar_B[j+(i*8)] = ((polarParams->nr_polar_aPrime[3+i]>>(7-j)) & 1);
-		}
+	for (int j=0; j<8; j++) {
+	polarParams->nr_polar_B[j+(i*8)] = ((polarParams->nr_polar_aPrime[3+i]>>(7-j)) & 1);
+	}
 	}
 	for (int i=0; i<((polarParams->payloadBits)%8); i++) {
-			polarParams->nr_polar_B[i+(arrayInd-1)*8] = ((polarParams->nr_polar_aPrime[3+(arrayInd-1)]>>(7-i)) & 1);
+	polarParams->nr_polar_B[i+(arrayInd-1)*8] = ((polarParams->nr_polar_aPrime[3+(arrayInd-1)]>>(7-i)) & 1);
 	}
 	for (int i=0; i<8; i++) {
-		polarParams->nr_polar_B[polarParams->payloadBits+i] = ((polarParams->crcBit)>>(31-i))&1;
+	polarParams->nr_polar_B[polarParams->payloadBits+i] = ((polarParams->crcBit)>>(31-i))&1;
 	}
 	//Scrambling (b to c)
 	for (int i=0; i<16; i++) {
-		polarParams->nr_polar_B[polarParams->payloadBits+8+i] =
-				( (((polarParams->crcBit)>>(23-i))&1) + ((n_RNTI>>(15-i))&1) ) % 2;
+	polarParams->nr_polar_B[polarParams->payloadBits+8+i] =
+	( (((polarParams->crcBit)>>(23-i))&1) + ((n_RNTI>>(15-i))&1) ) % 2;
 	}*/
 #ifdef DEBUG_POLAR_ENCODER_DCI
-	printf("[polar_encoder_dci] B: ");
-	for (int i = 0; i < polarParams->K; i++) printf("%d-", polarParams->nr_polar_B[i]);
-	printf("\n");
+  printf("[polar_encoder_dci] B: ");
+  for (int i = 0; i < polarParams->K; i++) printf("%d-", polarParams->nr_polar_B[i]);
+  printf("\n");
 #endif
 
-	//Interleaving (c to c')
-	nr_polar_interleaver(polarParams->nr_polar_B,
-						 polarParams->nr_polar_CPrime,
-						 polarParams->interleaving_pattern,
-						 polarParams->K);
+  //Interleaving (c to c')
+  nr_polar_interleaver(polarParams->nr_polar_B,
+		       polarParams->nr_polar_CPrime,
+		       polarParams->interleaving_pattern,
+		       polarParams->K);
 
-	//Bit insertion (c' to u)
-	nr_polar_bit_insertion(polarParams->nr_polar_CPrime,
-						   polarParams->nr_polar_U,
-						   polarParams->N,
-						   polarParams->K,
-						   polarParams->Q_I_N,
-						   polarParams->Q_PC_N,
-						   polarParams->n_pc);
+  //Bit insertion (c' to u)
+  nr_polar_bit_insertion(polarParams->nr_polar_CPrime,
+			 polarParams->nr_polar_U,
+			 polarParams->N,
+			 polarParams->K,
+			 polarParams->Q_I_N,
+			 polarParams->Q_PC_N,
+			 polarParams->n_pc);
 
-	//Encoding (u to d)
-	nr_matrix_multiplication_uint8_t_1D_uint8_t_2D(polarParams->nr_polar_U,
-												   polarParams->G_N,
-												   polarParams->nr_polar_D,
-												   polarParams->N,
-												   polarParams->N);
-	for (uint16_t i = 0; i < polarParams->N; i++)
-		polarParams->nr_polar_D[i] = (polarParams->nr_polar_D[i] % 2);
+  //Encoding (u to d)
+  nr_matrix_multiplication_uint8_1D_uint8_2D(polarParams->nr_polar_U,
+						 polarParams->G_N,
+						 polarParams->nr_polar_D,
+						 polarParams->N,
+						 polarParams->N);
+  for (uint16_t i = 0; i < polarParams->N; i++)
+    polarParams->nr_polar_D[i] = (polarParams->nr_polar_D[i] % 2);
 
-	//Rate matching
-	//Sub-block interleaving (d to y) and Bit selection (y to e)
-	nr_polar_interleaver(polarParams->nr_polar_D,
-						 polarParams->nr_polar_E,
-						 polarParams->rate_matching_pattern,
-						 polarParams->encoderLength);
+  //Rate matching
+  //Sub-block interleaving (d to y) and Bit selection (y to e)
+  nr_polar_interleaver(polarParams->nr_polar_D,
+		       polarParams->nr_polar_E,
+		       polarParams->rate_matching_pattern,
+		       polarParams->encoderLength);
 
-	/*
-	 * Return bits.
-	 */
-	nr_byte2bit_uint8_32_t(polarParams->nr_polar_E, polarParams->encoderLength, out);
+  /*
+   * Return bits.
+   */
+  nr_byte2bit_uint8_32_t(polarParams->nr_polar_E, polarParams->encoderLength, out);
 #ifdef DEBUG_POLAR_ENCODER_DCI
-	printf("[polar_encoder_dci] E: ");
-	for (int i = 0; i < polarParams->encoderLength; i++) printf("%d-", polarParams->nr_polar_E[i]);
-	uint8_t outputInd = ceil(polarParams->encoderLength / 32.0);
-	printf("\n[polar_encoder_dci] out: ");
-	for (int i = 0; i < outputInd; i++) {
-		printf("[%d]->0x%08x\t", i, out[i]);
-	}
+  printf("[polar_encoder_dci] E: ");
+  for (int i = 0; i < polarParams->encoderLength; i++) printf("%d-", polarParams->nr_polar_E[i]);
+  uint8_t outputInd = ceil(polarParams->encoderLength / 32.0);
+  printf("\n[polar_encoder_dci] out: ");
+  for (int i = 0; i < outputInd; i++) {
+    printf("[%d]->0x%08x\t", i, out[i]);
+  }
 #endif
 }
 
-void polar_encoder_timing(uint32_t *in,
-						  uint32_t *out,
-						  t_nrPolar_paramsPtr polarParams,
-						  double cpuFreqGHz,
-						  FILE* logFile)
-{
-	//Initiate timing.
-	time_stats_t timeEncoderCRCByte, timeEncoderCRCBit, timeEncoderInterleaver, timeEncoderBitInsertion, timeEncoder1, timeEncoder2, timeEncoderRateMatching, timeEncoderByte2Bit;
-	reset_meas(&timeEncoderCRCByte); reset_meas(&timeEncoderCRCBit); reset_meas(&timeEncoderInterleaver); reset_meas(&timeEncoderBitInsertion); reset_meas(&timeEncoder1); reset_meas(&timeEncoder2); reset_meas(&timeEncoderRateMatching); reset_meas(&timeEncoderByte2Bit);
-	uint16_t n_RNTI=0x0000;
+static inline void polar_rate_matching(t_nrPolar_paramsPtr polarParams,void *in,void *out) __attribute__((always_inline));
 
-	start_meas(&timeEncoderCRCByte);
-	nr_crc_bit2bit_uint32_8_t(in, polarParams->payloadBits, polarParams->nr_polar_aPrime); //(a to a')
-	polarParams->crcBit = crc24c(polarParams->nr_polar_aPrime, (polarParams->payloadBits+polarParams->crcParityBits)); //Parity bits computation (p)
-	uint8_t arrayInd = ceil(polarParams->payloadBits / 8.0); //(a to b)
-	for (int i=0; i<arrayInd-1; i++)
-		for (int j=0; j<8; j++)
-			polarParams->nr_polar_B[j+(i*8)] = ((polarParams->nr_polar_aPrime[3+i]>>(7-j)) & 1);
-	for (int i=0; i<((polarParams->payloadBits)%8); i++) polarParams->nr_polar_B[i+(arrayInd-1)*8] = ((polarParams->nr_polar_aPrime[3+(arrayInd-1)]>>(7-i)) & 1);
-	for (int i=0; i<8; i++) polarParams->nr_polar_B[polarParams->payloadBits+i] = ((polarParams->crcBit)>>(31-i))&1;
-	for (int i=0; i<16; i++) polarParams->nr_polar_B[polarParams->payloadBits+8+i] =	( (((polarParams->crcBit)>>(23-i))&1) + ((n_RNTI>>(15-i))&1) ) % 2; //Scrambling (b to c)
-	stop_meas(&timeEncoderCRCByte);
+static inline void polar_rate_matching(t_nrPolar_paramsPtr polarParams,void *in,void *out) {
+
+  if (polarParams->groupsize == 8) 
+    for (int i=0;i<polarParams->encoderLength>>3;i++) ((uint8_t*)out)[i] = ((uint8_t *)in)[polarParams->rm_tab[i]];
+  else
+    for (int i=0;i<polarParams->encoderLength>>4;i++) {
+      ((uint16_t*)out)[i] = ((uint16_t *)in)[polarParams->rm_tab[i]];
+    }
+}
+
+void build_polar_tables(t_nrPolar_paramsPtr polarParams) {
+  
+  // build table b -> c'
+
+  AssertFatal(polarParams->K > 32, "K = %d < 33, is not supported yet\n",polarParams->K);
+  AssertFatal(polarParams->K < 129, "K = %d > 64, is not supported yet\n",polarParams->K);
+  
+  int bit_i,ip;
+
+  int numbytes = polarParams->K>>3;
+  int residue = polarParams->K&7;
+  int numbits;
+  if (residue>0) numbytes++;
+  for (int byte=0;byte<numbytes;byte++) {
+    if (byte<(polarParams->K>>3)) numbits=8;
+    else numbits=residue;
+    for (int val=0;val<256;val++) {
+      polarParams->cprime_tab0[byte][val] = 0;
+      polarParams->cprime_tab1[byte][val] = 0;
+      for (int i=0;i<numbits;i++) {
+	// flip bit endian of B bitstring
+	ip=polarParams->deinterleaving_pattern[polarParams->K-1-((8*byte)+i)];
+	AssertFatal(ip<128,"ip = %d\n",ip);
+	bit_i=(val>>i)&1;
+	if (ip<64) polarParams->cprime_tab0[byte][val] |= (((uint64_t)bit_i)<<ip);				
+	else       polarParams->cprime_tab1[byte][val] |= (((uint64_t)bit_i)<<(ip&63));				
+      }
+    }
+  }
+
+  AssertFatal(polarParams->N==512,"N = %d, not done yet\n",polarParams->N);
+
+  // build G bit vectors for information bit positions and convert the bit as bytes tables in nr_polar_kronecker_power_matrices.c to 64 bit packed vectors.
+  // keep only rows of G which correspond to information/crc bits
+  polarParams->G_N_tab = (uint64_t**)malloc(polarParams->K * sizeof(int64_t*));
+  int k=0;
+  for (int i=0;i<polarParams->N;i++) {
+    if (polarParams->information_bit_pattern[i] > 0) {
+      polarParams->G_N_tab[k] = (uint64_t*)memalign(32,(polarParams->N/64)*sizeof(uint64_t));
+      memset((void*)polarParams->G_N_tab[k],0,(polarParams->N/64)*sizeof(uint64_t));
+      for (int j=0;j<polarParams->N;j++) 
+	polarParams->G_N_tab[k][j/64] |= ((uint64_t)polarParams->G_N[i][j])<<(j&63);
+#ifdef DEBUG_POLAR_ENCODER
+      printf("Bit %d Selecting row %d of G : ",k,i);
+      for (int j=0;j<polarParams->N;j+=4) printf("%1x",polarParams->G_N[i][j]+(polarParams->G_N[i][j+1]*2)+(polarParams->G_N[i][j+2]*4)+(polarParams->G_N[i][j+3]*8));
+      printf("\n");
+#endif
+      k++;
+    }
+  }
+
+  // rate matching table
+  int iplast=polarParams->rate_matching_pattern[0];
+  int ccnt=0;
+  int groupcnt=0;
+  int firstingroup_out=0;
+  int firstingroup_in=iplast;
+  int mingroupsize = 1024;
+  // compute minimum group size of rate-matching pattern
+  for (int outpos=1; outpos<polarParams->encoderLength; outpos++) {
+    
+    ip=polarParams->rate_matching_pattern[outpos];
+    if ((ip - iplast) == 1) ccnt++;
+    else {
+      groupcnt++;
+#ifdef DEBUG_POLAR_ENCODER
+      printf("group %d (size %d): (%d:%d) => (%d:%d)\n",groupcnt,ccnt+1,
+	     firstingroup_in,firstingroup_in+ccnt,
+	     firstingroup_out,firstingroup_out+ccnt);
+#endif
+      if ((ccnt+1)<mingroupsize) mingroupsize=ccnt+1;
+      ccnt=0;
+      firstingroup_out=outpos;
+      firstingroup_in=ip;
+    }
+    iplast=ip;
+  }
+  AssertFatal(mingroupsize==8 || mingroupsize==16,"mingroupsize %d, needs to be handled\n",mingroupsize);
+  polarParams->groupsize=mingroupsize;
+  int shift=3;
+  if (mingroupsize == 16) shift=4;
+  polarParams->rm_tab=(int*)malloc(sizeof(int)*polarParams->encoderLength/mingroupsize);
+  // rerun again to create groups
+  int tcnt=0;
+  for (int outpos=0;outpos<polarParams->encoderLength; outpos+=mingroupsize,tcnt++) 
+    polarParams->rm_tab[tcnt] = polarParams->rate_matching_pattern[outpos]>>shift;
+    
+}
+
+void polar_encoder_fast(uint64_t *A,
+			uint32_t *out,
+			int32_t crcmask,
+			t_nrPolar_paramsPtr polarParams) {
+
+  AssertFatal(polarParams->K > 32, "K = %d < 33, is not supported yet\n",polarParams->K);
+  AssertFatal(polarParams->K < 129, "K = %d > 64, is not supported yet\n",polarParams->K);
+
+  uint64_t B[4]={0,0,0,0},Cprime[4]={0,0,0,0};
+  int bitlen = polarParams->payloadBits;
+
+  // append crc
+ 
+  AssertFatal(bitlen<129,"support for payloads <= 128 bits\n");
+  AssertFatal(polarParams->crcParityBits == 24,"support for 24-bit crc only for now\n");
+
+  int bitlen0=bitlen;
+
+  uint64_t tcrc=0;
+
+  // A bitstring should be stored as a_{N-1} a_{N-2} ... a_{N-A} 0 .... 0, where N=64,128,192,..., N is smallest multiple of 64 greater than or equal to A
+
+  // First flip A bitstring byte endian for CRC routines (optimized for DLSCH/ULSCH, not PBCH/PDCCH)
+  // CRC reads in each byte in bit positions 7 downto 0, for PBCH/PDCCH we need to read in a_{A-1} downto a_{0}, A = length of bit string (e.g. 32 for PBCH)
+  if (bitlen<=32) {
+    uint8_t A32_flip[4];
+    uint32_t Aprime= (uint32_t)(((uint32_t)*A)<<(32-bitlen));
+    A32_flip[0]=((uint8_t*)&Aprime)[3];
+    A32_flip[1]=((uint8_t*)&Aprime)[2];
+    A32_flip[2]=((uint8_t*)&Aprime)[1];
+    A32_flip[3]=((uint8_t*)&Aprime)[0];
+    tcrc = (uint64_t)((crcmask^(crc24c(A32_flip,bitlen)>>8)));
+  }
+  else if (bitlen<=64) {
+    uint8_t A64_flip[8];
+    uint64_t Aprime= (uint32_t)(((uint64_t)*A)<<(64-bitlen));
+    A64_flip[0]=((uint8_t*)&Aprime)[7];
+    A64_flip[1]=((uint8_t*)&Aprime)[6];
+    A64_flip[2]=((uint8_t*)&Aprime)[5];
+    A64_flip[3]=((uint8_t*)&Aprime)[4];
+    A64_flip[4]=((uint8_t*)&Aprime)[3];
+    A64_flip[5]=((uint8_t*)&Aprime)[2];
+    A64_flip[6]=((uint8_t*)&Aprime)[1];
+    A64_flip[7]=((uint8_t*)&Aprime)[0];
+    tcrc = (uint64_t)((crcmask^(crc24c(A64_flip,bitlen)>>8)));
+  }
+
+  int n;
+  // this is number of quadwords in the bit string
+  int quadwlen = (polarParams->K>>6);
+  if ((polarParams->K&63) > 0) quadwlen++;
+
+  // Create the B bitstring as
+  // b_{N'-1} b_{N'-2} ... b_{N'-A} b_{N'-A-1} ... b_{N'-A-Nparity} = a_{N-1} a_{N-2} ... a_{N-A} p_{N_parity-1} ... p_0
+
+  for (n=0;n<quadwlen;n++) if (n==0) B[n] = (A[n] << polarParams->crcParityBits) | tcrc;
+                           else      B[n] = (A[n] << polarParams->crcParityBits) | (A[n-1]>>64-polarParams->crcParityBits);
+  
+    
+  uint8_t *Bbyte = (uint8_t*)B;
+  // for each byte of B, lookup in corresponding table for 64-bit word corresponding to that byte and its position
+  if (polarParams->K<65) 
+    Cprime[0] = polarParams->cprime_tab0[0][Bbyte[0]] |
+                polarParams->cprime_tab0[1][Bbyte[1]] |
+                polarParams->cprime_tab0[2][Bbyte[2]] |
+                polarParams->cprime_tab0[3][Bbyte[3]] |
+                polarParams->cprime_tab0[4][Bbyte[4]] |
+                polarParams->cprime_tab0[5][Bbyte[5]] |
+                polarParams->cprime_tab0[6][Bbyte[6]] |
+                polarParams->cprime_tab0[7][Bbyte[7]];
+  
+  else if (polarParams->K < 129) {
+    for (int i=0;i<1+(polarParams->K/8);i++) {
+      Cprime[0] |= polarParams->cprime_tab0[i][Bbyte[i]];
+      Cprime[1] |= polarParams->cprime_tab1[i][Bbyte[i]];
+    }
+  }
+
+#ifdef DEBUG_POLAR_ENCODER
+  if (polarParams->K<65) 
+    printf("A %llx B %llx Cprime %llx (payload bits %d,crc %x)\n",
+	   (unsigned long long)(A[0]&(((uint64_t)1<<bitlen)-1)),
+	   (unsigned long long)(B[0]),
+	   (unsigned long long)(Cprime[0]),
+	   polarParams->payloadBits,
+	   tcrc);
+  else if (polarParams->K<129) {
+    if (bitlen<64)
+      printf("A %llx B %llx|%llx Cprime %llx|%llx (payload bits %d,crc %x)\n",
+	     (unsigned long long)(A[0]&(((uint64_t)1<<bitlen)-1)),
+	     (unsigned long long)(B[1]),(unsigned long long)(B[0]),
+	     (unsigned long long)(Cprime[1]),(unsigned long long)(Cprime[0]),
+	     polarParams->payloadBits,
+	     tcrc);
+    else 
+      printf("A %llx|%llx B %llx|%llx Cprime %llx|%llx (payload bits %d,crc %x)\n",
+	     (unsigned long long)(A[1]&(((uint64_t)1<<(bitlen-64))-1)),(unsigned long long)(A[0]),
+	     (unsigned long long)(B[1]),(unsigned long long)(B[0]),
+	     (unsigned long long)(Cprime[1]),(unsigned long long)(Cprime[0]),
+	     polarParams->payloadBits,
+	     crc24c((uint8_t*)A,bitlen)>>8);
+  }
+#endif
+  /*  printf("Bbytes : %x.%x.%x.%x.%x.%x.%x.%x\n",Bbyte[0],Bbyte[1],Bbyte[2],Bbyte[3],Bbyte[4],Bbyte[5],Bbyte[6],Bbyte[7]);
+  printf("%llx,%llx,%llx,%llx,%llx,%llx,%llx,%llx\n",polarParams->cprime_tab[0][Bbyte[0]] , 
+		  polarParams->cprime_tab[1][Bbyte[1]] , 
+		  polarParams->cprime_tab[2][Bbyte[2]] , 
+		  polarParams->cprime_tab[3][Bbyte[3]] , 
+		  polarParams->cprime_tab[4][Bbyte[4]] , 
+		  polarParams->cprime_tab[5][Bbyte[5]] , 
+		  polarParams->cprime_tab[6][Bbyte[6]] , 
+		  polarParams->cprime_tab[7][Bbyte[7]]);*/
+  
+  // now do Gu product (here using 64-bit XORs, we can also do with SIMD after)
+  // here we're reading out the bits LSB -> MSB, is this correct w.r.t. 3GPP ?
+
+  uint64_t Cprime_i;
+  /*  printf("%llx Cprime_0 (%llx) G %llx,%llx,%llx,%llx,%llx,%llx,%llx,%llx\n",Cprime_i,Cprime &1,
+	 polarParams->G_N_tab[0][0],
+	 polarParams->G_N_tab[0][1],
+	 polarParams->G_N_tab[0][2],
+	 polarParams->G_N_tab[0][3],
+	 polarParams->G_N_tab[0][4],
+	 polarParams->G_N_tab[0][5],
+	 polarParams->G_N_tab[0][6],
+	 polarParams->G_N_tab[0][7]);*/
+  uint64_t D[8]={0,0,0,0,0,0,0,0};
+  int off=0;
+  int len=polarParams->K;
+  for (int j=0;j<(1+(polarParams->K>>6));j++,off+=64,len-=64) {
+    for (int i=0;i<((len>63) ? 64 : len);i++) {
+
+      Cprime_i = -((Cprime[j]>>i)&1); // this converts bit 0 as, 0 => 0000x00, 1 => 1111x11
+      /*
+#ifdef DEBUG_POLAR_ENCODER
+      printf("%llx Cprime_%d (%llx) G %llx,%llx,%llx,%llx,%llx,%llx,%llx,%llx\n",
+	     Cprime_i,off+i,(Cprime[j]>>i) &1,
+	     polarParams->G_N_tab[off+i][0],
+	     polarParams->G_N_tab[off+i][1],
+	     polarParams->G_N_tab[off+i][2],
+	     polarParams->G_N_tab[off+i][3],
+	     polarParams->G_N_tab[off+i][4],
+	     polarParams->G_N_tab[off+i][5],
+	     polarParams->G_N_tab[off+i][6],
+	     polarParams->G_N_tab[off+i][7]);
+#endif
+      */
+      uint64_t *Gi=polarParams->G_N_tab[off+i];
+      D[0] ^= (Cprime_i & Gi[0]);
+      D[1] ^= (Cprime_i & Gi[1]);
+      D[2] ^= (Cprime_i & Gi[2]);
+      D[3] ^= (Cprime_i & Gi[3]);
+      D[4] ^= (Cprime_i & Gi[4]);
+      D[5] ^= (Cprime_i & Gi[5]);
+      D[6] ^= (Cprime_i & Gi[6]);
+      D[7] ^= (Cprime_i & Gi[7]);
+    }
+  }
+#ifdef DEBUG_POLAR_ENCODER
+  printf("D %llx,%llx,%llx,%llx,%llx,%llx,%llx,%llx\n",
+	 D[0],
+	 D[1],
+	 D[2],
+	 D[3],
+	 D[4],
+	 D[5],
+	 D[6],
+	 D[7]);
+#endif
+
+  polar_rate_matching(polarParams,(void*)D,(void*)out);  
 
-
-	start_meas(&timeEncoderCRCBit);
-	nr_bit2byte_uint32_8_t(in, polarParams->payloadBits, polarParams->nr_polar_A);
-	nr_matrix_multiplication_uint8_t_1D_uint8_t_2D(polarParams->nr_polar_A, polarParams->crc_generator_matrix, polarParams->nr_polar_crc, polarParams->payloadBits, polarParams->crcParityBits); //Calculate CRC.
-	for (uint8_t i = 0; i < polarParams->crcParityBits; i++) polarParams->nr_polar_crc[i] = (polarParams->nr_polar_crc[i] % 2);
-	for (uint16_t i = 0; i < polarParams->payloadBits; i++) polarParams->nr_polar_B[i] = polarParams->nr_polar_A[i]; //Attach CRC to the Transport Block. (a to b)
-	for (uint16_t i = polarParams->payloadBits; i < polarParams->K; i++) polarParams->nr_polar_B[i]= polarParams->nr_polar_crc[i-(polarParams->payloadBits)];
-	stop_meas(&timeEncoderCRCBit);
-
-
-	start_meas(&timeEncoderInterleaver); //Interleaving (c to c')
-	nr_polar_interleaver(polarParams->nr_polar_B, polarParams->nr_polar_CPrime, polarParams->interleaving_pattern, polarParams->K);
-	stop_meas(&timeEncoderInterleaver);
-
-
-	start_meas(&timeEncoderBitInsertion); //Bit insertion (c' to u)
-	nr_polar_bit_insertion(polarParams->nr_polar_CPrime, polarParams->nr_polar_U, polarParams->N, polarParams->K, polarParams->Q_I_N, polarParams->Q_PC_N, polarParams->n_pc);
-	stop_meas(&timeEncoderBitInsertion);
-
-
-	start_meas(&timeEncoder1); //Encoding (u to d)
-	nr_matrix_multiplication_uint8_t_1D_uint8_t_2D(polarParams->nr_polar_U, polarParams->G_N, polarParams->nr_polar_D, polarParams->N, polarParams->N);
-	stop_meas(&timeEncoder1);
-
-
-	start_meas(&timeEncoder2);
-	for (uint16_t i = 0; i < polarParams->N; i++) polarParams->nr_polar_D[i] = (polarParams->nr_polar_D[i] % 2);
-	stop_meas(&timeEncoder2);
-
-
-	start_meas(&timeEncoderRateMatching);//Rate matching //Sub-block interleaving (d to y) and Bit selection (y to e)
-	nr_polar_interleaver(polarParams->nr_polar_D, polarParams->nr_polar_E, polarParams->rate_matching_pattern, polarParams->encoderLength);
-	stop_meas(&timeEncoderRateMatching);
-
-
-	start_meas(&timeEncoderByte2Bit); //Return bits.
-	nr_byte2bit_uint8_32_t(polarParams->nr_polar_E, polarParams->encoderLength, out);
-	stop_meas(&timeEncoderByte2Bit);
-
-	fprintf(logFile,",%f,%f,%f,%f,%f,%f,%f,%f\n",
-			(timeEncoderCRCByte.diff/(cpuFreqGHz*1000.0)),
-			(timeEncoderCRCBit.diff/(cpuFreqGHz*1000.0)),
-			(timeEncoderInterleaver.diff/(cpuFreqGHz*1000.0)),
-			(timeEncoderBitInsertion.diff/(cpuFreqGHz*1000.0)),
-			(timeEncoder1.diff/(cpuFreqGHz*1000.0)),
-			(timeEncoder2.diff/(cpuFreqGHz*1000.0)),
-			(timeEncoderRateMatching.diff/(cpuFreqGHz*1000.0)),
-			(timeEncoderByte2Bit.diff/(cpuFreqGHz*1000.0)));
 }

openair1/PHY/CODING/nrPolar_tools/nr_polar_matrix_and_array.c

@@ -32,7 +32,7 @@
 
 #include "PHY/CODING/nrPolar_tools/nr_polar_defs.h"
 
-void nr_matrix_multiplication_uint8_t_1D_uint8_t_2D(uint8_t *matrix1, uint8_t **matrix2,
+void nr_matrix_multiplication_uint8_1D_uint8_2D(uint8_t *matrix1, uint8_t **matrix2,
 		uint8_t *output, uint16_t row, uint16_t col) {
 
 	for (uint16_t i = 0; i < col; i++) {
@@ -43,12 +43,12 @@ void nr_matrix_multiplication_uint8_t_1D_uint8_t_2D(uint8_t *matrix1, uint8_t **
 	}
 }
 
-uint8_t ***nr_alloc_uint8_t_3D_array(uint16_t xlen, uint16_t ylen, uint16_t zlen) {
+uint8_t ***nr_alloc_uint8_3D_array(uint16_t xlen, uint16_t ylen, uint16_t zlen) {
 	uint8_t ***output;
 	int i, j;
 
 	if ((output = malloc(xlen * sizeof(*output))) == NULL) {
-		perror("[nr_alloc_uint8_t_3D_array] Problem at 1D allocation");
+		perror("[nr_alloc_uint8_3D_array] Problem at 1D allocation");
 		return NULL;
 	}
 	for (i = 0; i < xlen; i++)
@@ -57,8 +57,8 @@ uint8_t ***nr_alloc_uint8_t_3D_array(uint16_t xlen, uint16_t ylen, uint16_t zlen
 
 	for (i = 0; i < xlen; i++)
 		if ((output[i] = malloc(ylen * sizeof *output[i])) == NULL) {
-			perror("[nr_alloc_uint8_t_3D_array] Problem at 2D allocation");
-			nr_free_uint8_t_3D_array(output, xlen, ylen);
+			perror("[nr_alloc_uint8_3D_array] Problem at 2D allocation");
+			nr_free_uint8_3D_array(output, xlen, ylen);
 			return NULL;
 		}
 	for (i = 0; i < xlen; i++)
@@ -69,14 +69,39 @@ uint8_t ***nr_alloc_uint8_t_3D_array(uint16_t xlen, uint16_t ylen, uint16_t zlen
 	for (i = 0; i < xlen; i++)
 		for (j = 0; j < ylen; j++)
 			if ((output[i][j] = malloc(zlen * sizeof *output[i][j])) == NULL) {
-				perror("[nr_alloc_uint8_t_3D_array] Problem at 3D allocation");
-				nr_free_uint8_t_3D_array(output, xlen, ylen);
+				perror("[nr_alloc_uint8_3D_array] Problem at 3D allocation");
+				nr_free_uint8_3D_array(output, xlen, ylen);
 				return NULL;
 			}
 
 	return output;
 }
 
+uint8_t **nr_alloc_uint8_2D_array(uint16_t xlen, uint16_t ylen) {
+	uint8_t **output;
+	int i, j;
+
+	if ((output = malloc(xlen * sizeof(*output))) == NULL) {
+		perror("[nr_alloc_uint8_2D_array] Problem at 1D allocation");
+		return NULL;
+	}
+	for (i = 0; i < xlen; i++)
+		output[i] = NULL;
+
+
+	for (i = 0; i < xlen; i++)
+		if ((output[i] = malloc(ylen * sizeof *output[i])) == NULL) {
+			perror("[nr_alloc_uint8_2D_array] Problem at 2D allocation");
+			nr_free_uint8_2D_array(output, xlen);
+			return NULL;
+		}
+	for (i = 0; i < xlen; i++)
+		for (j = 0; j < ylen; j++)
+			output[i][j] = 0;
+
+	return output;
+}
+
 double ***nr_alloc_double_3D_array(uint16_t xlen, uint16_t ylen, uint16_t zlen) {
 	double ***output;
 	int i, j;
@@ -137,31 +162,6 @@ double **nr_alloc_double_2D_array(uint16_t xlen, uint16_t ylen) {
   return output;
 }
 
-uint8_t **nr_alloc_uint8_t_2D_array(uint16_t xlen, uint16_t ylen) {
-	uint8_t **output;
-	int i, j;
-
-	if ((output = malloc(xlen * sizeof(*output))) == NULL) {
-		perror("[nr_alloc_uint8_t_2D_array] Problem at 1D allocation");
-		return NULL;
-	}
-	for (i = 0; i < xlen; i++)
-		output[i] = NULL;
-
-
-	for (i = 0; i < xlen; i++)
-		if ((output[i] = malloc(ylen * sizeof *output[i])) == NULL) {
-			perror("[nr_alloc_uint8_t_2D_array] Problem at 2D allocation");
-			nr_free_uint8_t_2D_array(output, xlen);
-			return NULL;
-		}
-	for (i = 0; i < xlen; i++)
-		for (j = 0; j < ylen; j++)
-			output[i][j] = 0;
-
-	return output;
-}
-
 void nr_free_double_3D_array(double ***input, uint16_t xlen, uint16_t ylen) {
 	int i, j;
 
@@ -174,7 +174,16 @@ void nr_free_double_3D_array(double ***input, uint16_t xlen, uint16_t ylen) {
 	free(input);
 }
 
-void nr_free_uint8_t_3D_array(uint8_t ***input, uint16_t xlen, uint16_t ylen) {
+void nr_free_double_2D_array(double **input, uint16_t xlen) {
+  int i;
+
+  for (i = 0; i < xlen; i++) {
+    free(input[i]);
+  }
+  free(input);
+}
+
+void nr_free_uint8_3D_array(uint8_t ***input, uint16_t xlen, uint16_t ylen) {
 	int i, j;
 
 	for (i = 0; i < xlen; i++) {
@@ -186,20 +195,11 @@ void nr_free_uint8_t_3D_array(uint8_t ***input, uint16_t xlen, uint16_t ylen) {
 	free(input);
 }
 
-void nr_free_uint8_t_2D_array(uint8_t **input, uint16_t xlen) {
+void nr_free_uint8_2D_array(uint8_t **input, uint16_t xlen) {
   for (int i = 0; i < xlen; i++) free(input[i]);
   free(input);
 }
 
-void nr_free_double_2D_array(double **input, uint16_t xlen) {
-  int i;
-  
-  for (i = 0; i < xlen; i++) {
-    free(input[i]);
-  }
-  free(input);
-}
-
 // Modified Bubble Sort.
 void nr_sort_asc_double_1D_array_ind(double *matrix, uint8_t *ind, uint8_t len) {
 	int swaps;

openair1/PHY/CODING/nrPolar_tools/nr_polar_procedures.c

@@ -33,15 +33,15 @@
 #include "PHY/CODING/nrPolar_tools/nr_polar_defs.h"
 
 void nr_polar_bit_insertion(uint8_t *input,
-						    uint8_t *output,
-							uint16_t N,
-							uint16_t K,
-							int16_t *Q_I_N,
-							int16_t *Q_PC_N,
-							uint8_t n_PC)
+			    uint8_t *output,
+			    uint16_t N,
+			    uint16_t K,
+			    int16_t *Q_I_N,
+			    int16_t *Q_PC_N,
+			    uint8_t n_PC)
 {
-	uint16_t k=0;
-	uint8_t flag;
+  uint16_t k=0;
+  uint8_t flag;
 
 	if (n_PC>0) {
 		/*
@@ -325,7 +325,7 @@ void nr_polar_rate_matching_int16(int16_t *input, int16_t *output, uint16_t *rmp
 		if ( (K/(double)E) <= (7.0/16) ) { //puncturing
 			for (int i=0; i<=N-1; i++) output[i]=0;
 		} else { //shortening
-			for (int i=0; i<=N-1; i++) output[i]=INFINITY;
+			for (int i=0; i<=N-1; i++) output[i]=32767;//instead of INFINITY, to prevent [-Woverflow]
 		}
 
 		for (int i=0; i<=E-1; i++){

openair1/PHY/CODING/nr_compute_tbs.c

@@ -40,9 +40,9 @@ uint32_t nr_compute_tbs(uint8_t mcs,
 						uint16_t length_dmrs,
 						uint8_t Nl)
 {
-	uint16_t nbp_re, nb_re, nb_dmrs_prb, nb_rb_oh,Qm,R;
-	uint32_t nr_tbs=0;
-	double Ninfo,Np_info,n,C;
+	uint16_t nbp_re, nb_re, nb_dmrs_prb, nb_rb_oh, Ninfo,Np_info,n,Qm,R,C;
+
+	uint32_t nr_tbs = 0;//Initialization to remove [-Wmaybe-uninitialized]
 
 	nb_rb_oh = 0; //set to 0 if not configured by higher layer
 	Qm = Mcsindextable1[mcs][0];

openair1/PHY/CODING/nr_polar_init.c

@@ -36,20 +36,27 @@
 #include "PHY/CODING/nrPolar_tools/nr_polar_pbch_defs.h"
 #include "PHY/NR_TRANSPORT/nr_dci.h"
 
+static int intcmp(const void *p1,const void *p2) {
+
+  return(*(int16_t*)p1 > *(int16_t*)p2);
+}
+
 void nr_polar_init(t_nrPolar_paramsPtr *polarParams,
-				   int8_t messageType,
-				   uint16_t messageLength,
-				   uint8_t aggregation_level)
+		   int8_t messageType,
+		   uint16_t messageLength,
+		   uint8_t aggregation_level)
 {
 	t_nrPolar_paramsPtr currentPtr = *polarParams;
 	uint16_t aggregation_prime = nr_polar_aggregation_prime(aggregation_level);
 
 	//Parse the list. If the node is already created, return without initialization.
 	while (currentPtr != NULL) {
-		if (currentPtr->idx == (messageType * messageLength * aggregation_prime)) return;
-		else currentPtr = currentPtr->nextPtr;
+	  printf("currentPtr->idx %d, (%d,%d,%d)\n",currentPtr->idx,messageType,messageLength,aggregation_prime);
+	  if (currentPtr->idx == (messageType * messageLength * aggregation_prime)) return;
+	  else currentPtr = currentPtr->nextPtr;
 	}
 
+	printf("currentPtr %p (polarParams %p)\n",currentPtr,polarParams);
 	//Else, initialize and add node to the end of the linked list.
 	t_nrPolar_paramsPtr newPolarInitNode = malloc(sizeof(t_nrPolar_params));
 
@@ -70,6 +77,7 @@ void nr_polar_init(t_nrPolar_paramsPtr *polarParams,
 			newPolarInitNode->encoderLength = NR_POLAR_PBCH_E;
 			newPolarInitNode->crcCorrectionBits = NR_POLAR_PBCH_CRC_ERROR_CORRECTION_BITS;
 			newPolarInitNode->crc_generator_matrix = crc24c_generator_matrix(newPolarInitNode->payloadBits);//G_P
+			//printf("Initializing polar parameters for PBCH (K %d, E %d)\n",newPolarInitNode->payloadBits,newPolarInitNode->encoderLength);
 		} else if (messageType == 1) { //DCI
 			newPolarInitNode->n_max = NR_POLAR_DCI_N_MAX;
 			newPolarInitNode->i_il = NR_POLAR_DCI_I_IL;
@@ -82,6 +90,7 @@ void nr_polar_init(t_nrPolar_paramsPtr *polarParams,
 			newPolarInitNode->encoderLength = aggregation_level*108;
 			newPolarInitNode->crcCorrectionBits = NR_POLAR_DCI_CRC_ERROR_CORRECTION_BITS;
 			newPolarInitNode->crc_generator_matrix=crc24c_generator_matrix(newPolarInitNode->payloadBits+newPolarInitNode->crcParityBits);//G_P
+			//printf("Initializing polar parameters for DCI (K %d, E %d, L %d)\n",newPolarInitNode->payloadBits,newPolarInitNode->encoderLength,aggregation_level);
 		} else if (messageType == -1) { //UCI
 
 		} else {
@@ -115,6 +124,10 @@ void nr_polar_init(t_nrPolar_paramsPtr *polarParams,
 									  newPolarInitNode->i_il,
 									  newPolarInitNode->interleaving_pattern);
 
+		newPolarInitNode->deinterleaving_pattern = malloc(sizeof(uint16_t) * newPolarInitNode->K);
+		for (int i=0;i<newPolarInitNode->K;i++)
+		  newPolarInitNode->deinterleaving_pattern[newPolarInitNode->interleaving_pattern[i]] = i;
+
 		newPolarInitNode->rate_matching_pattern = malloc(sizeof(uint16_t) * newPolarInitNode->encoderLength);
 		uint16_t *J = malloc(sizeof(uint16_t) * newPolarInitNode->N);
 		nr_polar_rate_matching_pattern(newPolarInitNode->rate_matching_pattern,
@@ -139,7 +152,9 @@ void nr_polar_init(t_nrPolar_paramsPtr *polarParams,
 								  newPolarInitNode->N,
 								  newPolarInitNode->encoderLength,
 								  newPolarInitNode->n_pc);
-
+		// sort the Q_I_N array in ascending order (first K positions)
+		qsort((void*)newPolarInitNode->Q_I_N,newPolarInitNode->K,sizeof(int16_t),intcmp);
+ 
 		newPolarInitNode->channel_interleaver_pattern = malloc(sizeof(uint16_t) * newPolarInitNode->encoderLength);
 		nr_polar_channel_interleaver_pattern(newPolarInitNode->channel_interleaver_pattern,
 											 newPolarInitNode->i_bil,
@@ -148,6 +163,9 @@ void nr_polar_init(t_nrPolar_paramsPtr *polarParams,
 		free(J);
 
 		build_decoder_tree(newPolarInitNode);
+		build_polar_tables(newPolarInitNode);
+		init_polar_deinterleaver_table(newPolarInitNode);
+
 		//printf("decoder tree nodes %d\n",newPolarInitNode->tree.num_nodes);
 
 	} else {
@@ -159,13 +177,18 @@ void nr_polar_init(t_nrPolar_paramsPtr *polarParams,
 	if (currentPtr == NULL)
 	{
 		*polarParams = newPolarInitNode;
+		printf("Creating first polarParams entry index %d, %p\n",newPolarInitNode->idx,*polarParams);
 		return;
 	}
 	//Else, add node to the end of the linked list.
 	while (currentPtr->nextPtr != NULL) {
-			currentPtr = currentPtr->nextPtr;
+	  currentPtr = currentPtr->nextPtr;
 	}
 	currentPtr->nextPtr= newPolarInitNode;
+	printf("Adding new polarParams entry to list index %d,%p\n",
+	       newPolarInitNode->idx,
+	       currentPtr->nextPtr);
+
 	return;
 }
 

openair1/PHY/CODING/nr_segmentation.c

@@ -38,7 +38,8 @@ int32_t nr_segmentation(unsigned char *input_buffer,
                      unsigned int *F)
 {
 
-  unsigned int L,Bprime,Bprime_by_C,Z,r,Kb,k,s,crc,Kprime;
+
+  unsigned int L,Bprime,Bprime_by_C,Z,r,Kb,k,s,Kprime,crc;
 
   if (B<=8448) {
     L=0;

openair1/PHY/INIT/nr_init.c

@@ -37,8 +37,8 @@
 #include "PHY/LTE_REFSIG/lte_refsig.h"
 #include "SCHED_NR/fapi_nr_l1.h"
 
-extern uint32_t from_earfcn(int eutra_bandP,uint32_t dl_earfcn);
-extern int32_t get_uldl_offset(int eutra_bandP);
+extern uint32_t from_nrarfcn(int nr_bandP,uint32_t dl_nrarfcn);
+extern int32_t get_uldl_offset(int nr_bandP);
 
 int l1_north_init_gNB() {
 
@@ -125,10 +125,11 @@ int phy_init_nr_gNB(PHY_VARS_gNB *gNB,
   // PBCH DMRS gold sequences generation
   nr_init_pbch_dmrs(gNB);
   // Polar encoder init for PBCH
+  
   nr_polar_init(&gNB->nrPolar_params,
-        NR_POLAR_PBCH_MESSAGE_TYPE,
-				NR_POLAR_PBCH_PAYLOAD_BITS,
-				NR_POLAR_PBCH_AGGREGATION_LEVEL);
+		NR_POLAR_PBCH_MESSAGE_TYPE,
+		NR_POLAR_PBCH_PAYLOAD_BITS,
+		NR_POLAR_PBCH_AGGREGATION_LEVEL);
 
   //PDCCH DMRS init
   gNB->nr_gold_pdcch_dmrs = (uint32_t ***)malloc16(fp->slots_per_frame*sizeof(uint32_t**));
@@ -398,8 +399,8 @@ void nr_phy_config_request_sim(PHY_VARS_gNB *gNB,int N_RB_DL,int N_RB_UL,int mu)
   nfapi_nr_config_request_t *gNB_config = &gNB->gNB_config;
 
   //overwrite for new NR parameters
-  gNB_config->nfapi_config.rf_bands.rf_band[0] = 22;
-  gNB_config->nfapi_config.earfcn.value = 6600;
+  gNB_config->nfapi_config.rf_bands.rf_band[0] = 22; //78;
+  gNB_config->nfapi_config.nrarfcn.value = 6600; //620000;
   gNB_config->subframe_config.numerology_index_mu.value = mu;
   gNB_config->subframe_config.duplex_mode.value = TDD;
   gNB_config->rf_config.tx_antenna_ports.value = 1;
@@ -413,7 +414,7 @@ void nr_phy_config_request_sim(PHY_VARS_gNB *gNB,int N_RB_DL,int N_RB_UL,int mu)
 
   gNB->mac_enabled     = 1;
 
-  fp->dl_CarrierFreq = from_earfcn(gNB_config->nfapi_config.rf_bands.rf_band[0],gNB_config->nfapi_config.earfcn.value);
+  fp->dl_CarrierFreq = 3510000000; //from_nrarfcn(gNB_config->nfapi_config.rf_bands.rf_band[0],gNB_config->nfapi_config.nrarfcn.value);
   fp->ul_CarrierFreq = fp->dl_CarrierFreq - (get_uldl_offset(gNB_config->nfapi_config.rf_bands.rf_band[0])*100000);
   fp->threequarter_fs                    = 0;
 
@@ -435,7 +436,7 @@ void nr_phy_config_request(NR_PHY_Config_t *phy_config)
 
 
   gNB_config->nfapi_config.rf_bands.rf_band[0]          = phy_config->cfg->nfapi_config.rf_bands.rf_band[0]; //22
-  gNB_config->nfapi_config.earfcn.value                 = phy_config->cfg->nfapi_config.earfcn.value; //6600
+  gNB_config->nfapi_config.nrarfcn.value                = phy_config->cfg->nfapi_config.nrarfcn.value; //6600
   gNB_config->subframe_config.numerology_index_mu.value = phy_config->cfg->subframe_config.numerology_index_mu.value;//1
   gNB_config->rf_config.tx_antenna_ports.value          = phy_config->cfg->rf_config.tx_antenna_ports.value; //1
   gNB_config->rf_config.dl_carrier_bandwidth.value      = phy_config->cfg->rf_config.dl_carrier_bandwidth.value;//106;
@@ -443,7 +444,7 @@ void nr_phy_config_request(NR_PHY_Config_t *phy_config)
   gNB_config->sch_config.half_frame_index.value         = 0;
   gNB_config->sch_config.ssb_subcarrier_offset.value    = phy_config->cfg->sch_config.ssb_subcarrier_offset.value;//0;
   gNB_config->sch_config.n_ssb_crb.value                = (phy_config->cfg->rf_config.dl_carrier_bandwidth.value-20);
-  gNB_config->sch_config.physical_cell_id.value         = phy_config->cfg->sch_config.physical_cell_id.value;
+  gNB_config->sch_config.physical_cell_id.value         = 1; //phy_config->cfg->sch_config.physical_cell_id.value;
 
   if (phy_config->cfg->subframe_config.duplex_mode.value == 0) {
     gNB_config->subframe_config.duplex_mode.value    = TDD;
@@ -454,20 +455,20 @@ void nr_phy_config_request(NR_PHY_Config_t *phy_config)
 
   RC.gNB[Mod_id][CC_id]->mac_enabled     = 1;
 
-  fp->dl_CarrierFreq = from_earfcn(gNB_config->nfapi_config.rf_bands.rf_band[0],gNB_config->nfapi_config.earfcn.value);
+  fp->dl_CarrierFreq = 3510000000; //from_nrarfcn(gNB_config->nfapi_config.rf_bands.rf_band[0],gNB_config->nfapi_config.nrarfcn.value);
   fp->ul_CarrierFreq = fp->dl_CarrierFreq - (get_uldl_offset(gNB_config->nfapi_config.rf_bands.rf_band[0])*100000);
   fp->threequarter_fs                    = 0;
 
   LOG_I(PHY,"Configuring MIB for instance %d, CCid %d : (band %d,N_RB_DL %d, N_RB_UL %d, Nid_cell %d,gNB_tx_antenna_ports %d,DL freq %u)\n",
-  Mod_id, 
-  CC_id, 
-  gNB_config->nfapi_config.rf_bands.rf_band[0], 
-  gNB_config->rf_config.dl_carrier_bandwidth.value, 
-  gNB_config->rf_config.ul_carrier_bandwidth.value, 
-  gNB_config->sch_config.physical_cell_id.value, 
-  gNB_config->rf_config.tx_antenna_ports.value,
-  fp->dl_CarrierFreq );
-
+	Mod_id, 
+	CC_id, 
+	gNB_config->nfapi_config.rf_bands.rf_band[0], 
+	gNB_config->rf_config.dl_carrier_bandwidth.value, 
+	gNB_config->rf_config.ul_carrier_bandwidth.value, 
+	gNB_config->sch_config.physical_cell_id.value, 
+	gNB_config->rf_config.tx_antenna_ports.value,
+	fp->dl_CarrierFreq );
+  
   nr_init_frame_parms(gNB_config, fp);
 
   if (RC.gNB[Mod_id][CC_id]->configured == 1){

openair1/PHY/INIT/nr_init_ue.c

@@ -954,12 +954,7 @@ void phy_init_nr_top(PHY_VARS_NR_UE *ue)
   generate_ul_reference_signal_sequences(SHRT_MAX);
 
   // Polar encoder init for PBCH
-
-  ue->nrPolar_params = NULL;
-  nr_polar_init(&ue->nrPolar_params,
-		NR_POLAR_PBCH_MESSAGE_TYPE,
-		NR_POLAR_PBCH_PAYLOAD_BITS,
-		NR_POLAR_PBCH_AGGREGATION_LEVEL);
+  
   //lte_sync_time_init(frame_parms);
 
   //generate_ul_ref_sigs();

openair1/PHY/INIT/nr_parms.c

@@ -176,7 +176,9 @@ int nr_init_frame_parms0(NR_DL_FRAME_PARMS *fp,
 }
 
 int nr_init_frame_parms(nfapi_nr_config_request_t* config,
-                        NR_DL_FRAME_PARMS *fp) {
+                        NR_DL_FRAME_PARMS *fp)
+{
+
 
   return nr_init_frame_parms0(fp,
 			      config->subframe_config.numerology_index_mu.value,

openair1/PHY/LTE_TRANSPORT/dlsch_coding.c

@@ -703,7 +703,7 @@ int dlsch_encoding_all(PHY_VARS_eNB *eNB,
 
 
 int dlsch_encoding(PHY_VARS_eNB *eNB,
-		   unsigned char *a,
+		unsigned char *a,
                    uint8_t num_pdcch_symbols,
                    LTE_eNB_DLSCH_t *dlsch,
                    int frame,

openair1/PHY/NR_TRANSPORT/nr_dci.c

@@ -41,11 +41,10 @@ extern short nr_mod_table[NR_MOD_TABLE_SIZE_SHORT];
 
 uint16_t nr_get_dci_size(nfapi_nr_dci_format_e format,
                         nfapi_nr_rnti_type_e rnti_type,
-                        NR_BWP_PARMS* bwp,
+                        uint16_t N_RB,
                         nfapi_nr_config_request_t* config)
 {
   uint16_t size = 0;
-  uint16_t N_RB = bwp->N_RB;
 
   switch(format) {
 /*Only sizes for 0_0 and 1_0 are correct at the moment*/
@@ -53,7 +52,7 @@ uint16_t nr_get_dci_size(nfapi_nr_dci_format_e format,
       /// fixed: Format identifier 1, Hop flag 1, MCS 5, NDI 1, RV 2, HARQ PID 4, PUSCH TPC 2 Time Domain assgnmt 4 --20
       size += 20;
       size += (uint8_t)ceil( log2( (N_RB*(N_RB+1))>>1 ) ); // Freq domain assignment -- hopping scenario to be updated
-      size += nr_get_dci_size(NFAPI_NR_DL_DCI_FORMAT_1_0, rnti_type, bwp, config) - size; // Padding to match 1_0 size
+      size += nr_get_dci_size(NFAPI_NR_DL_DCI_FORMAT_1_0, rnti_type, N_RB, config) - size; // Padding to match 1_0 size
       // UL/SUL indicator assumed to be 0
       break;
 
@@ -215,14 +214,15 @@ uint8_t nr_generate_dci_top(NR_gNB_PDCCH pdcch_vars,
   uint16_t Nid = (pdcch_params.search_space_type == NFAPI_NR_SEARCH_SPACE_TYPE_UE_SPECIFIC)? pdcch_params.scrambling_id : config.sch_config.physical_cell_id.value;
 #ifdef PDCCH_TEST_POLAR_TEMP_FIX
   t_nrPolar_paramsPtr currentPtr = NULL;//, polarParams = NULL;
-  nr_polar_init(&currentPtr, NR_POLAR_DCI_MESSAGE_TYPE, dci_alloc.size, dci_alloc.L);
+  //nr_polar_init(&currentPtr, NR_POLAR_DCI_MESSAGE_TYPE, dci_alloc.size, dci_alloc.L);
 //  t_nrPolar_paramsPtr currentPtr = nr_polar_params(*nrPolar_params, NR_POLAR_DCI_MESSAGE_TYPE, dci_alloc.size, dci_alloc.L);
 #else 
-  nr_polar_init(nrPolar_params, NR_POLAR_DCI_MESSAGE_TYPE, dci_alloc.size, dci_alloc.L);
+  //nr_polar_init(nrPolar_params, NR_POLAR_DCI_MESSAGE_TYPE, dci_alloc.size, dci_alloc.L);
   t_nrPolar_paramsPtr currentPtr = nr_polar_params(*nrPolar_params, NR_POLAR_DCI_MESSAGE_TYPE, dci_alloc.size, dci_alloc.L);
 #endif
 
-polar_encoder_dci(dci_alloc.dci_pdu, encoder_output, currentPtr, pdcch_params.rnti);
+  //polar_encoder_dci(dci_alloc.dci_pdu, encoder_output, currentPtr, pdcch_params.rnti);
+  //polar_encoder_fast(dci_alloc.dci_pdu, encoder_output, pdcch_params.rnti,currentPtr);
 
 #ifdef DEBUG_CHANNEL_CODING
   printf("polar rnti %d\n",pdcch_params.rnti);

openair1/PHY/NR_TRANSPORT/nr_dci.h

@@ -29,7 +29,7 @@ typedef unsigned __int128 uint128_t;
 
 uint16_t nr_get_dci_size(nfapi_nr_dci_format_e format,
                         nfapi_nr_rnti_type_e rnti_type,
-                        NR_BWP_PARMS* bwp,
+                        uint16_t N_RB,
                         nfapi_nr_config_request_t* config);
 
 uint8_t nr_generate_dci_top(NR_gNB_PDCCH pdcch_vars,

openair1/PHY/NR_TRANSPORT/nr_dci_tools.c

@@ -114,19 +114,29 @@ void nr_fill_dci_and_dlsch(PHY_VARS_gNB *gNB,
                            nfapi_nr_dl_config_dci_dl_pdu *pdcch_pdu,
                            nfapi_nr_dl_config_dlsch_pdu *dlsch_pdu)
 {
-	NR_DL_FRAME_PARMS *fp = &gNB->frame_parms;
+  NR_DL_FRAME_PARMS *fp = &gNB->frame_parms;
   uint8_t n_shift;
-	uint32_t *dci_pdu = dci_alloc->dci_pdu;
-  memset((void*)dci_pdu,0,4*sizeof(uint32_t));
-	nfapi_nr_dl_config_dci_dl_pdu_rel15_t *pdu_rel15 = &pdcch_pdu->dci_dl_pdu_rel15;
+  uint64_t *dci_pdu = dci_alloc->dci_pdu;
+  memset((void*)dci_pdu,0,2*sizeof(uint64_t));
+  nfapi_nr_dl_config_dci_dl_pdu_rel15_t *pdu_rel15 = &pdcch_pdu->dci_dl_pdu_rel15;
   nfapi_nr_dl_config_pdcch_parameters_rel15_t *params_rel15 = &pdcch_pdu->pdcch_params_rel15;
 	nfapi_nr_config_request_t *cfg = &gNB->gNB_config;
   NR_gNB_DLSCH_t *dlsch = gNB->dlsch[0][0];
   NR_DL_gNB_HARQ_t **harq = dlsch->harq_processes;
 
-  uint16_t N_RB = fp->initial_bwp_dl.N_RB;
-  uint16_t N_RB_UL = fp->initial_bwp_ul.N_RB;
-  uint8_t fsize=0, pos=0, pos2=0,cand_idx=0;
+  uint16_t N_RB = params_rel15->n_RB_BWP;
+  uint8_t fsize=0, pos=0, cand_idx=0;
+
+  dci_alloc->L = 8;
+  memcpy((void*)&dci_alloc->pdcch_params, (void*)params_rel15, sizeof(nfapi_nr_dl_config_pdcch_parameters_rel15_t));
+  dci_alloc->size = nr_get_dci_size(dci_alloc->pdcch_params.dci_format,
+                        dci_alloc->pdcch_params.rnti_type,
+                        N_RB,
+                        cfg);
+  AssertFatal(dci_alloc->size<=64, "DCI sizes above 64 bits not yet supported");
+  n_shift = (dci_alloc->pdcch_params.config_type == NFAPI_NR_CSET_CONFIG_MIB_SIB1)?
+                      cfg->sch_config.physical_cell_id.value : dci_alloc->pdcch_params.shift_index;
+  nr_fill_cce_list(dci_alloc, n_shift, cand_idx);
 
   /// Payload generation
   switch(params_rel15->dci_format) {
@@ -138,398 +148,263 @@ void nr_fill_dci_and_dlsch(PHY_VARS_gNB *gNB,
         	fsize = (int)ceil( log2( (N_RB*(N_RB+1))>>1 ) );
           printf("fsize = %d\n",fsize);
         	for (int i=0; i<fsize; i++)
-        		*dci_pdu |= ((pdu_rel15->frequency_domain_assignment>>(fsize-i-1))&1)<<pos++;
+        		*dci_pdu |= ((pdu_rel15->frequency_domain_assignment>>(fsize-i-1))&1)<<(63-pos++);
         	// Time domain assignment
         	for (int i=0; i<4; i++)
-        		*dci_pdu |= ((pdu_rel15->time_domain_assignment>>(3-i))&1)<<pos++;
+        		*dci_pdu |= ((pdu_rel15->time_domain_assignment>>(3-i))&1)<<(63-pos++);
         	// VRB to PRB mapping
-        	*dci_pdu |= (pdu_rel15->vrb_to_prb_mapping&1)<<pos++;
+        	*dci_pdu |= (pdu_rel15->vrb_to_prb_mapping&1)<<(63-pos++);
         	// MCS
         	for (int i=0; i<5; i++)
-        		*dci_pdu |= ((pdu_rel15->mcs>>(4-i))&1)<<pos++;
+        		*dci_pdu |= ((pdu_rel15->mcs>>(4-i))&1)<<(63-pos++);
         	// TB scaling
         	for (int i=0; i<2; i++)
-        		*dci_pdu |= ((pdu_rel15->tb_scaling>>(1-i))&1)<<pos++;
-
-          printf("***************************\n");
+        		*dci_pdu |= ((pdu_rel15->tb_scaling>>(1-i))&1)<<(63-pos++);
         	break;
 
-         case NFAPI_NR_RNTI_C:  
-      // indicating a DL DCI format 1bit
-        *dci_pdu |= (pdu_rel15->format_indicator&1)<<pos++;
-      // Freq domain assignment (275rb >> fsize = 16)
-        fsize = (int)ceil( log2( (N_RB*(N_RB+1))>>1 ) );
-        for (int i=0; i<fsize; i++) 
-            *dci_pdu |= ((pdu_rel15->frequency_domain_assignment>>(fsize-i-1))&1)<<pos++;
+        case NFAPI_NR_RNTI_C:  
+        // indicating a DL DCI format 1bit
+          *dci_pdu |= (pdu_rel15->format_indicator&1)<<(63-pos++);
+        // Freq domain assignment (275rb >> fsize = 16)
+          fsize = (int)ceil( log2( (N_RB*(N_RB+1))>>1 ) );
+          for (int i=0; i<fsize; i++) 
+            *dci_pdu |= ((pdu_rel15->frequency_domain_assignment>>(fsize-i-1))&1)<<(63-pos++);
 
-      if ((pdu_rel15->frequency_domain_assignment+1)&1 ==0) //fsize are all 1  38.212 p86
-      {
-          printf("***************************\n");
+          if ((pdu_rel15->frequency_domain_assignment+1)&1 ==0) //fsize are all 1  38.212 p86
+          {
+            // ra_preamble_index 6 bits
+            for (int i=0; i<6; i++)
+              *dci_pdu |= ((pdu_rel15->ra_preamble_index>>(5-i))&1)<<(63-pos++);
+
+            // UL/SUL indicator  1 bit
+              *dci_pdu |= (pdu_rel15->ul_sul_indicator&1)<<(63-pos++);
           
-          // ra_preamble_index 6bit
-          for (int i=0; i<6; i++)
-            *dci_pdu |= ((pdu_rel15->ra_preamble_index>>(5-i-1))&1)<<pos++;
-
-          // UL/SUL indicator  1bit
-            *dci_pdu |= (pdu_rel15->ul_sul_indicator&1)<<pos++;
+            // SS/PBCH index  6 bits
+            for (int i=0; i<6; i++)
+              *dci_pdu |= ((pdu_rel15->ss_pbch_index>>(5-i))&1)<<(63-pos++);
         
-          // SS/PBCH index  6bit
-          for (int i=0; i<6; i++)
-            *dci_pdu |= ((pdu_rel15->ss_pbch_index>>(5-i))&1)<<pos++;
-      
-      //  prach_mask_index  "2"+2bit // cause it 32bit and  bit over 32 ,so dci_pdu ++
-          for (int i=0; i<2; i++)
-            *dci_pdu |= ((pdu_rel15->prach_mask_index>>(3-i))&1)<<pos++;
-      
-      //--------------------------dci_pdu ++------------------------------
-      
-      //  prach_mask_index  2+"2"bit //
-          for (int i=2; i<4; i++)
-      {
-        if (pos>31)
-            *(dci_pdu+1) |= ((pdu_rel15->prach_mask_index>>(3-i))&1)<<pos2++;
-        else
-        *dci_pdu |= ((pdu_rel15->prach_mask_index>>(3-i))&1)<<pos++;
-      }
-      
-      
-      }  //end if
-      else 
-      
-      {
-      // Time domain assignment 4bit
-          for (int i=0; i<4; i++)
-            *dci_pdu |= ((pdu_rel15->time_domain_assignment>>(3-i))&1)<<pos++;
-      
-      // VRB to PRB mapping  1bit
-           *dci_pdu |= (pdu_rel15->vrb_to_prb_mapping&1)<<pos++;
-      
-      // MCS 5bit  //bit over 32, so dci_pdu ++
-          for (int i=0; i<5; i++)
-            *dci_pdu |= ((pdu_rel15->mcs>>(4-i))&1)<<pos++;
-    
-      // New data indicator 1bit
-        *dci_pdu |= (pdu_rel15->ndi&1)<<pos++;
-      
-      // Redundancy version  2bit
-          for (int i=0; i<2; i++)
-            *dci_pdu |= ((pdu_rel15->rv>>(1-i))&1)<<pos++;
-      
-      // HARQ process number  4bit  "2"+2
-          for (int i=0; i<2; i++)
-            *dci_pdu  |= ((pdu_rel15->harq_pid>>(3-i))&1)<<pos++;
-      
-      //--------------------------dci_pdu ++------------------------------
-      
-      // HARQ process number  4bit  2+"2"
-          for (int i=2; i<4; i++)
-      { 
-        if (pos>31)
-            *(dci_pdu+1)  |= ((pdu_rel15->harq_pid>>(3-i))&1)<<pos2++;
-        else 
-        *dci_pdu  |= ((pdu_rel15->harq_pid>>(3-i))&1)<<pos++;
-      }
-      
-      // Downlink assignment index  2bit
-      for (int i=0; i<2; i++)
-      { 
-        if (pos>31)
-            *(dci_pdu+1) |= ((pdu_rel15->dai>>(1-i))&1)<<pos2++;
-        else 
-        *dci_pdu |= ((pdu_rel15->dai>>(1-i))&1)<<pos++;
-      }
-      // TPC command for scheduled PUCCH  2bit
-      for (int i=0; i<2; i++)
-      { 
-        if (pos>31)
-            *(dci_pdu+1) |= ((pdu_rel15->tpc>>(1-i))&1)<<pos2++;
-        else 
-        *dci_pdu |= ((pdu_rel15->tpc>>(1-i))&1)<<pos++;  
-      }
-      // PUCCH resource indicator  3bit
-      for (int i=0; i<3; i++)
-      { 
-        if (pos>31)
-            *(dci_pdu+1) |= ((pdu_rel15->pucch_resource_indicator>>(2-i))&1)<<pos2++;
-        else
-        *dci_pdu |= ((pdu_rel15->pucch_resource_indicator>>(2-i))&1)<<pos++;      
-      }
-      // PDSCH-to-HARQ_feedback timing indicator 3bit
-      for (int i=0; i<3; i++)
-      {
-        if (pos>31)
-            *(dci_pdu+1) |= ((pdu_rel15->pdsch_to_harq_feedback_timing_indicator>>(2-i))&1)<<pos2++;
-        else
-        *dci_pdu |= ((pdu_rel15->pdsch_to_harq_feedback_timing_indicator>>(2-i))&1)<<pos++; 
-      }
-  
-      } //end else
+            //  prach_mask_index  4 bits
+            for (int i=0; i<4; i++)
+              *dci_pdu |= ((pdu_rel15->prach_mask_index>>(3-i))&1)<<(63-pos++);
+          
+          }  //end if
 
-      break;
+          else {
+
+          // Time domain assignment 4bit
+          for (int i=0; i<4; i++)
+            *dci_pdu |= ((pdu_rel15->time_domain_assignment>>(3-i))&1)<<(63-pos++);
+      
+          // VRB to PRB mapping  1bit
+          *dci_pdu |= (pdu_rel15->vrb_to_prb_mapping&1)<<(63-pos++);
+      
+          // MCS 5bit  //bit over 32, so dci_pdu ++
+          for (int i=0; i<5; i++)
+            *dci_pdu |= ((pdu_rel15->mcs>>(4-i))&1)<<(63-pos++);
+    
+          // New data indicator 1bit
+            *dci_pdu |= (pdu_rel15->ndi&1)<<(63-pos++);
+      
+          // Redundancy version  2bit
+          for (int i=0; i<2; i++)
+            *dci_pdu |= ((pdu_rel15->rv>>(1-i))&1)<<(63-pos++);
+      
+          // HARQ process number  4bit
+          for (int i=0; i<4; i++)
+            *dci_pdu  |= ((pdu_rel15->harq_pid>>(3-i))&1)<<(63-pos++);      
+ 
+          // Downlink assignment index  2bit
+          for (int i=0; i<2; i++)
+            *dci_pdu |= ((pdu_rel15->dai>>(1-i))&1)<<(63-pos++);
+
+          // TPC command for scheduled PUCCH  2bit
+          for (int i=0; i<2; i++)
+            *dci_pdu |= ((pdu_rel15->tpc>>(1-i))&1)<<(63-pos++);  
+
+          // PUCCH resource indicator  3bit
+          for (int i=0; i<3; i++)
+            *dci_pdu |= ((pdu_rel15->pucch_resource_indicator>>(2-i))&1)<<(63-pos++);      
+
+          // PDSCH-to-HARQ_feedback timing indicator 3bit
+          for (int i=0; i<3; i++)
+            *dci_pdu |= ((pdu_rel15->pdsch_to_harq_feedback_timing_indicator>>(2-i))&1)<<(63-pos++); 
+
+          } //end else
+          break;
 
       case NFAPI_NR_RNTI_P:
       
-      // Short Messages Indicator – 2 bits
-          for (int i=0; i<2; i++)
-            *dci_pdu |= ((pdu_rel15->short_messages_indicator>>(1-i))&1)<<pos++;
-      // Short Messages – 8 bits
-          for (int i=0; i<8; i++)
-            *dci_pdu |= ((pdu_rel15->short_messages>>(7-i))&1)<<pos++;
-      // Freq domain assignment 0-16 bit
+        // Short Messages Indicator – 2 bits
+        for (int i=0; i<2; i++)
+          *dci_pdu |= ((pdu_rel15->short_messages_indicator>>(1-i))&1)<<(63-pos++);
+        // Short Messages – 8 bits
+        for (int i=0; i<8; i++)
+          *dci_pdu |= ((pdu_rel15->short_messages>>(7-i))&1)<<(63-pos++);
+        // Freq domain assignment 0-16 bit
         fsize = (int)ceil( log2( (N_RB*(N_RB+1))>>1 ) );
           for (int i=0; i<fsize; i++)
-            *dci_pdu |= ((pdu_rel15->frequency_domain_assignment>>(fsize-i-1))&1)<<pos++;
-          // Time domain assignment 4 bit
-          for (int i=0; i<4; i++)
-            *dci_pdu |= ((pdu_rel15->time_domain_assignment>>(3-i))&1)<<pos++;
-          // VRB to PRB mapping 1 bit
-        *dci_pdu |= (pdu_rel15->vrb_to_prb_mapping&1)<<pos++;
-          // MCS "1"+4 = 5 bit
-          for (int i=0; i<1; i++) 
-            *dci_pdu |= ((pdu_rel15->mcs>>(4-i))&1)<<pos++;
-      // MCS 1+"4" = 5 bit
+            *dci_pdu |= ((pdu_rel15->frequency_domain_assignment>>(fsize-i-1))&1)<<(63-pos++);
+        // Time domain assignment 4 bit
+        for (int i=0; i<4; i++)
+          *dci_pdu |= ((pdu_rel15->time_domain_assignment>>(3-i))&1)<<(63-pos++);
+        // VRB to PRB mapping 1 bit
+        *dci_pdu |= (pdu_rel15->vrb_to_prb_mapping&1)<<(63-pos++);
+        // MCS 5 bit
+        for (int i=0; i<5; i++) 
+          *dci_pdu |= ((pdu_rel15->mcs>>(4-i))&1)<<(63-pos++);
       
-          for (int i=1; i<4; i++) 
-      {
-        if (pos>31)
-            *(dci_pdu+1) |= ((pdu_rel15->mcs>>(4-i))&1)<<pos2++;
-        else
-        *dci_pdu |= ((pdu_rel15->mcs>>(4-i))&1)<<pos++;
-      }
-          // TB scaling 2 bit
-          for (int i=0; i<2; i++)
-      { 
-        if (pos>31)
-            *(dci_pdu+1) |= ((pdu_rel15->tb_scaling>>(1-i))&1)<<pos2++;
-        else
-        *dci_pdu |= ((pdu_rel15->tb_scaling>>(1-i))&1)<<pos++;
-      }
+        // TB scaling 2 bit
+        for (int i=0; i<2; i++)
+          *dci_pdu |= ((pdu_rel15->tb_scaling>>(1-i))&1)<<(63-pos++);
+
       break;
       
       case NFAPI_NR_RNTI_SI:
-      // Freq domain assignment 0-16 bit
+        // Freq domain assignment 0-16 bit
         fsize = (int)ceil( log2( (N_RB*(N_RB+1))>>1 ) );
-          for (int i=0; i<fsize; i++)
-            *dci_pdu |= ((pdu_rel15->frequency_domain_assignment>>(fsize-i-1))&1)<<pos++;
-          // Time domain assignment 4 bit
-          for (int i=0; i<4; i++)
-            *dci_pdu |= ((pdu_rel15->time_domain_assignment>>(3-i))&1)<<pos++;
+        for (int i=0; i<fsize; i++)
+          *dci_pdu |= ((pdu_rel15->frequency_domain_assignment>>(fsize-i-1))&1)<<(63-pos++);
+        // Time domain assignment 4 bit
+        for (int i=0; i<4; i++)
+          *dci_pdu |= ((pdu_rel15->time_domain_assignment>>(3-i))&1)<<(63-pos++);
           // VRB to PRB mapping 1 bit
-        *dci_pdu |= (pdu_rel15->vrb_to_prb_mapping&1)<<pos++;
-      // MCS 5bit  //bit over 32, so dci_pdu ++
-          for (int i=0; i<5; i++)
-            *dci_pdu |= ((pdu_rel15->mcs>>(4-i))&1)<<pos++;
-      // Redundancy version  2bit
-          for (int i=0; i<2; i++)
-            *dci_pdu |= ((pdu_rel15->rv>>(1-i))&1)<<pos++;
+        *dci_pdu |= (pdu_rel15->vrb_to_prb_mapping&1)<<(63-pos++);
+        // MCS 5bit  //bit over 32, so dci_pdu ++
+        for (int i=0; i<5; i++)
+          *dci_pdu |= ((pdu_rel15->mcs>>(4-i))&1)<<(63-pos++);
+        // Redundancy version  2bit
+        for (int i=0; i<2; i++)
+          *dci_pdu |= ((pdu_rel15->rv>>(1-i))&1)<<(63-pos++);
       
       break;
       
       case NFAPI_NR_RNTI_TC:
       // indicating a DL DCI format 1bit
-        *dci_pdu |= (pdu_rel15->format_indicator&1)<<pos++;
+        *dci_pdu |= (pdu_rel15->format_indicator&1)<<(63-pos++);
       // Freq domain assignment 0-16 bit
-          fsize = (int)ceil( log2( (N_RB*(N_RB+1))>>1 ) );
-          for (int i=0; i<fsize; i++)
-            *dci_pdu |= ((pdu_rel15->frequency_domain_assignment>>(fsize-i-1))&1)<<pos++;
+        fsize = (int)ceil( log2( (N_RB*(N_RB+1))>>1 ) );
+        for (int i=0; i<fsize; i++)
+          *dci_pdu |= ((pdu_rel15->frequency_domain_assignment>>(fsize-i-1))&1)<<(63-pos++);
       // Time domain assignment 4 bit
-          for (int i=0; i<4; i++)
-            *dci_pdu |= ((pdu_rel15->time_domain_assignment>>(3-i))&1)<<pos++;
+        for (int i=0; i<4; i++)
+          *dci_pdu |= ((pdu_rel15->time_domain_assignment>>(3-i))&1)<<(63-pos++);
       // VRB to PRB mapping 1 bit
-        *dci_pdu |= (pdu_rel15->vrb_to_prb_mapping&1)<<pos++;
+        *dci_pdu |= (pdu_rel15->vrb_to_prb_mapping&1)<<(63-pos++);
       // MCS 5bit  //bit over 32, so dci_pdu ++
-          for (int i=0; i<5; i++)
-            *dci_pdu |= ((pdu_rel15->mcs>>(4-i))&1)<<pos++;
+        for (int i=0; i<5; i++)
+          *dci_pdu |= ((pdu_rel15->mcs>>(4-i))&1)<<(63-pos++);
       // New data indicator 1bit
-        *dci_pdu |= (pdu_rel15->ndi&1)<<pos++;
+        *dci_pdu |= (pdu_rel15->ndi&1)<<(63-pos++);
       // Redundancy version  2bit
-          for (int i=0; i<2; i++)
-            *dci_pdu |= ((pdu_rel15->rv>>(1-i))&1)<<pos++;
+        for (int i=0; i<2; i++)
+          *dci_pdu |= ((pdu_rel15->rv>>(1-i))&1)<<(63-pos++);
       // HARQ process number  4bit  
-          for (int i=0; i<2; i++)
-            *dci_pdu  |= ((pdu_rel15->harq_pid>>(3-i))&1)<<pos++; 
+        for (int i=0; i<4; i++)
+          *dci_pdu  |= ((pdu_rel15->harq_pid>>(3-i))&1)<<(63-pos++); 
       
-      // HARQ process number  4bit  
-          for (int i=2; i<4; i++)
-      { 
-        if (pos>31)
-            *(dci_pdu+1)  |= ((pdu_rel15->harq_pid>>(3-i))&1)<<pos2++;  
-        else
-        *dci_pdu  |= ((pdu_rel15->harq_pid>>(3-i))&1)<<pos++; 
-      } 
-        
       // Downlink assignment index – 2 bits 
-          for (int i=0; i<2; i++)
-      { 
-        if (pos>31)
-            *(dci_pdu+1)  |= ((pdu_rel15->dai>>(1-i))&1)<<pos2++;
-        else
-        *dci_pdu  |= ((pdu_rel15->dai>>(1-i))&1)<<pos++;
-      }     
+        for (int i=0; i<2; i++)
+           *dci_pdu  |= ((pdu_rel15->dai>>(1-i))&1)<<(63-pos++);
+    
       // TPC command for scheduled PUCCH – 2 bits
-          for (int i=0; i<2; i++)
-      { 
-        if (pos>31)
-            *(dci_pdu+1)  |= ((pdu_rel15->tpc>>(1-i))&1)<<pos2++; 
-        else
-        *dci_pdu  |= ((pdu_rel15->tpc>>(1-i))&1)<<pos++;    
-      } 
+        for (int i=0; i<2; i++)
+          *dci_pdu  |= ((pdu_rel15->tpc>>(1-i))&1)<<(63-pos++);    
+
       // PUCCH resource indicator – 3 bits 
-          for (int i=0; i<3; i++)
-      { 
-        if (pos>31)
-            *(dci_pdu+1)  |= ((pdu_rel15->pucch_resource_indicator>>(2-i))&1)<<pos2++;
-        else
-        *dci_pdu  |= ((pdu_rel15->pucch_resource_indicator>>(2-i))&1)<<pos++; 
-      }
+        for (int i=0; i<3; i++)
+          *dci_pdu  |= ((pdu_rel15->pucch_resource_indicator>>(2-i))&1)<<(63-pos++); 
+
       // PDSCH-to-HARQ_feedback timing indicator – 3 bits
-          for (int i=0; i<3; i++)
-      {
-        if (pos>31)
-            *(dci_pdu+1)  |= ((pdu_rel15->pdsch_to_harq_feedback_timing_indicator>>(2-i))&1)<<pos2++; 
-        else
-        *dci_pdu  |= ((pdu_rel15->pdsch_to_harq_feedback_timing_indicator>>(2-i))&1)<<pos++;      
-      }
+        for (int i=0; i<3; i++)
+          *dci_pdu  |= ((pdu_rel15->pdsch_to_harq_feedback_timing_indicator>>(2-i))&1)<<(63-pos++);
       
-      ///-----------------------------------?????????????????????------------------------
       break;
       }
-      break;
 
     case NFAPI_NR_UL_DCI_FORMAT_0_0:
-    switch(params_rel15->rnti_type) 
+    switch(params_rel15->rnti_type)
     {
       case NFAPI_NR_RNTI_C:
       // indicating a DL DCI format 1bit
-         *dci_pdu |= (pdu_rel15->format_indicator&1)<<pos++;
+         *dci_pdu |= (pdu_rel15->format_indicator&1)<<(63-pos++);
           // Freq domain assignment  max 16 bit
-          fsize = (int)ceil( log2( (N_RB_UL*(N_RB_UL+1))>>1 ) );
+          fsize = (int)ceil( log2( (N_RB*(N_RB+1))>>1 ) );
           for (int i=0; i<fsize; i++)
-            *dci_pdu |= ((pdu_rel15->frequency_domain_assignment>>(fsize-i-1))&1)<<pos++;
+            *dci_pdu |= ((pdu_rel15->frequency_domain_assignment>>(fsize-i-1))&1)<<(63-pos++);
           // Time domain assignment 4bit
           for (int i=0; i<4; i++)
-            *dci_pdu |= ((pdu_rel15->time_domain_assignment>>(3-i))&1)<<pos++;
+            *dci_pdu |= ((pdu_rel15->time_domain_assignment>>(3-i))&1)<<(63-pos++);
       // Frequency hopping flag – 1 bit
-         *dci_pdu |= (pdu_rel15->frequency_hopping_flag&1)<<pos++;
+         *dci_pdu |= (pdu_rel15->frequency_hopping_flag&1)<<(63-pos++);
           // MCS  5 bit
           for (int i=0; i<5; i++)
-          *dci_pdu |= ((pdu_rel15->mcs>>(4-i))&1)<<pos++;
+          *dci_pdu |= ((pdu_rel15->mcs>>(4-i))&1)<<(63-pos++);
       // New data indicator 1bit
-         *dci_pdu |= (pdu_rel15->ndi&1)<<pos++;
+         *dci_pdu |= (pdu_rel15->ndi&1)<<(63-pos++);
       // Redundancy version  2bit
           for (int i=0; i<2; i++)
-         *dci_pdu |= ((pdu_rel15->rv>>(1-i))&1)<<pos++;
+         *dci_pdu |= ((pdu_rel15->rv>>(1-i))&1)<<(63-pos++);
       // HARQ process number  4bit  
-          for (int i=0; i<2; i++)
-         *dci_pdu  |= ((pdu_rel15->harq_pid>>(3-i))&1)<<pos++;
+          for (int i=0; i<4; i++)
+         *dci_pdu  |= ((pdu_rel15->harq_pid>>(3-i))&1)<<(63-pos++);
       
-      // HARQ process number  4bit  
-          for (int i=2; i<4; i++)
-      {
-        if (pos>31)
-            *(dci_pdu+1)  |= ((pdu_rel15->harq_pid>>(3-i))&1)<<pos2++;
-        else 
-        *dci_pdu  |= ((pdu_rel15->harq_pid>>(3-i))&1)<<pos++;
-      }
       // TPC command for scheduled PUSCH – 2 bits
         for (int i=0; i<2; i++)
-        {
-        if (pos>31)
-            *(dci_pdu+1) |= ((pdu_rel15->tpc>>(1-i))&1)<<pos2++;  
-        else
-        *dci_pdu |= ((pdu_rel15->tpc>>(1-i))&1)<<pos++;
-        }
+          *dci_pdu |= ((pdu_rel15->tpc>>(1-i))&1)<<(63-pos++);
+
       // Padding bits
-        if (pos<32)
-        {
         for(int a = pos;a<32;a++)
-          *dci_pdu |= (pdu_rel15->padding&1)<<pos++;
-        }
+          *dci_pdu |= (pdu_rel15->padding&1)<<(63-pos++);
+
       // UL/SUL indicator – 1 bit
         if (cfg->pucch_config.pucch_GroupHopping.value)
-        { 
-        if (pos>31) 
-        *(dci_pdu+1) |= (pdu_rel15->ul_sul_indicator&1)<<pos2++;  
-        else
-        *dci_pdu |= (pdu_rel15->ul_sul_indicator&1)<<pos++; 
-        }
+          *dci_pdu |= (pdu_rel15->ul_sul_indicator&1)<<(63-pos++); 
    
           break;
       
       case NFAPI_NR_RNTI_TC:
       
           // indicating a DL DCI format 1bit
-          *dci_pdu |= (pdu_rel15->format_indicator&1)<<pos++;
+          *dci_pdu |= (pdu_rel15->format_indicator&1)<<(63-pos++);
           // Freq domain assignment  max 16 bit
-          fsize = (int)ceil( log2( (N_RB_UL*(N_RB_UL+1))>>1 ) );
+          fsize = (int)ceil( log2( (N_RB*(N_RB+1))>>1 ) );
           for (int i=0; i<fsize; i++)
-            *dci_pdu |= ((pdu_rel15->frequency_domain_assignment>>(fsize-i-1))&1)<<pos++;
+            *dci_pdu |= ((pdu_rel15->frequency_domain_assignment>>(fsize-i-1))&1)<<(63-pos++);
           // Time domain assignment 4bit
           for (int i=0; i<4; i++)
-            *dci_pdu |= ((pdu_rel15->time_domain_assignment>>(3-i))&1)<<pos++;
+            *dci_pdu |= ((pdu_rel15->time_domain_assignment>>(3-i))&1)<<(63-pos++);
          // Frequency hopping flag – 1 bit
-          *dci_pdu |= (pdu_rel15->frequency_hopping_flag&1)<<pos++;
+          *dci_pdu |= (pdu_rel15->frequency_hopping_flag&1)<<(63-pos++);
           // MCS  5 bit
           for (int i=0; i<5; i++)
-          *dci_pdu |= ((pdu_rel15->mcs>>(4-i))&1)<<pos++;
+          *dci_pdu |= ((pdu_rel15->mcs>>(4-i))&1)<<(63-pos++);
           // New data indicator 1bit
-         *dci_pdu |= (pdu_rel15->ndi&1)<<pos++;
+         *dci_pdu |= (pdu_rel15->ndi&1)<<(63-pos++);
           // Redundancy version  2bit
           for (int i=0; i<2; i++)
-          *dci_pdu |= ((pdu_rel15->rv>>(1-i))&1)<<pos++;
+          *dci_pdu |= ((pdu_rel15->rv>>(1-i))&1)<<(63-pos++);
           // HARQ process number  4bit  
-          for (int i=0; i<2; i++)
-          *dci_pdu  |= ((pdu_rel15->harq_pid>>(3-i))&1)<<pos++;
-      
-        // HARQ process number  4bit  
-        for (int i=2; i<4; i++)
-        {
-        if (pos>31)
-        *(dci_pdu+1)  |= ((pdu_rel15->harq_pid>>(3-i))&1)<<pos2++;
-        else 
-        *dci_pdu  |= ((pdu_rel15->harq_pid>>(3-i))&1)<<pos++;
-        }
+          for (int i=0; i<4; i++)
+          *dci_pdu  |= ((pdu_rel15->harq_pid>>(3-i))&1)<<(63-pos++);
+
         // TPC command for scheduled PUSCH – 2 bits
         for (int i=0; i<2; i++)
-        {
-        if (pos>31)
-        *(dci_pdu+1) |= ((pdu_rel15->tpc>>(1-i))&1)<<pos2++;  
-        else
-        *dci_pdu |= ((pdu_rel15->tpc>>(1-i))&1)<<pos++;
-        }
+          *dci_pdu |= ((pdu_rel15->tpc>>(1-i))&1)<<(63-pos++);
+
         // Padding bits
-        if (pos<32)
-        {
         for(int a = pos;a<32;a++)
-        *dci_pdu |= (pdu_rel15->padding&1)<<pos++;
-        }
+        *dci_pdu |= (pdu_rel15->padding&1)<<(63-pos++);
+
         // UL/SUL indicator – 1 bit
         if (cfg->pucch_config.pucch_GroupHopping.value)
-        { 
-        if (pos>31) 
-        *(dci_pdu+1) |= (pdu_rel15->ul_sul_indicator&1)<<pos2++;  
-        else
-        *dci_pdu |= (pdu_rel15->ul_sul_indicator&1)<<pos++; 
-        } 
+        *dci_pdu |= (pdu_rel15->ul_sul_indicator&1)<<(63-pos++); 
+
         break;
       } 
       break;
   }
 
-
-  LOG_I(PHY, "DCI PDU: [0]->0x%08x \t [1]->0x%08x \t [2]->0x%08x \t [3]->0x%08x\n",
-              dci_pdu[0], dci_pdu[1], dci_pdu[2], dci_pdu[3]);
-
-  /// rest of DCI alloc
-  dci_alloc->L = 8;
-  memcpy((void*)&dci_alloc->pdcch_params, (void*)params_rel15, sizeof(nfapi_nr_dl_config_pdcch_parameters_rel15_t));
-  dci_alloc->size = nr_get_dci_size(dci_alloc->pdcch_params.dci_format,
-                        dci_alloc->pdcch_params.rnti_type,
-                        &fp->initial_bwp_dl,
-                        cfg);
-  n_shift = (dci_alloc->pdcch_params.config_type == NFAPI_NR_CSET_CONFIG_MIB_SIB1)?
-                      cfg->sch_config.physical_cell_id.value : dci_alloc->pdcch_params.shift_index;
-  nr_fill_cce_list(dci_alloc, n_shift, cand_idx);
+  LOG_I(PHY, "DCI PDU: [0]->0x%16x \t [1]->0x%16x \n",dci_pdu[0], dci_pdu[1]);
   LOG_I(PHY, "DCI type %d payload (size %d) generated on candidate %d\n", dci_alloc->pdcch_params.dci_format, dci_alloc->size, cand_idx);
 
   /// DLSCH struct

openair1/PHY/NR_TRANSPORT/nr_dlsch.c

@@ -211,16 +211,21 @@ uint8_t nr_generate_pdsch(NR_gNB_DLSCH_t dlsch,
   uint16_t nb_symbols = rel15->nb_mod_symbols;
   uint8_t Qm = rel15->modulation_order;
   uint16_t encoded_length = nb_symbols*Qm;
+  static uint8_t print=1;
 
   /// CRC, coding, interleaving and rate matching
   nr_dlsch_encoding(harq->pdu, subframe, &dlsch, &frame_parms);
+  //#ifdef DEBUG_DLSCH
+  if (print) {
+    print = 0;
+    printf("PDSCH encoding:\nPayload:\n");
+    for (int i=0; i<TBS>>7; i++) {
+      for (int j=0; j<16; j++)
+	printf("0x%02x\t", harq->pdu[(i<<4)+j]);
+      printf("\n");
+    }
+  }
 #ifdef DEBUG_DLSCH
-printf("PDSCH encoding:\nPayload:\n");
-for (int i=0; i<TBS>>7; i++) {
-  for (int j=0; j<16; j++)
-    printf("0x%02x\t", harq->pdu[(i<<4)+j]);
-  printf("\n");
-}
 printf("\nEncoded payload:\n");
 for (int i=0; i<encoded_length>>3; i++) {
   for (int j=0; j<8; j++)

openair1/PHY/NR_TRANSPORT/nr_pbch.c

@@ -226,6 +226,7 @@ void nr_init_pbch_interleaver(uint8_t *interleaver) {
       *(interleaver+i) = *(nr_pbch_payload_interleaving_pattern+j_hrf);
     else // Ssb bits:3
       *(interleaver+i) = *(nr_pbch_payload_interleaving_pattern+j_ssb++);
+
 }
 
 int nr_generate_pbch(NR_gNB_PBCH *pbch,
@@ -250,6 +251,7 @@ int nr_generate_pbch(NR_gNB_PBCH *pbch,
   uint16_t M;
   uint8_t nushift;
   uint32_t unscrambling_mask;
+  uint64_t a_reversed=0;
 
   LOG_I(PHY, "PBCH generation started\n");
 
@@ -304,8 +306,14 @@ int nr_generate_pbch(NR_gNB_PBCH *pbch,
   printf("pbch_a_prime: 0x%08x\n", pbch->pbch_a_prime);
 #endif
 
+
+  // Encoder reversal
+  for (int i=0; i<NR_POLAR_PBCH_PAYLOAD_BITS; i++)
+    a_reversed |= (((uint64_t)pbch->pbch_a_prime>>i)&1)<<(31-i);
+
+
   /// CRC, coding and rate matching
-  polar_encoder (&pbch->pbch_a_prime, pbch->pbch_e, polar_params);
+  polar_encoder_fast (&a_reversed, (uint32_t*)pbch->pbch_e, 0, polar_params);
 #ifdef DEBUG_PBCH_ENCODING
   printf("Channel coding:\n");
   for (int i=0; i<NR_POLAR_PBCH_E_DWORD; i++)

openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_decoding.c

@@ -537,13 +537,13 @@ uint32_t  nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
 		      				harq_process->c[r][m]= (uint8_t) llrProcBuf[m];
 		      	      	}
 
-#ifdef DEBUG_DLSCH_DECODING
+		//#ifdef DEBUG_DLSCH_DECODING
       //printf("output 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]);
       for (int k=0;k<32;k++)
-       printf("output decoder [%d] =  0x%02x \n", k, harq_process->c[r][k]);
-      printf("no_iterations_ldpc %d (ret %d)\n",no_iteration_ldpc,ret);
+	LOG_I(PHY,"output decoder [%d] =  0x%02x \n", k, harq_process->c[r][k]);
+      LOG_I(PHY,"no_iterations_ldpc %d (ret %d)\n",no_iteration_ldpc,ret);
       //write_output("dec_output.m","dec0",harq_process->c[0],Kr_bytes,1,4);
-#endif
+      //#endif
 
 
 #if UE_TIMING_TRACE

openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_demodulation.c

@@ -160,7 +160,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
   //set active for testing -> to be removed
   dlsch[0]->harq_processes[harq_pid]->status = ACTIVE;
   dlsch[0]->harq_processes[harq_pid]->Qm = 2;
-  dlsch[0]->harq_processes[harq_pid]->mcs = 9;
+  dlsch[0]->harq_processes[harq_pid]->mcs = 8;
   dlsch[0]->harq_processes[harq_pid]->Nl=1;
   dlsch[0]->harq_processes[harq_pid]->nb_rb = nb_rb_pdsch;
   frame_parms->nushift = 0;

openair1/PHY/NR_UE_TRANSPORT/nr_pbch.c

@@ -497,7 +497,7 @@ void nr_pbch_quantize(int16_t *pbch_llr8,
     if (pbch_llr[i]>31)
       pbch_llr8[i]=32;
     else if (pbch_llr[i]<-31)
-      pbch_llr8[i]=-32;
+      pbch_llr8[i]=-31;
     else
       pbch_llr8[i] = (char)(pbch_llr[i]);
 
@@ -655,16 +655,20 @@ int nr_rx_pbch( PHY_VARS_NR_UE *ue,
 
   //polar decoding de-rate matching
 
+  nr_ue_pbch_vars->nrPolar_params = NULL;
+  nr_polar_init(&nr_ue_pbch_vars->nrPolar_params,
+		NR_POLAR_PBCH_MESSAGE_TYPE,
+		NR_POLAR_PBCH_PAYLOAD_BITS,
+		NR_POLAR_PBCH_AGGREGATION_LEVEL);
 
-  AssertFatal(ue->nrPolar_params != NULL,"ue->nrPolar_params is null\n");
+  AssertFatal(nr_ue_pbch_vars->nrPolar_params != NULL,"nr_ue_pbch_vars->nrPolar_params is null\n");
 
-  t_nrPolar_params *currentPtr = nr_polar_params(ue->nrPolar_params, NR_POLAR_PBCH_MESSAGE_TYPE, NR_POLAR_PBCH_PAYLOAD_BITS, NR_POLAR_PBCH_AGGREGATION_LEVEL);
+  t_nrPolar_params *currentPtr = nr_polar_params(nr_ue_pbch_vars->nrPolar_params, NR_POLAR_PBCH_MESSAGE_TYPE, NR_POLAR_PBCH_PAYLOAD_BITS, NR_POLAR_PBCH_AGGREGATION_LEVEL);
 
   decoderState = polar_decoder_int16(pbch_e_rx,(uint8_t*)&nr_ue_pbch_vars->pbch_a_prime,currentPtr);
 
 
-  if(decoderState == -1)
-  	return(decoderState);
+  if(decoderState > 0)	return(decoderState);
   	
   	printf("polar decoder output 0x%08x\n",nr_ue_pbch_vars->pbch_a_prime);
   

openair1/PHY/TOOLS/nr_phy_scope.c

@@ -732,6 +732,7 @@ void phy_scope_UE(FD_lte_phy_scope_ue *form,
     }
 
     fl_set_xyplot_data(form->pbch_llr,bit_pbch,llr_pbch,864,"","","");
+    fl_set_xyplot_ybounds(form->pbch_llr,-32,32);
   }
 
   if (phy_vars_ue->is_synchronized==1)

openair1/PHY/defs_gNB.h

@@ -60,7 +60,7 @@ typedef struct {
   /// CCE list
   nr_cce_t cce_list[NR_MAX_PDCCH_AGG_LEVEL];
   /// DCI pdu
-  uint32_t dci_pdu[4];
+  uint64_t dci_pdu[2];
 } NR_gNB_DCI_ALLOC_t;
 
 typedef struct {
@@ -383,7 +383,6 @@ typedef struct PHY_VARS_gNB_s {
   NR_gNB_PDCCH        pdcch_vars;
   NR_gNB_PBCH         pbch;
   t_nrPolar_paramsPtr nrPolar_params;
-  nfapi_nr_dl_config_pdcch_parameters_rel15_t pdcch_type0_params;
   LTE_eNB_PHICH       phich_vars[2];
 
   NR_gNB_COMMON       common_vars;

openair1/PHY/defs_nr_UE.h

@@ -892,6 +892,7 @@ typedef struct {
   //Check for specific DCIFormat and AgregationLevel
   uint8_t dciFormat;
   uint8_t agregationLevel;
+  t_nrPolar_paramsPtr nrPolar_params;
   #ifdef NR_PDCCH_DEFS_NR_UE
   int nb_searchSpaces;
   // CORESET structure, where maximum number of CORESETs to be handled is 3 (according to 38.331 V15.1.0)
@@ -900,6 +901,7 @@ typedef struct {
   // Each SearchSpace is associated with one ControlResourceSet 
   NR_UE_PDCCH_SEARCHSPACE searchSpace[NR_NBR_SEARCHSPACE_ACT_BWP];
 
+  int n_RB_BWP[NR_NBR_SEARCHSPACE_ACT_BWP];
   uint32_t nb_search_space;
   #endif
 } NR_UE_PDCCH;
@@ -931,6 +933,8 @@ typedef struct {
   /// \brief Pointer to PBCH decoded output.
   /// - first index: ? [0..63] (hard coded)
   uint8_t *decoded_output;
+  /// polar decoder parameters
+  t_nrPolar_paramsPtr nrPolar_params;
   /// \brief Total number of PDU errors.
   uint32_t pdu_errors;
   /// \brief Total number of PDU errors 128 frames ago.
@@ -1017,7 +1021,12 @@ typedef struct {
   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;
+
+  /// UE FAPI indication for DLSCH reception
   fapi_nr_rx_indication_t rx_ind;
+  /// UE FAPI indication for DCI reception
   fapi_nr_dci_indication_t dci_ind;
 
   // point to the current rxTx thread index
@@ -1061,7 +1070,7 @@ typedef struct {
   uint32_t dmrs_pbch_bitmap_nr[DMRS_PBCH_I_SSB][DMRS_PBCH_N_HF][DMRS_BITMAP_SIZE];
 
 #endif
-  t_nrPolar_params  *nrPolar_params;
+
 
   /// PBCH DMRS sequence
   uint32_t nr_gold_pbch[2][64][NR_PBCH_DMRS_LENGTH_DWORD];

openair1/SCHED_NR/fapi_nr_l1.c

@@ -109,7 +109,8 @@ void nr_schedule_response(NR_Sched_Rsp_t *Sched_INFO){
 
   for (i=0;i<number_dl_pdu;i++) {
     dl_config_pdu = &DL_req->dl_config_request_body.dl_config_pdu_list[i];
-    //LOG_D(PHY,"NFAPI: dl_pdu %d : type %d\n",i,dl_config_pdu->pdu_type);
+    LOG_D(PHY,"NFAPI: dl_pdu %d : type %d\n",i,dl_config_pdu->pdu_type);
+    printf("NFAPI: dl_pdu %d : type %d\n",i,dl_config_pdu->pdu_type);
     switch (dl_config_pdu->pdu_type) {
       case NFAPI_NR_DL_CONFIG_BCH_PDU_TYPE:
         AssertFatal(dl_config_pdu->bch_pdu_rel15.pdu_index < TX_req->tx_request_body.number_of_pdus,

openair1/SCHED_NR/phy_procedures_nr_common.c

@@ -33,23 +33,6 @@
 #include "sched_nr.h"
 
 
-/// LUT for the number of symbols in the coreset indexed by coreset index (4 MSB rmsi_pdcch_config)
-uint8_t nr_coreset_nsymb_pdcch_type_0_b40Mhz[16] = {2,2,2,2,2,3,3,3,3,3,1,1,1,2,2,2}; // below 40Mhz bw
-uint8_t nr_coreset_nsymb_pdcch_type_0_a40Mhz[10] = {2,2,3,3,1,1,2,2,3,3}; // above 40Mhz bw
-/// LUT for the number of RBs in the coreset indexed by coreset index
-uint8_t nr_coreset_rb_offset_pdcch_type_0_b40Mhz[16] = {0,1,2,3,4,0,1,2,3,4,12,14,16,12,14,16};
-uint8_t nr_coreset_rb_offset_pdcch_type_0_a40Mhz[10] = {0,4,0,4,0,28,0,28,0,28};
-/// LUT for monitoring occasions param O indexed by ss index (4 LSB rmsi_pdcch_config)
-uint8_t nr_ss_param_O_type_0_mux1_FR1[16] = {0,0,2,2,5,5,7,7,0,5,0,0,2,2,5,5};
-uint8_t nr_ss_param_O_type_0_mux1_FR2[14] = {0,0,2.5,2.5,5,5,0,2.5,5,7.5,7.5,7.5,0,5};
-/// LUT for number of SS sets per slot indexed by ss index
-uint8_t nr_ss_sets_per_slot_type_0_FR1[16] = {1,2,1,2,1,2,1,2,1,1,1,1,1,1,1,1};
-uint8_t nr_ss_sets_per_slot_type_0_FR2[14] = {1,2,1,2,1,2,2,2,2,1,2,2,1,1};
-/// LUT for monitoring occasions param M indexed by ss index
-uint8_t nr_ss_param_M_type_0_mux1_FR1[16] = {1,0.5,1,0.5,1,0.5,1,0.5,2,2,1,1,1,1,1,1};
-uint8_t nr_ss_param_M_type_0_mux1_FR2[14] = {1,0.5,1,0.5,1,0.5,0.5,0.5,0.5,1,0.5,0.5,2,2};
-/// LUT for SS first symbol index indexed by ss index
-uint8_t nr_ss_first_symb_idx_type_0_mux1_FR1[8] = {0,0,1,2,1,2,1,2};
 
 
 
@@ -60,123 +43,4 @@ nr_subframe_t nr_subframe_select(nfapi_nr_config_request_t *cfg,unsigned char su
 }
 
 
-void nr_configure_css_dci_from_mib(nfapi_nr_dl_config_pdcch_parameters_rel15_t* pdcch_params,
-                               nr_scs_e scs_common,
-                               nr_scs_e pdcch_scs,
-                               nr_frequency_range_e freq_range,
-                               uint8_t rmsi_pdcch_config,
-                               uint8_t ssb_idx,
-                               uint16_t nb_slots_per_frame,
-                               uint16_t N_RB)
-{
-  uint8_t O, M;
-  uint8_t ss_idx = rmsi_pdcch_config&0xf;
-  uint8_t cset_idx = (rmsi_pdcch_config>>4)&0xf;
-  uint8_t mu;
 
-  /// Coreset params
-  switch(scs_common) {
-
-    case kHz15:
-      mu = 0;
-      break;
-
-    case kHz30:
-      mu = 1;
-
-      if (N_RB < 106) { // Minimum 40Mhz bandwidth not satisfied
-        switch(pdcch_scs) {
-          case kHz15:
-            break;
-
-          case kHz30:
-            pdcch_params->mux_pattern = NFAPI_NR_SSB_AND_CSET_MUX_PATTERN_TYPE1;
-            pdcch_params->n_rb = (cset_idx < 10)? 24 : 48;
-            pdcch_params->n_symb = nr_coreset_nsymb_pdcch_type_0_b40Mhz[cset_idx];
-            pdcch_params->rb_offset =  nr_coreset_rb_offset_pdcch_type_0_b40Mhz[cset_idx];
-            break;
-
-          default:
-            AssertFatal(1==0,"Invalid scs_common/pdcch_scs combination %d/%d \n", scs_common, pdcch_scs);
-        }
-      }
-
-      else {
-        AssertFatal(ss_idx<10 ,"Invalid scs_common/pdcch_scs combination %d/%d \n", scs_common, pdcch_scs);
-        switch(pdcch_scs) {
-          case kHz15:
-            break;
-
-          case kHz30:
-            pdcch_params->mux_pattern = NFAPI_NR_SSB_AND_CSET_MUX_PATTERN_TYPE1;
-            pdcch_params->n_rb = (cset_idx < 4)? 24 : 48;
-            pdcch_params->n_symb = nr_coreset_nsymb_pdcch_type_0_b40Mhz[cset_idx];
-            pdcch_params->rb_offset =  nr_coreset_rb_offset_pdcch_type_0_b40Mhz[cset_idx];
-            break;
-
-          default:
-            AssertFatal(1==0,"Invalid scs_common/pdcch_scs combination %d/%d \n", scs_common, pdcch_scs);
-        }
-      }
-
-    case kHz60:
-      mu = 2;
-      break;
-
-    case kHz120:
-    mu = 3;
-      break;
-
-  default:
-    AssertFatal(1==0,"Invalid common subcarrier spacing %d\n", scs_common);
-
-  }
-
-  /// Search space params
-  switch(pdcch_params->mux_pattern) {
-
-    case NFAPI_NR_SSB_AND_CSET_MUX_PATTERN_TYPE1:
-      if (freq_range == nr_FR1) {
-        O = nr_ss_param_O_type_0_mux1_FR1[ss_idx];
-        pdcch_params->nb_ss_sets_per_slot = nr_ss_sets_per_slot_type_0_FR1[ss_idx];
-        M = nr_ss_param_M_type_0_mux1_FR1[ss_idx];
-        pdcch_params->first_symbol = (ss_idx < 8)? ( (ss_idx&1)? pdcch_params->n_symb : 0 ) : nr_ss_first_symb_idx_type_0_mux1_FR1[ss_idx - 8];
-      }
-
-      else {
-        AssertFatal(ss_idx<14 ,"Invalid search space index for multiplexing type 1 and FR2 %d\n", ss_idx);
-        O = nr_ss_param_O_type_0_mux1_FR2[ss_idx];
-        pdcch_params->nb_ss_sets_per_slot = nr_ss_sets_per_slot_type_0_FR2[ss_idx];
-        M = nr_ss_param_M_type_0_mux1_FR2[ss_idx];
-        pdcch_params->first_symbol = (ss_idx < 12)? ( (ss_idx&1)? 7 : 0 ) : 0;
-      }
-      pdcch_params->nb_slots = 2;
-      pdcch_params->sfn_mod2 = ((uint8_t)(floor( (O*pow(2, mu) + floor(ssb_idx*M)) / nb_slots_per_frame )) & 1)? 1 : 0;
-      pdcch_params->first_slot = (uint8_t)(O*pow(2, mu) + floor(ssb_idx*M)) % nb_slots_per_frame;
-
-      break;
-
-    case NFAPI_NR_SSB_AND_CSET_MUX_PATTERN_TYPE2:
-      break;
-
-    case NFAPI_NR_SSB_AND_CSET_MUX_PATTERN_TYPE3:
-      break;
-
-    default:
-      AssertFatal(1==0, "Invalid SSB and coreset multiplexing pattern %d\n", pdcch_params->mux_pattern);
-  }
-  pdcch_params->config_type = NFAPI_NR_CSET_CONFIG_MIB_SIB1;
-  pdcch_params->search_space_type = NFAPI_NR_SEARCH_SPACE_TYPE_COMMON;
-  pdcch_params->common_search_space_type = NFAPI_NR_COMMON_SEARCH_SPACE_TYPE_0;
-  pdcch_params->cr_mapping_type = NFAPI_NR_CCE_REG_MAPPING_INTERLEAVED;
-  pdcch_params->precoder_granularity = NFAPI_NR_CSET_SAME_AS_REG_BUNDLE;
-  pdcch_params->reg_bundle_size = 6;
-  pdcch_params->interleaver_size = 2;
-}
-
-void nr_configure_css_dci_from_pdcch_config(nfapi_nr_dl_config_pdcch_parameters_rel15_t* pdcch_params,
-                                            nfapi_nr_coreset_t* coreset,
-                                            nfapi_nr_search_space_t* search_space) {
-
-  
-}

openair1/SCHED_NR/phy_procedures_nr_gNB.c

@@ -192,7 +192,7 @@ void phy_procedures_gNB_TX(PHY_VARS_gNB *gNB,
 
   num_dci = gNB->pdcch_vars.num_dci;
   num_pdsch_rnti = gNB->pdcch_vars.num_pdsch_rnti;
-  if (num_dci && (subframe==1)) {
+  if (num_dci) {
     LOG_I(PHY, "[gNB %d] Frame %d subframe %d \
     Calling nr_generate_dci_top (number of DCI %d)\n", gNB->Mod_id, frame, subframe, num_dci);
 

openair1/SCHED_NR_UE/defs.h

@@ -123,7 +123,7 @@ void phy_procedures_nrUE_TX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t e
   @param r_type indicates the relaying operation: 0: no_relaying, 1: unicast relaying type 1, 2: unicast relaying type 2, 3: multicast relaying
   @param phy_vars_rn pointer to RN variables
 */
-int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eNB_id,uint8_t abstraction_flag,uint8_t do_pdcch_flag,runmode_t mode,relaying_type_t r_type);
+int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eNB_id,uint8_t do_pdcch_flag,runmode_t mode);
 int phy_procedures_slot_parallelization_nrUE_RX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eNB_id,uint8_t abstraction_flag,uint8_t do_pdcch_flag,runmode_t mode,relaying_type_t r_type);
 
 #ifdef UE_SLOT_PARALLELISATION

openair1/SCHED_NR_UE/fapi_nr_ue_l1.c

@@ -65,7 +65,8 @@ int8_t nr_ue_scheduled_response(nr_scheduled_response_t *scheduled_response){
                 if(dl_config->dl_config_list[i].pdu_type == FAPI_NR_DL_CONFIG_TYPE_DCI){
                     pdcch_vars2->nb_search_space = pdcch_vars2->nb_search_space + 1;
                     fapi_nr_dl_config_dci_dl_pdu_rel15_t *dci_config = &dl_config->dl_config_list[i].dci_config_pdu.dci_config_rel15;
-                    
+             
+		    pdcch_vars2->n_RB_BWP[i] = dci_config->N_RB_BWP;
                     pdcch_vars2->searchSpace[i].monitoringSymbolWithinSlot = dci_config->monitoring_symbols_within_slot;
                     
                     pdcch_vars2->searchSpace[i].nrofCandidates_aggrlevel1  = dci_config->number_of_candidates[0];

openair1/SCHED_NR_UE/phy_procedures_nr_ue.c

@@ -56,7 +56,7 @@
 //#define DEBUG_PHY_PROC
 
 #define NR_PDCCH_SCHED
-#define NR_PDCCH_SCHED_DEBUG
+//#define NR_PDCCH_SCHED_DEBUG
 //#define NR_PUCCH_SCHED
 //#define NR_PUCCH_SCHED_DEBUG
 
@@ -2717,7 +2717,7 @@ void nr_ue_measurement_procedures(
   }
 #endif
   // accumulate and filter timing offset estimation every nr_tti_rx (instead of every frame)
-  if (( (slot%2) == 0) && (l==(1-frame_parms->Ncp))) {
+  if (( slot == 2) && (l==(1-frame_parms->Ncp))) {
 
     // AGC
 /*
@@ -3058,9 +3058,14 @@ int nr_ue_pdcch_procedures(uint8_t eNB_id,PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *
   // this table contains 56 (NBR_NR_DCI_FIELDS) elements for each dci field and format described in TS 38.212. Each element represents the size in bits for each dci field
   uint8_t dci_fields_sizes[NBR_NR_DCI_FIELDS][NBR_NR_FORMATS] = {{0}};
   // this is the UL bandwidth part. FIXME! To be defined where this value comes from
-  uint16_t n_RB_ULBWP = 106;
+    uint16_t n_RB_ULBWP = 106;
   // this is the DL bandwidth part. FIXME! To be defined where this value comes from
   uint16_t n_RB_DLBWP = 106;
+  //#ifdef NR_PDCCH_SCHED_DEBUG
+  //    printf("<-NR_PDCCH_PHY_PROCEDURES_LTE_UE (nr_ue_pdcch_procedures)-> n_RB_ULBWP=%d n_RB_DLBWP=%d\n",
+  //            n_RB_ULBWP,
+  //            n_RB_DLBWP);
+  //  #endif
 
   // First we have to identify each searchSpace active at a time and do PDCCH monitoring corresponding to current searchSpace
   // Up to 10 searchSpaces can be configured to UE (s<=10)
@@ -3307,8 +3312,8 @@ int nr_ue_pdcch_procedures(uint8_t eNB_id,PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *
                                                 ue->pdsch_config_dedicated,
                                                 ue->transmission_mode[eNB_id]<7?0:ue->transmission_mode[eNB_id],
                                                 dci_fields_sizes_cnt[i],
-                                                n_RB_ULBWP,
-                                                n_RB_DLBWP,
+					       pdcch_vars2->n_RB_BWP[nb_searchspace_active],
+					       pdcch_vars2->n_RB_BWP[nb_searchspace_active],
                                                 crc_scrambled_values,
                                                 &nr_dci_info_extracted);
 
@@ -4951,12 +4956,11 @@ int phy_procedures_slot_parallelization_nrUE_RX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_pr
 
 
 int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eNB_id,
-			 uint8_t abstraction_flag,uint8_t do_pdcch_flag,runmode_t mode,
-			 relaying_type_t r_type) {
+			   uint8_t do_pdcch_flag,runmode_t mode) {
 
-  int l,l2;
-  int pilot1;
-  int pmch_flag=0;
+
+  //int l,l2;
+  //int pilot1;
   int frame_rx = proc->frame_rx;
   int nr_tti_rx = proc->nr_tti_rx;
   uint16_t nb_symb_sch = 8; // to be updated by higher layer
@@ -4990,8 +4994,6 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eN
   start_meas(&ue->generic_stat);
 #endif
 
-  pmch_flag = is_pmch_subframe(frame_rx,nr_tti_rx,&ue->frame_parms) ? 1 : 0;
-
   if (do_pdcch_flag) {
   // deactivate reception until we scan pdcch
   if (ue->dlsch[ue->current_thread_id[nr_tti_rx]][eNB_id][0])
@@ -5023,8 +5025,6 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eN
 
   if (nr_subframe_select(&ue->frame_parms,nr_tti_rx) == SF_S) { // S-subframe, do first 5 symbols only
     l2 = 5;
-  } else if (pmch_flag == 1) { // do first 2 symbols only
-    l2 = 1;
   } else { // normal nr_tti_rx, last symbol to be processed is the first of the second slot
     l2 = (ue->frame_parms.symbols_per_tti/2)-1;
   }
@@ -5050,29 +5050,27 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eN
   //nr_gold_pdcch(ue,0, 2);
  if (nr_tti_rx==1){
   for (uint16_t l=0; l<nb_symb_pdcch; l++) {
-    if (abstraction_flag == 0) {
 #if UE_TIMING_TRACE
-        start_meas(&ue->ofdm_demod_stats);
+    start_meas(&ue->ofdm_demod_stats);
 #endif
 
       VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SLOT_FEP, VCD_FUNCTION_IN);
       nr_slot_fep(ue,
 		  l,
-		  nr_tti_rx,
+		  nr_tti_rx<<1,
 		  0,
 		  0,
 		  1,
 		 NR_PDCCH_EST);
       VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SLOT_FEP, VCD_FUNCTION_OUT);
 #if UE_TIMING_TRACE
-      stop_meas(&ue->ofdm_demod_stats);
+    stop_meas(&ue->ofdm_demod_stats);
 #endif
       //printf("phy procedure pdcch start measurement l =%d\n",l);
-      nr_ue_measurement_procedures(l,ue,proc,eNB_id,(nr_tti_rx<<1),abstraction_flag,mode);
-	}
-      }
+      nr_ue_measurement_procedures(l,ue,proc,eNB_id,(nr_tti_rx<<1),0,mode);
+  }
 
-  if (nr_ue_pdcch_procedures(eNB_id,ue,proc,abstraction_flag) == -1) {
+  if (nr_ue_pdcch_procedures(eNB_id,ue,proc,0) == -1) {
     LOG_E(PHY,"[UE  %d] Frame %d, nr_tti_rx %d: Error in pdcch procedures\n",ue->Mod_id,frame_rx,nr_tti_rx);
     return(-1);
   }
@@ -5095,7 +5093,7 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eN
 		  NR_PDSCH_EST);
       
       //printf("phy procedure pdsch start measurement\n"); 
-      nr_ue_measurement_procedures(m,ue,proc,eNB_id,(nr_tti_rx<<1),abstraction_flag,mode);
+      nr_ue_measurement_procedures(m,ue,proc,eNB_id,(nr_tti_rx<<1),0,mode);
       
     }
     //set active for testing, to be removed
@@ -5118,7 +5116,7 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eN
 			NULL,
 			nb_symb_pdcch, //ue->pdcch_vars[ue->current_thread_id[nr_tti_rx]][eNB_id]->num_pdcch_symbols,
 			(nb_symb_sch+nb_symb_pdcch-1), //ue->frame_parms.symbols_per_tti>>1,
-			abstraction_flag);
+			0);
 
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDSCH_PROC, VCD_FUNCTION_OUT);
   }
@@ -5135,7 +5133,7 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eN
 			NULL,
 			ue->pdcch_vars[ue->current_thread_id[nr_tti_rx]][eNB_id]->num_pdcch_symbols,
 			ue->frame_parms.symbols_per_tti>>1,
-			abstraction_flag);
+			0);
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDSCH_PROC_SI, VCD_FUNCTION_OUT);
   }
 
@@ -5150,7 +5148,7 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eN
 			NULL,
 			ue->pdcch_vars[ue->current_thread_id[nr_tti_rx]][eNB_id]->num_pdcch_symbols,
 			ue->frame_parms.symbols_per_tti>>1,
-			abstraction_flag);
+			0);
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDSCH_PROC_P, VCD_FUNCTION_OUT);
   }
 
@@ -5165,62 +5163,13 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eN
 			NULL,
 			ue->pdcch_vars[ue->current_thread_id[nr_tti_rx]][eNB_id]->num_pdcch_symbols,
 			ue->frame_parms.symbols_per_tti>>1,
-			abstraction_flag);
+			0);
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDSCH_PROC_RA, VCD_FUNCTION_OUT);
   }
-//#if 0
+
   LOG_D(PHY," ------ slot 1 Processing: AbsSubframe %d.%d ------  \n", frame_rx%1024, nr_tti_rx);
   LOG_D(PHY," ------  --> FFT/ChannelEst/PDCCH slot 1: AbsSubframe %d.%d ------  \n", frame_rx%1024, nr_tti_rx);
 
-  if (nr_subframe_select(&ue->frame_parms,nr_tti_rx) != SF_S) {  // do front-end processing for second slot, and first symbol of next nr_tti_rx
-    for (l=1; l<ue->frame_parms.symbols_per_tti>>1; l++) {
-      if (abstraction_flag == 0) {
-#if UE_TIMING_TRACE
-          start_meas(&ue->ofdm_demod_stats);
-#endif
-	VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SLOT_FEP, VCD_FUNCTION_IN);
-	/*nr_slot_fep(ue,
-		 l,
-		 1+(nr_tti_rx<<1),
-		 0,
-		 0,
-		 0,
-		 NR_PDSCH_EST);*/
-	VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SLOT_FEP, VCD_FUNCTION_OUT);
-#if UE_TIMING_TRACE
-    stop_meas(&ue->ofdm_demod_stats);
-#endif
-      }
-
-      //ue_measurement_procedures(l-1,ue,proc,eNB_id,1+(nr_tti_rx<<1),abstraction_flag,mode);
-
-    } // for l=1..l2
-
-    // do first symbol of next downlink nr_tti_rx for channel estimation
-    int next_nr_tti_rx = (1+nr_tti_rx)%10;
-    if (nr_subframe_select(&ue->frame_parms,next_nr_tti_rx) != SF_UL)
-    {
-      /*nr_slot_fep(ue,
-         0,
-         (next_nr_tti_rx<<1),
-         0,
-         0,
-         0,
-		 NR_PDSCH_EST);*/
-    }
-  } // not an S-subframe
-#if UE_TIMING_TRACE
-  stop_meas(&ue->generic_stat);
-#if DISABLE_LOG_X
-  printf("[SFN %d] Slot1: FFT + Channel Estimate + Pdsch Proc Slot0 %5.2f \n",nr_tti_rx,ue->generic_stat.p_time/(cpuf*1000.0));
-#else
-  LOG_D(PHY, "[SFN %d] Slot1: FFT + Channel Estimate + Pdsch Proc Slot0 %5.2f \n",nr_tti_rx,ue->generic_stat.p_time/(cpuf*1000.0));
-#endif
-
-#endif
-
-  //LOG_D(PHY," ------  end FFT/ChannelEst/PDCCH slot 1: AbsSubframe %d.%d ------  \n", frame_rx%1024, nr_tti_rx);
-
   if ( (nr_tti_rx == 0) && (ue->decode_MIB == 1))
   {
 	for (int i=0; i<3; i++)
@@ -5232,7 +5181,7 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eN
 			      1,
 			      NR_PBCH_EST);
 
-    nr_ue_pbch_procedures(eNB_id,ue,proc,abstraction_flag);
+    nr_ue_pbch_procedures(eNB_id,ue,proc,0);
   }
 
   // do procedures for C-RNTI
@@ -5251,7 +5200,7 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eN
 			NULL,
 			1+(ue->frame_parms.symbols_per_tti>>1),
 			ue->frame_parms.symbols_per_tti-1,
-			abstraction_flag);
+			0);
     LOG_D(PHY," ------ end PDSCH ChannelComp/LLR slot 0: AbsSubframe %d.%d ------  \n", frame_rx%1024, nr_tti_rx);
     LOG_D(PHY," ------ --> PDSCH Turbo Decoder slot 0/1: AbsSubframe %d.%d ------  \n", frame_rx%1024, nr_tti_rx);*/
 #if UE_TIMING_TRACE
@@ -5269,7 +5218,7 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eN
 			ue->dlsch[ue->current_thread_id[nr_tti_rx]][eNB_id][1],
 			&ue->dlsch_errors[eNB_id],
 			mode,
-			abstraction_flag);
+			0);
 #if UE_TIMING_TRACE
     stop_meas(&ue->dlsch_procedures_stat[ue->current_thread_id[nr_tti_rx]]);
 #if DISABLE_LOG_X
@@ -5319,7 +5268,7 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eN
       NULL,
       1+(ue->frame_parms.symbols_per_tti>>1),
       ue->frame_parms.symbols_per_tti-1,
-      abstraction_flag);
+      0);
 
     /*ue_dlsch_procedures(ue,
       proc,
@@ -5329,7 +5278,7 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eN
       NULL,
       &ue->dlsch_SI_errors[eNB_id],
       mode,
-      abstraction_flag);
+      0);
     ue->dlsch_SI[eNB_id]->active = 0;*/
   }
 
@@ -5343,7 +5292,7 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eN
       NULL,
       1+(ue->frame_parms.symbols_per_tti>>1),
       ue->frame_parms.symbols_per_tti-1,
-      abstraction_flag);
+      0);
 
     /*ue_dlsch_procedures(ue,
       proc,
@@ -5353,7 +5302,7 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eN
       NULL,
       &ue->dlsch_p_errors[eNB_id],
       mode,
-      abstraction_flag);*/
+      0);*/
     ue->dlsch_p[eNB_id]->active = 0;
   }
   // do procedures for RA-RNTI
@@ -5366,7 +5315,7 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eN
       NULL,
       1+(ue->frame_parms.symbols_per_tti>>1),
       ue->frame_parms.symbols_per_tti-1,
-      abstraction_flag);
+      0);
     /*ue_dlsch_procedures(ue,
       proc,
       eNB_id,
@@ -5375,7 +5324,7 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,UE_nr_rxtx_proc_t *proc,uint8_t eN
       NULL,
       &ue->dlsch_ra_errors[eNB_id],
       mode,
-      abstraction_flag);*/
+      0);*/
     ue->dlsch_ra[eNB_id]->active = 0;
   }
 

openair1/SIMULATION/NR_PHY/dlschsim.c

@@ -593,14 +593,15 @@ int main(int argc, char **argv) {
 
         if (estimated_output_bit[i] != test_input_bit[i]) {
           errors_bit++;
-          //printf("estimated bits error occurs @%d ",i);
+	  if (n_trials==1)          
+	    printf("bit error @%d\n",i);
         }
       }
 
       if (errors_bit>0) {
 	n_false_positive++;
 	if (n_trials == 1)
-	  printf("\n errors_bit %d (trial %d)\n", errors_bit,trial);
+	  printf("total bit errors %d\n", errors_bit);
       }
     }
 

openair1/SIMULATION/NR_PHY/dlsim.c

@@ -72,8 +72,8 @@ int oai_nfapi_ul_config_req(nfapi_ul_config_request_t *ul_config_req) { return(0
 
 int oai_nfapi_nr_dl_config_req(nfapi_nr_dl_config_request_t *dl_config_req) {return(0);}
 
-uint32_t from_earfcn(int eutra_bandP,uint32_t dl_earfcn) {return(0);}
-int32_t get_uldl_offset(int eutra_bandP) {return(0);}
+uint32_t from_nrarfcn(int nr_bandP,uint32_t dl_nrarfcn) {return(0);}
+int32_t get_uldl_offset(int nr_bandP) {return(0);}
 
 NR_IF_Module_t *NR_IF_Module_init(int Mod_id){return(NULL);}
 
@@ -97,7 +97,12 @@ int rlc_module_init (void) {return(0);}
 void pdcp_layer_init(void) {}
 int rrc_init_nr_global_param(void){return(0);}
 
-
+void config_common(int Mod_idP, 
+                   int CC_idP,
+                   int nr_bandP,
+                   uint64_t dl_CarrierFreqP,
+                   uint32_t dl_BandwidthP
+		   );
 
 // needed for some functions
 PHY_VARS_NR_UE ***PHY_vars_UE_g;
@@ -376,6 +381,8 @@ int main(int argc, char **argv)
   RC.gNB = (PHY_VARS_gNB***) malloc(sizeof(PHY_VARS_gNB **));
   RC.gNB[0] = (PHY_VARS_gNB**) malloc(sizeof(PHY_VARS_gNB *));
   RC.gNB[0][0] = malloc(sizeof(PHY_VARS_gNB));
+  memset(RC.gNB[0][0],0,sizeof(PHY_VARS_gNB));
+
   gNB = RC.gNB[0][0];
   gNB_config = &gNB->gNB_config;
   frame_parms = &gNB->frame_parms; //to be initialized I suppose (maybe not necessary for PBCH)
@@ -384,9 +391,14 @@ int main(int argc, char **argv)
   frame_parms->N_RB_DL = N_RB_DL;
   frame_parms->N_RB_UL = N_RB_DL;
 
+  // stub to configure frame_parms
   nr_phy_config_request_sim(gNB,N_RB_DL,N_RB_DL,mu);
+  // call MAC to configure common parameters
+
   phy_init_nr_gNB(gNB,0,0);
 
+
+
   double fs,bw;
 
   if (mu == 1 && N_RB_DL == 217) { 
@@ -455,11 +467,12 @@ int main(int argc, char **argv)
 
   //configure UE
   UE = malloc(sizeof(PHY_VARS_NR_UE));
+  memset((void*)UE,0,sizeof(PHY_VARS_NR_UE));
   PHY_vars_UE_g = malloc(sizeof(PHY_VARS_NR_UE**));
   PHY_vars_UE_g[0] = malloc(sizeof(PHY_VARS_NR_UE*));
   PHY_vars_UE_g[0][0] = UE;
   memcpy(&UE->frame_parms,frame_parms,sizeof(NR_DL_FRAME_PARMS));
-  phy_init_nr_top(UE);
+
   if (run_initial_sync==1)  UE->is_synchronized = 0;
   else                      UE->is_synchronized = 1;
                       
@@ -477,6 +490,8 @@ int main(int argc, char **argv)
   mac_top_init_gNB();
   gNB_mac = RC.nrmac[0];
 
+  config_common(0,0,78,(uint64_t)3640000000L,N_RB_DL*180000*(mu+1));
+
   nr_l2_init_ue();
   UE_mac = get_mac_inst(0);
 
@@ -563,6 +578,7 @@ int main(int argc, char **argv)
     }
   }
 
+
   //Configure UE
   fapi_nr_dl_config_request_t dl_config; 
   //  Type0 PDCCH search space
@@ -604,8 +620,9 @@ int main(int argc, char **argv)
   dl_config.dl_config_list[0].dci_config_pdu.dci_config_rel15.number_of_candidates[4] = table_38213_10_1_1_c2[4];   //  CCE aggregation level = 16
   dl_config.dl_config_list[0].dci_config_pdu.dci_config_rel15.duration = search_space_duration;
   dl_config.dl_config_list[0].dci_config_pdu.dci_config_rel15.monitoring_symbols_within_slot = (0x3fff << first_symbol_index) & (0x3fff >> (14-coreset_duration-first_symbol_index)) & 0x3fff;
-  	
-  
+
+  dl_config.dl_config_list[0].dci_config_pdu.dci_config_rel15.N_RB_BWP = N_RB_DL;
+
   for (SNR=snr0; SNR<snr1; SNR+=.2) {
 
     n_errors = 0;

openair1/SIMULATION/NR_PHY/pbchsim.c

@@ -66,8 +66,8 @@ int oai_nfapi_ul_config_req(nfapi_ul_config_request_t *ul_config_req) { return(0
 
 int oai_nfapi_nr_dl_config_req(nfapi_nr_dl_config_request_t *dl_config_req) {return(0);}
 
-uint32_t from_earfcn(int eutra_bandP,uint32_t dl_earfcn) {return(0);}
-int32_t get_uldl_offset(int eutra_bandP) {return(0);}
+uint32_t from_nrarfcn(int nr_bandP,uint32_t dl_nrarfcn) {return(0);}
+int32_t get_uldl_offset(int nr_bandP) {return(0);}
 
 NR_IF_Module_t *NR_IF_Module_init(int Mod_id){return(NULL);}
 
@@ -513,7 +513,7 @@ int main(int argc, char **argv)
       sigma2 = pow(10,sigma2_dB/10);
       //      printf("sigma2 %f (%f dB)\n",sigma2,sigma2_dB);
 
-      for (i=0; i<frame_length_complex_samples; i++) {
+      for (i=0; i<frame_parms->samples_per_subframe; i++) {
 	for (aa=0; aa<frame_parms->nb_antennas_rx; aa++) {
 	  
 	  ((short*) UE->common_vars.rxdata[aa])[2*i]   = (short) ((r_re[aa][i] + sqrt(sigma2/2)*gaussdouble(0.0,1.0)));
@@ -522,9 +522,9 @@ int main(int argc, char **argv)
       }
 
       if (n_trials==1) {
-	LOG_M("rxsig0.m","rxs0", UE->common_vars.rxdata[0],frame_length_complex_samples,1,1);
+	LOG_M("rxsig0.m","rxs0", UE->common_vars.rxdata[0],frame_parms->samples_per_subframe,1,1);
 	if (gNB->frame_parms.nb_antennas_tx>1)
-	  LOG_M("rxsig1.m","rxs1", UE->common_vars.rxdata[1],frame_length_complex_samples,1,1);
+	  LOG_M("rxsig1.m","rxs1", UE->common_vars.rxdata[1],frame_parms->samples_per_subframe,1,1);
       }
 
       if (UE->is_synchronized == 0) {

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

@@ -119,9 +119,9 @@ void dl_phy_sync_success(module_id_t module_idP,
 			 frame_t frameP,
 			 unsigned char eNB_index, uint8_t first_sync){}
 
-uint32_t from_earfcn(int eutra_bandP, uint32_t dl_earfcn) { return(0);}
+uint32_t from_nrarfcn(int nr_bandP, uint32_t dl_nrarfcn) { return(0);}
 
-int32_t get_uldl_offset(int eutra_bandP) { return(0);}
+int32_t get_uldl_offset(int nr_bandP) { return(0);}
 
 IF_Module_t *IF_Module_init(int Mod_id) { return(NULL);}
 

openair2/LAYER2/NR_MAC_gNB/config.c

@@ -52,96 +52,87 @@ extern uint8_t nfapi_mode;
 int32_t **rxdata;
 int32_t **txdata;
 
-typedef struct eutra_bandentry_s {
+typedef struct nr_bandentry_s {
   int16_t band;
-  uint32_t ul_min;
-  uint32_t ul_max;
-  uint32_t dl_min;
-  uint32_t dl_max;
-  uint32_t N_OFFs_DL;
-} eutra_bandentry_t;
+  uint64_t ul_min;
+  uint64_t ul_max;
+  uint64_t dl_min;
+  uint64_t dl_max;
+  uint64_t N_OFFs_DL;
+  uint64_t step_size;
+} nr_bandentry_t;
 
 typedef struct band_info_s {
   int nbands;
-  eutra_bandentry_t band_info[100];
-} band_info_t;
+  nr_bandentry_t band_info[100];
+} nr_band_info_t;
 
-static const eutra_bandentry_t eutra_bandtable[] = {
-  {1, 19200, 19800, 21100, 21700, 0},
-  {2, 18500, 19100, 19300, 19900, 6000},
-  {3, 17100, 17850, 18050, 18800, 12000},
-  {4, 17100, 17550, 21100, 21550, 19500},
-  {5, 8240, 8490, 8690, 8940, 24000},
-  {6, 8300, 8400, 8750, 8850, 26500},
-  {7, 25000, 25700, 26200, 26900, 27500},
-  {8, 8800, 9150, 9250, 9600, 34500},
-  {9, 17499, 17849, 18449, 18799, 38000},
-  {10, 17100, 17700, 21100, 21700, 41500},
-  {11, 14279, 14529, 14759, 15009, 47500},
-  {12, 6980, 7160, 7280, 7460, 50100},
-  {13, 7770, 7870, 7460, 7560, 51800},
-  {14, 7880, 7980, 7580, 7680, 52800},
-  {17, 7040, 7160, 7340, 7460, 57300},
-  {18, 8150, 9650, 8600, 10100, 58500},
-  {19, 8300, 8450, 8750, 8900, 60000},
-  {20, 8320, 8620, 7910, 8210, 61500},
-  {21, 14479, 14629, 14959, 15109, 64500},
-  {22, 34100, 34900, 35100, 35900, 66000},
-  {23, 20000, 20200, 21800, 22000, 75000},
-  {24, 16126, 16605, 15250, 15590, 77000},
-  {25, 18500, 19150, 19300, 19950, 80400},
-  {26, 8140, 8490, 8590, 8940, 86900},
-  {27, 8070, 8240, 8520, 8690, 90400},
-  {28, 7030, 7580, 7580, 8130, 92100},
-  {29, 0, 0, 7170, 7280, 96600},
-  {30, 23050, 23250, 23500, 23600, 97700},
-  {31, 45250, 34900, 46250, 35900, 98700},
-  {32, 0, 0, 14520, 14960, 99200},
-  {33, 19000, 19200, 19000, 19200, 36000},
-  {34, 20100, 20250, 20100, 20250, 36200},
-  {35, 18500, 19100, 18500, 19100, 36350},
-  {36, 19300, 19900, 19300, 19900, 36950},
-  {37, 19100, 19300, 19100, 19300, 37550},
-  {38, 25700, 26200, 25700, 26300, 37750},
-  {39, 18800, 19200, 18800, 19200, 38250},
-  {40, 23000, 24000, 23000, 24000, 38650},
-  {41, 24960, 26900, 24960, 26900, 39650},
-  {42, 34000, 36000, 34000, 36000, 41590},
-  {43, 36000, 38000, 36000, 38000, 43590},
-  {44, 7030, 8030, 7030, 8030, 45590},
-  {45, 14470, 14670, 14470, 14670, 46590},
-  {46, 51500, 59250, 51500, 59250, 46790},
-  {65, 19200, 20100, 21100, 22000, 65536},
-  {66, 17100, 18000, 21100, 22000, 66436},
-  {67, 0, 0, 7380, 7580, 67336},
-  {68, 6980, 7280, 7530, 7830, 67536}
+static const nr_bandentry_t nr_bandtable[] = {
+  {1,  1920000, 1980000, 2110000, 2170000, 20, 422000},
+  {2,  1850000, 1910000, 1930000, 1990000, 20, 386000},
+  {3,  1710000, 1785000, 1805000, 1880000, 20, 361000},
+  {5,   824000,  849000,  869000,  894000, 20, 173800},
+  {7,  2500000, 2570000, 2620000, 2690000, 20, 524000},
+  {8,   880000,  915000,  925000,  960000, 20, 185000},
+  {12,  698000,  716000,  728000,  746000, 20, 145800},
+  {20,  832000,  862000,  791000,  821000, 20, 158200},
+  {25, 1850000, 1915000, 1930000, 1995000, 20, 386000},
+  {28,  703000,  758000,  758000,  813000, 20, 151600},
+  {34, 2010000, 2025000, 2010000, 2025000, 20, 402000},
+  {38, 2570000, 2620000, 2570000, 2630000, 20, 514000},
+  {39, 1880000, 1920000, 1880000, 1920000, 20, 376000},
+  {40, 2300000, 2400000, 2300000, 2400000, 20, 460000},
+  {41, 2496000, 2690000, 2496000, 2690000,  3, 499200},
+  {50, 1432000, 1517000, 1432000, 1517000, 20, 286400},
+  {51, 1427000, 1432000, 1427000, 1432000, 20, 285400},
+  {66, 1710000, 1780000, 2110000, 2200000, 20, 422000},
+  {70, 1695000, 1710000, 1995000, 2020000, 20, 399000},
+  {71,  663000,  698000,  617000,  652000, 20, 123400},
+  {74, 1427000, 1470000, 1475000, 1518000, 20, 295000},
+  {75,     000,     000, 1432000, 1517000, 20, 286400},
+  {76,     000,     000, 1427000, 1432000, 20, 285400},
+  {77, 3300000, 4200000, 3300000, 4200000,  1, 620000},
+  {78, 3300000, 3800000, 3300000, 3800000,  1, 620000},
+  {79, 4400000, 5000000, 4400000, 5000000,  2, 693334},
+  {80, 1710000, 1785000,     000,     000, 20, 342000},
+  {81,  860000,  915000,     000,     000, 20, 176000},
+  {82,  832000,  862000,     000,     000, 20, 166400},
+  {83,  703000,  748000,     000,     000, 20, 140600},
+  {84, 1920000, 1980000,     000,     000, 20, 384000},
+  {86, 1710000, 1785000,     000,     000, 20, 342000}
 };
 
 
-uint32_t nr_to_earfcn(int eutra_bandP, uint32_t dl_CarrierFreq, uint32_t bw)
+uint32_t to_nrarfcn(int nr_bandP, uint64_t dl_CarrierFreq, uint32_t bw)
 {
 
-  uint32_t dl_CarrierFreq_by_100k = dl_CarrierFreq / 100000;
-  int bw_by_100 = bw / 100;
+  uint64_t dl_CarrierFreq_by_1k = dl_CarrierFreq / 1000;
+  int bw_kHz = bw / 1000;
 
   int i;
 
-  AssertFatal(eutra_bandP < 69, "eutra_band %d > 68\n", eutra_bandP);
-  for (i = 0; i < 69 && eutra_bandtable[i].band != eutra_bandP; i++);
+  AssertFatal(nr_bandP < 86, "nr_band %d > 86\n", nr_bandP);
+  for (i = 0; i < 30 && nr_bandtable[i].band != nr_bandP; i++);
 
-  AssertFatal(dl_CarrierFreq_by_100k >= eutra_bandtable[i].dl_min,
-        "Band %d, bw %u : DL carrier frequency %u Hz < %u\n",
-        eutra_bandP, bw, dl_CarrierFreq,
-        eutra_bandtable[i].dl_min);
-  AssertFatal(dl_CarrierFreq_by_100k <=
-        (eutra_bandtable[i].dl_max - bw_by_100),
-        "Band %d, bw %u: DL carrier frequency %u Hz > %d\n",
-        eutra_bandP, bw, dl_CarrierFreq,
-        eutra_bandtable[i].dl_max - bw_by_100);
+  AssertFatal(dl_CarrierFreq_by_1k >= nr_bandtable[i].dl_min,
+        "Band %d, bw %u : DL carrier frequency %llu kHz < %llu\n",
+	      nr_bandP, bw, (long long unsigned int)dl_CarrierFreq_by_1k,
+	      (long long unsigned int)nr_bandtable[i].dl_min);
+  AssertFatal(dl_CarrierFreq_by_1k <=
+        (nr_bandtable[i].dl_max - bw_kHz),
+        "Band %d, dl_CarrierFreq %llu bw %u: DL carrier frequency %llu kHz > %llu\n",
+	      nr_bandP, (long long unsigned int)dl_CarrierFreq,bw, (long long unsigned int)dl_CarrierFreq_by_1k,
+	      (long long unsigned int)(nr_bandtable[i].dl_max - bw_kHz));
+ 
+  int deltaFglobal;
 
+  if (dl_CarrierFreq < 3e9) deltaFglobal = 5;
+  else                      deltaFglobal = 15;
 
-  return (dl_CarrierFreq_by_100k - eutra_bandtable[i].dl_min +
-    (eutra_bandtable[i].N_OFFs_DL / 10));
+  // This is equation before Table 5.4.2.1-1 in 38101-1-f30
+  // F_REF=F_REF_Offs + deltaF_Global(N_REF-NREF_REF_Offs)
+  return (((dl_CarrierFreq_by_1k - nr_bandtable[i].dl_min)/deltaFglobal) +
+	  nr_bandtable[i].N_OFFs_DL);
 }
 
 
@@ -170,9 +161,9 @@ void config_nr_mib(int Mod_idP,
 
 void config_common(int Mod_idP, 
                    int CC_idP,
-                   int eutra_bandP,
-                   int dl_CarrierFreqP,
-                   int dl_BandwidthP
+                   int nr_bandP,
+                   uint64_t dl_CarrierFreqP,
+                   uint32_t dl_BandwidthP
                   ){
 
   nfapi_nr_config_request_t *cfg = &RC.nrmac[Mod_idP]->config[CC_idP];
@@ -184,12 +175,12 @@ void config_common(int Mod_idP,
   
   /// In NR DL and UL will be different band
   cfg->nfapi_config.rf_bands.number_rf_bands       = 1;
-  cfg->nfapi_config.rf_bands.rf_band[0]            = eutra_bandP;  
+  cfg->nfapi_config.rf_bands.rf_band[0]            = nr_bandP;  
   cfg->nfapi_config.rf_bands.tl.tag = NFAPI_PHY_RF_BANDS_TAG;
   cfg->num_tlv++;
 
-  cfg->nfapi_config.earfcn.value                   = nr_to_earfcn(eutra_bandP,dl_CarrierFreqP,dl_BandwidthP*180/100);
-  cfg->nfapi_config.earfcn.tl.tag = NFAPI_NFAPI_EARFCN_TAG;
+  cfg->nfapi_config.nrarfcn.value                   = to_nrarfcn(nr_bandP,dl_CarrierFreqP,dl_BandwidthP);
+  cfg->nfapi_config.nrarfcn.tl.tag = NFAPI_NR_NFAPI_NRARFCN_TAG;
   cfg->num_tlv++;
 
   cfg->subframe_config.numerology_index_mu.value = 1;
@@ -217,8 +208,8 @@ void config_common(int Mod_idP,
 int rrc_mac_config_req_gNB(module_id_t Mod_idP, 
                            int CC_idP,
                            int p_gNB,
-                           int eutra_bandP,
-                           int dl_CarrierFreqP,
+                           int nr_bandP,
+                           uint32_t dl_CarrierFreqP,
                            int dl_BandwidthP,
                            NR_BCCH_BCH_Message_t *mib,
                            NR_ServingCellConfigCommon_t *servingcellconfigcommon
@@ -245,7 +236,7 @@ int rrc_mac_config_req_gNB(module_id_t Mod_idP,
   if( servingcellconfigcommon != NULL ){
     config_common(Mod_idP, 
                   CC_idP,
-                  eutra_bandP,
+                  nr_bandP,
                   dl_CarrierFreqP,
                   dl_BandwidthP
                   );  

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_phytest.c

@@ -49,15 +49,21 @@ void nr_schedule_css_dlsch_phytest(module_id_t   module_idP,
   nfapi_nr_dl_config_request_pdu_t  *dl_config_dci_pdu;
   nfapi_nr_dl_config_request_pdu_t  *dl_config_dlsch_pdu;
   nfapi_tx_request_pdu_t            *TX_req;
+  nfapi_nr_config_request_t *cfg = &nr_mac->config[0];
+
   uint16_t sfn_sf = frameP << 4 | subframeP;
   uint16_t rnti = 0x1234;
+  int dl_carrier_bandwidth = cfg->rf_config.dl_carrier_bandwidth.value;
 
+  // everything here is hard-coded to 30 kHz
+  int scs = kHz30;
+  int mu = 1;
+  int slots_per_frame = 10 * (1<<mu);
   for (CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
     LOG_I(MAC, "Scheduling common search space DCI type 1 for CC_id %d\n",CC_id);
 
-    PHY_VARS_gNB                *gNB      = RC.gNB[module_idP][CC_id];
-    nfapi_nr_config_request_t     *cfg   = &gNB->gNB_config;
-    NR_DL_FRAME_PARMS             *fp    = &gNB->frame_parms;
+
+
 
     dl_req = &nr_mac->DL_req[CC_id].dl_config_request_body;
     dl_config_dci_pdu = &dl_req->dl_config_pdu_list[dl_req->number_pdu];
@@ -77,7 +83,7 @@ void nr_schedule_css_dlsch_phytest(module_id_t   module_idP,
     dlsch_pdu_rel15->start_prb = 0;
     dlsch_pdu_rel15->n_prb = 50;
     dlsch_pdu_rel15->start_symbol = 2;
-    dlsch_pdu_rel15->nb_symbols = 8;
+    dlsch_pdu_rel15->nb_symbols = 10;
     dlsch_pdu_rel15->rnti = rnti;
     dlsch_pdu_rel15->nb_layers =1;
     dlsch_pdu_rel15->nb_codewords = 1;
@@ -85,11 +91,10 @@ void nr_schedule_css_dlsch_phytest(module_id_t   module_idP,
     dlsch_pdu_rel15->ndi = 1;
     dlsch_pdu_rel15->redundancy_version = 0;
 
-    nr_configure_css_dci_from_mib(&gNB->pdcch_type0_params,
-                               kHz30, kHz30, nr_FR1, 0, 0,
-                               fp->slots_per_frame,
-                               cfg->rf_config.dl_carrier_bandwidth.value);
-    memcpy((void*)params_rel15, (void*)&gNB->pdcch_type0_params, sizeof(nfapi_nr_dl_config_pdcch_parameters_rel15_t));
+    nr_configure_css_dci_from_mib(params_rel15,
+				  scs, scs, nr_FR1, 0, 0,
+				  slots_per_frame,
+				  dl_carrier_bandwidth);
 
     pdu_rel15->frequency_domain_assignment = get_RIV(dlsch_pdu_rel15->start_prb, dlsch_pdu_rel15->n_prb, cfg->rf_config.dl_carrier_bandwidth.value);
     pdu_rel15->time_domain_assignment = get_SLIV(dlsch_pdu_rel15->start_symbol, dlsch_pdu_rel15->nb_symbols);

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_primitives.c

@@ -65,6 +65,24 @@ extern RAN_CONTEXT_t RC;
 
 extern int n_active_slices;
 
+/// LUT for the number of symbols in the coreset indexed by coreset index (4 MSB rmsi_pdcch_config)
+uint8_t nr_coreset_nsymb_pdcch_type_0_b40Mhz[16] = {2,2,2,2,2,3,3,3,3,3,1,1,1,2,2,2}; // below 40Mhz bw
+uint8_t nr_coreset_nsymb_pdcch_type_0_a40Mhz[10] = {2,2,3,3,1,1,2,2,3,3}; // above 40Mhz bw
+/// LUT for the number of RBs in the coreset indexed by coreset index
+uint8_t nr_coreset_rb_offset_pdcch_type_0_b40Mhz[16] = {0,1,2,3,4,0,1,2,3,4,12,14,16,12,14,16};
+uint8_t nr_coreset_rb_offset_pdcch_type_0_a40Mhz[10] = {0,4,0,4,0,28,0,28,0,28};
+/// LUT for monitoring occasions param O indexed by ss index (4 LSB rmsi_pdcch_config)
+uint8_t nr_ss_param_O_type_0_mux1_FR1[16] = {0,0,2,2,5,5,7,7,0,5,0,0,2,2,5,5};
+uint8_t nr_ss_param_O_type_0_mux1_FR2[14] = {0,0,2.5,2.5,5,5,0,2.5,5,7.5,7.5,7.5,0,5};
+/// LUT for number of SS sets per slot indexed by ss index
+uint8_t nr_ss_sets_per_slot_type_0_FR1[16] = {1,2,1,2,1,2,1,2,1,1,1,1,1,1,1,1};
+uint8_t nr_ss_sets_per_slot_type_0_FR2[14] = {1,2,1,2,1,2,2,2,2,1,2,2,1,1};
+/// LUT for monitoring occasions param M indexed by ss index
+uint8_t nr_ss_param_M_type_0_mux1_FR1[16] = {1,0.5,1,0.5,1,0.5,1,0.5,2,2,1,1,1,1,1,1};
+uint8_t nr_ss_param_M_type_0_mux1_FR2[14] = {1,0.5,1,0.5,1,0.5,0.5,0.5,0.5,1,0.5,0.5,2,2};
+/// LUT for SS first symbol index indexed by ss index
+uint8_t nr_ss_first_symb_idx_type_0_mux1_FR1[8] = {0,0,1,2,1,2,1,2};
+
 int is_nr_UL_sf(NR_COMMON_channels_t * ccP, sub_frame_t subframeP){
   // if FDD return dummy value
   if (ccP->tdd_Config == NULL)
@@ -121,3 +139,122 @@ int is_nr_UL_sf(NR_COMMON_channels_t * ccP, sub_frame_t subframeP){
     break;
   }
 }
+
+void nr_configure_css_dci_from_mib(nfapi_nr_dl_config_pdcch_parameters_rel15_t* pdcch_params,
+				   nr_scs_e scs_common,
+				   nr_scs_e pdcch_scs,
+				   nr_frequency_range_e freq_range,
+				   uint8_t rmsi_pdcch_config,
+				   uint8_t ssb_idx,
+				   uint16_t nb_slots_per_frame,
+				   uint16_t N_RB)
+{
+  uint8_t O, M;
+  uint8_t ss_idx = rmsi_pdcch_config&0xf;
+  uint8_t cset_idx = (rmsi_pdcch_config>>4)&0xf;
+  uint8_t mu;
+
+  /// Coreset params
+  switch(scs_common) {
+
+    case kHz15:
+      mu = 0;
+      break;
+
+    case kHz30:
+      mu = 1;
+
+      if (N_RB < 106) { // Minimum 40Mhz bandwidth not satisfied
+        switch(pdcch_scs) {
+          case kHz15:
+            break;
+
+          case kHz30:
+            pdcch_params->mux_pattern = NFAPI_NR_SSB_AND_CSET_MUX_PATTERN_TYPE1;
+            pdcch_params->n_rb = (cset_idx < 10)? 24 : 48;
+            pdcch_params->n_symb = nr_coreset_nsymb_pdcch_type_0_b40Mhz[cset_idx];
+            pdcch_params->rb_offset =  nr_coreset_rb_offset_pdcch_type_0_b40Mhz[cset_idx];
+            break;
+
+          default:
+            AssertFatal(1==0,"Invalid scs_common/pdcch_scs combination %d/%d \n", scs_common, pdcch_scs);
+        }
+      }
+
+      else {
+        AssertFatal(ss_idx<10 ,"Invalid scs_common/pdcch_scs combination %d/%d \n", scs_common, pdcch_scs);
+        switch(pdcch_scs) {
+          case kHz15:
+            break;
+
+          case kHz30:
+            pdcch_params->mux_pattern = NFAPI_NR_SSB_AND_CSET_MUX_PATTERN_TYPE1;
+            pdcch_params->n_rb = (cset_idx < 4)? 24 : 48;
+            pdcch_params->n_symb = nr_coreset_nsymb_pdcch_type_0_b40Mhz[cset_idx];
+            pdcch_params->rb_offset =  nr_coreset_rb_offset_pdcch_type_0_b40Mhz[cset_idx];
+            break;
+
+          default:
+            AssertFatal(1==0,"Invalid scs_common/pdcch_scs combination %d/%d \n", scs_common, pdcch_scs);
+        }
+      }
+
+    case kHz60:
+      mu = 2;
+      break;
+
+    case kHz120:
+    mu = 3;
+      break;
+
+  default:
+    AssertFatal(1==0,"Invalid common subcarrier spacing %d\n", scs_common);
+
+  }
+
+  /// Search space params
+  switch(pdcch_params->mux_pattern) {
+
+    case NFAPI_NR_SSB_AND_CSET_MUX_PATTERN_TYPE1:
+      if (freq_range == nr_FR1) {
+        O = nr_ss_param_O_type_0_mux1_FR1[ss_idx];
+        pdcch_params->nb_ss_sets_per_slot = nr_ss_sets_per_slot_type_0_FR1[ss_idx];
+        M = nr_ss_param_M_type_0_mux1_FR1[ss_idx];
+        pdcch_params->first_symbol = (ss_idx < 8)? ( (ss_idx&1)? pdcch_params->n_symb : 0 ) : nr_ss_first_symb_idx_type_0_mux1_FR1[ss_idx - 8];
+      }
+
+      else {
+        AssertFatal(ss_idx<14 ,"Invalid search space index for multiplexing type 1 and FR2 %d\n", ss_idx);
+        O = nr_ss_param_O_type_0_mux1_FR2[ss_idx];
+        pdcch_params->nb_ss_sets_per_slot = nr_ss_sets_per_slot_type_0_FR2[ss_idx];
+        M = nr_ss_param_M_type_0_mux1_FR2[ss_idx];
+        pdcch_params->first_symbol = (ss_idx < 12)? ( (ss_idx&1)? 7 : 0 ) : 0;
+      }
+      pdcch_params->nb_slots = 2;
+      pdcch_params->sfn_mod2 = ((uint8_t)(floor( (O*pow(2, mu) + floor(ssb_idx*M)) / nb_slots_per_frame )) & 1)? 1 : 0;
+      pdcch_params->first_slot = (uint8_t)(O*pow(2, mu) + floor(ssb_idx*M)) % nb_slots_per_frame;
+
+      break;
+
+    case NFAPI_NR_SSB_AND_CSET_MUX_PATTERN_TYPE2:
+      break;
+
+    case NFAPI_NR_SSB_AND_CSET_MUX_PATTERN_TYPE3:
+      break;
+
+    default:
+      AssertFatal(1==0, "Invalid SSB and coreset multiplexing pattern %d\n", pdcch_params->mux_pattern);
+  }
+  pdcch_params->config_type = NFAPI_NR_CSET_CONFIG_MIB_SIB1;
+  pdcch_params->cr_mapping_type = NFAPI_NR_CCE_REG_MAPPING_INTERLEAVED;
+  pdcch_params->precoder_granularity = NFAPI_NR_CSET_SAME_AS_REG_BUNDLE;
+  pdcch_params->reg_bundle_size = 6;
+  pdcch_params->interleaver_size = 2;
+}
+
+void nr_configure_css_dci_from_pdcch_config(nfapi_nr_dl_config_pdcch_parameters_rel15_t* pdcch_params,
+                                            nfapi_nr_coreset_t* coreset,
+                                            nfapi_nr_search_space_t* search_space) {
+
+  
+}

openair2/LAYER2/NR_MAC_gNB/mac_proto.h

@@ -40,7 +40,7 @@ int rrc_mac_config_req_gNB(module_id_t Mod_idP,
                            int CC_id,
                            int p_gNB,
                            int eutra_bandP,
-                           int dl_CarrierFreqP,
+                           uint32_t dl_CarrierFreqP,
                            int dl_BandwidthP,
                            NR_BCCH_BCH_Message_t *mib,
                            NR_ServingCellConfigCommon_t *servingcellconfigcommon
@@ -59,4 +59,25 @@ void gNB_dlsch_ulsch_scheduler(module_id_t module_idP,
 
 void schedule_nr_mib(module_id_t module_idP, frame_t frameP, sub_frame_t subframeP);
 
+
+
+void nr_schedule_css_dlsch_phytest(module_id_t   module_idP,
+                                   frame_t       frameP,
+                                   sub_frame_t   subframeP);
+
+
+void nr_configure_css_dci_from_mib(nfapi_nr_dl_config_pdcch_parameters_rel15_t* pdcch_params,
+				   nr_scs_e scs_common,
+				   nr_scs_e pdcch_scs,
+				   nr_frequency_range_e freq_range,
+				   uint8_t rmsi_pdcch_config,
+				   uint8_t ssb_idx,
+				   uint16_t nb_slots_per_frame,
+				   uint16_t N_RB);
+
+
+void nr_configure_css_dci_from_pdcch_config(nfapi_nr_dl_config_pdcch_parameters_rel15_t* pdcch_params,
+                                            nfapi_nr_coreset_t* coreset,
+                                            nfapi_nr_search_space_t* search_space);
+
 #endif /*__LAYER2_NR_MAC_PROTO_H__*/

openair2/NR_UE_PHY_INTERFACE/NR_IF_Module.c

@@ -41,7 +41,7 @@
 static nr_ue_if_module_t *nr_ue_if_module_inst[MAX_IF_MODULES];
 
 //  L2 Abstraction Layer
-int8_t handle_bcch_bch(module_id_t module_id, int cc_id, uint8_t gNB_index, uint8_t *pduP, uint8_t additional_bits, uint32_t ssb_index, uint32_t ssb_length, uint16_t cell_id){
+int handle_bcch_bch(module_id_t module_id, int cc_id, unsigned int gNB_index, uint8_t *pduP, unsigned int additional_bits, uint32_t ssb_index, uint32_t ssb_length, uint16_t cell_id){
 
     return nr_ue_decode_mib( module_id,
                              cc_id,
@@ -55,12 +55,12 @@ int8_t handle_bcch_bch(module_id_t module_id, int cc_id, uint8_t gNB_index, uint
 }
 
 //  L2 Abstraction Layer
-int8_t handle_bcch_dlsch(module_id_t module_id, int cc_id, uint8_t gNB_index, uint32_t sibs_mask, uint8_t *pduP, uint32_t pdu_len){
+int handle_bcch_dlsch(module_id_t module_id, int cc_id, unsigned int gNB_index, uint32_t sibs_mask, uint8_t *pduP, uint32_t pdu_len){
 
     return 0;
 }
 //  L2 Abstraction Layer
-int8_t handle_dci(module_id_t module_id, int cc_id, uint8_t gNB_index, fapi_nr_dci_pdu_rel15_t *dci, uint16_t rnti, uint32_t dci_type){
+int handle_dci(module_id_t module_id, int cc_id, unsigned int gNB_index, fapi_nr_dci_pdu_rel15_t *dci, uint16_t rnti, uint32_t dci_type){
 
     return nr_ue_process_dci(module_id, cc_id, gNB_index, dci, rnti, dci_type);
 
@@ -78,7 +78,7 @@ int8_t handle_dlsch (module_id_t module_id, int cc_id, uint8_t gNB_index, fapi_n
 
 }
 
-int8_t nr_ue_ul_indication(nr_uplink_indication_t *ul_info){
+int nr_ue_ul_indication(nr_uplink_indication_t *ul_info){
 
     NR_UE_L2_STATE_t ret;
     module_id_t module_id = ul_info->module_id;
@@ -118,7 +118,7 @@ int8_t nr_ue_ul_indication(nr_uplink_indication_t *ul_info){
     return 0;
 }
 
-int8_t nr_ue_dl_indication(nr_downlink_indication_t *dl_info){
+int nr_ue_dl_indication(nr_downlink_indication_t *dl_info){
     
     int32_t i;
     uint32_t ret_mask = 0x0;
@@ -248,7 +248,7 @@ nr_ue_if_module_t *nr_ue_if_module_init(uint32_t module_id){
     return nr_ue_if_module_inst[module_id];
 }
 
-int8_t nr_ue_if_module_kill(uint32_t module_id) {
+int nr_ue_if_module_kill(uint32_t module_id) {
 
     if (nr_ue_if_module_inst[module_id] != NULL){
         free(nr_ue_if_module_inst[module_id]);

openair2/NR_UE_PHY_INTERFACE/NR_IF_Module.h

@@ -38,6 +38,21 @@
 
 
 
+typedef struct {
+    /// module id
+  module_id_t module_id;
+  /// gNB index
+  uint32_t gNB_index;
+  /// component carrier id
+  int cc_id;
+  /// frame 
+  frame_t frame;
+  /// slot
+  int slot;
+
+  fapi_nr_dl_config_request_t dl_config_req;
+} nr_dcireq_t;
+
 typedef struct {
     /// module id
     module_id_t module_id;
@@ -48,7 +63,7 @@ typedef struct {
     /// frame 
     frame_t frame;
     /// slot
-    uint8_t slot;
+    int slot;
 
     /// NR UE FAPI-like P7 message, direction: L1 to L2
     /// data reception indication structure
@@ -72,7 +87,7 @@ typedef struct {
     /// slot
     uint32_t slot;
     /// ssb_index, if ssb is not present in current TTI, thie value set to -1
-    int8_t ssb_index;
+    int ssb_index;
 } nr_uplink_indication_t;
 
 // Downlink subframe P7
@@ -82,13 +97,13 @@ typedef struct {
     /// module id
     module_id_t module_id; 
     /// component carrier id
-    uint8_t CC_id;
+    int CC_id;
     /// frame
     frame_t frame;
     /// subframe
     sub_frame_t subframe;
     /// slot
-    uint8_t slot;
+    int slot;
 
     /// NR UE FAPI-like P7 message, direction: L2 to L1
     /// downlink transmission configuration request structure
@@ -122,7 +137,7 @@ typedef struct {
  *  -1: Failed to consume bytes. Abort the mission.
  * Non-negative return values indicate success, and ignored.
  */
-typedef int8_t (nr_ue_scheduled_response_f)(nr_scheduled_response_t *scheduled_response);
+typedef int (nr_ue_scheduled_response_f)(nr_scheduled_response_t *scheduled_response);
 
 
 /*
@@ -132,7 +147,7 @@ typedef int8_t (nr_ue_scheduled_response_f)(nr_scheduled_response_t *scheduled_r
  *  -1: Failed to consume bytes. Abort the mission.
  * Non-negative return values indicate success, and ignored.
  */
-typedef int8_t (nr_ue_phy_config_request_f)(nr_phy_config_t *phy_config);
+typedef int (nr_ue_phy_config_request_f)(nr_phy_config_t *phy_config);
 
 
 /*
@@ -142,7 +157,7 @@ typedef int8_t (nr_ue_phy_config_request_f)(nr_phy_config_t *phy_config);
  *  -1: Failed to consume bytes. Abort the mission.
  * Non-negative return values indicate success, and ignored.
  */
-typedef int8_t (nr_ue_dl_indication_f)(nr_downlink_indication_t *dl_info);
+typedef int (nr_ue_dl_indication_f)(nr_downlink_indication_t *dl_info);
 
 /*
  * Generic type of an application-defined callback to return various
@@ -151,19 +166,21 @@ typedef int8_t (nr_ue_dl_indication_f)(nr_downlink_indication_t *dl_info);
  *  -1: Failed to consume bytes. Abort the mission.
  * Non-negative return values indicate success, and ignored.
  */
-typedef int8_t (nr_ue_ul_indication_f)(nr_uplink_indication_t *ul_info);
+typedef int (nr_ue_ul_indication_f)(nr_uplink_indication_t *ul_info);
+
+typedef int (nr_ue_dcireq_f)(nr_dcireq_t *ul_info);
 
 //  TODO check this stuff can be reuse of need modification
 typedef struct nr_ue_if_module_s {
-    nr_ue_scheduled_response_f *scheduled_response;
-    nr_ue_phy_config_request_f *phy_config_request;
-    nr_ue_dl_indication_f      *dl_indication;
-    nr_ue_ul_indication_f      *ul_indication;
-
-    uint32_t cc_mask;
-    uint32_t current_frame;
-    uint32_t current_slot;
-    //pthread_mutex_t nr_if_mutex;
+  nr_ue_scheduled_response_f *scheduled_response;
+  nr_ue_phy_config_request_f *phy_config_request;
+  nr_ue_dl_indication_f      *dl_indication;
+  nr_ue_ul_indication_f      *ul_indication;
+  nr_ue_dcireq_f             *dcireq;
+  uint32_t cc_mask;
+  uint32_t current_frame;
+  uint32_t current_slot;
+  //pthread_mutex_t nr_if_mutex;
 } nr_ue_if_module_t;
 
 
@@ -174,14 +191,16 @@ nr_ue_if_module_t *nr_ue_if_module_init(uint32_t module_id);
 
 /**\brief done free of memory allocation by module_id and release to pointer pool.
    \param module_id module id*/
-int8_t nr_ue_if_module_kill(uint32_t module_id);
+int nr_ue_if_module_kill(uint32_t module_id);
 
 
 /**\brief interface between L1/L2, indicating the downlink related information, like dci_ind and rx_req
    \param dl_info including dci_ind and rx_request messages*/
-int8_t nr_ue_dl_indication(nr_downlink_indication_t *dl_info);
+int nr_ue_dl_indication(nr_downlink_indication_t *dl_info);
 
-int8_t nr_ue_ul_indication(nr_uplink_indication_t *ul_info);
+int nr_ue_ul_indication(nr_uplink_indication_t *ul_info);
+
+int nr_ue_dcireq(nr_dcireq_t *dcireq);
 
 //  TODO check
 /**\brief handle BCCH-BCH message from dl_indication
@@ -190,15 +209,15 @@ int8_t nr_ue_ul_indication(nr_uplink_indication_t *ul_info);
    \param ssb_index       SSB index within 0 - (L_ssb-1) corresponding to 38.331 ch.13 parameter i
    \param ssb_length      corresponding to L1 parameter L_ssb 
    \param cell_id         cell id */
-int8_t handle_bcch_bch(module_id_t module_id, int cc_id, uint8_t gNB_index, uint8_t *pduP, uint8_t additional_bits, uint32_t ssb_index, uint32_t ssb_length, uint16_t cell_id);
+int handle_bcch_bch(module_id_t module_id, int cc_id, unsigned int gNB_index, uint8_t *pduP, unsigned int additional_bits, uint32_t ssb_index, uint32_t ssb_length, uint16_t cell_id);
 
 //  TODO check
 /**\brief handle BCCH-DL-SCH message from dl_indication
    \param pdu_len   length(bytes) of pdu
    \param pduP      pointer to pdu*/
-int8_t handle_bcch_dlsch(module_id_t module_id, int cc_id, uint8_t gNB_index, uint32_t sibs_mask, uint8_t *pduP, uint32_t pdu_len);
+int handle_bcch_dlsch(module_id_t module_id, int cc_id, unsigned int gNB_index, uint32_t sibs_mask, uint8_t *pduP, uint32_t pdu_len);
 
-int8_t handle_dci(module_id_t module_id, int cc_id, uint8_t gNB_index, fapi_nr_dci_pdu_rel15_t *dci, uint16_t rnti, uint32_t dci_type);
+int handle_dci(module_id_t module_id, int cc_id, unsigned int gNB_index, fapi_nr_dci_pdu_rel15_t *dci, uint16_t rnti, uint32_t dci_type);
 
 #endif
 

targets/COMMON/threads_t.h

@@ -2,6 +2,7 @@
 #define _THREADS_T_H_
 
 typedef struct threads_s {
+    int main;
     int iq;
     int one;
     int two;

targets/PROJECTS/GENERIC-LTE-EPC/CONF/enb.band7.tm1.100PRB.usrpx310.conf

@@ -147,13 +147,13 @@ eNBs =
 
     NETWORK_INTERFACES :
     {
-        ENB_INTERFACE_NAME_FOR_S1_MME            = "eth6";
-        ENB_IPV4_ADDRESS_FOR_S1_MME              = "192.168.12.111/24";
-        ENB_INTERFACE_NAME_FOR_S1U               = "eth6";
-        ENB_IPV4_ADDRESS_FOR_S1U                 = "192.168.12.111/24";
+        ENB_INTERFACE_NAME_FOR_S1_MME            = "enp0s20f0u11";
+        ENB_IPV4_ADDRESS_FOR_S1_MME              = "192.168.12.110/24";
+        ENB_INTERFACE_NAME_FOR_S1U               = "enp0s20f0u11";
+        ENB_IPV4_ADDRESS_FOR_S1U                 = "192.168.12.110/24";
         ENB_PORT_FOR_S1U                         = 2152; # Spec 2152
 
-        ENB_IPV4_ADDRESS_FOR_X2C                 = "192.168.12.111/24";
+        ENB_IPV4_ADDRESS_FOR_X2C                 = "192.168.12.110/24";
         ENB_PORT_FOR_X2C                         = 36422; # Spec 36422
     };
   }
@@ -187,7 +187,7 @@ RUs = (
          max_pdschReferenceSignalPower = -27;
          max_rxgain                    = 116;
          eNB_instances  = [0];
-
+	 sdr_addrs = "addr=192.168.10.2,mgmt_addr=192.168.100.8,clock_src=external";
     }
 );  
 

targets/PROJECTS/GENERIC-LTE-EPC/CONF/gnb.band78.tm1.106PRB.usrpn300.conf

@@ -29,7 +29,7 @@ gNBs =
       frame_type                                                    = "FDD";
       DL_prefix_type                                                = "NORMAL";
       UL_prefix_type                                                = "NORMAL";
-      eutra_band                                                    = 22;
+      eutra_band                                                    = 78;
       downlink_frequency                                            = 3510000000L;
       uplink_frequency_offset                                       = -120000000;
       Nid_cell                                                      = 0;
@@ -254,21 +254,21 @@ RUs = (
          max_pdschReferenceSignalPower = -27;
          max_rxgain                    = 114;
          eNB_instances  = [0];
-	 sdr_addrs = "addr=192.168.10.2,second_addr=192.168.20.2,mgmt_addr=192.168.100.8";
-
+	 sdr_addrs = "addr=192.168.10.2,mgmt_addr=192.168.100.8,clock_src=external,time_src=external";
+	 #clock_src = "external";	 
     }
 );  
 
 THREAD_STRUCT = (
   {
     #three config for level of parallelism "PARALLEL_SINGLE_THREAD", "PARALLEL_RU_L1_SPLIT", or "PARALLEL_RU_L1_TRX_SPLIT"
-    parallel_config    = "PARALLEL_SINGLE_THREAD";
+    parallel_config    = "PARALLEL_RU_L1_TRX_SPLIT";
     #two option for worker "WORKER_DISABLE" or "WORKER_ENABLE"
-    worker_config      = "WORKER_DISABLE";
+    worker_config      = "WORKER_ENABLE";
   }
 );
 
-NETWORK_CONTROLLER :
+nETWORK_CONTROLLER :
 {
     FLEXRAN_ENABLED        = "no";
     FLEXRAN_INTERFACE_NAME = "lo";

targets/RT/USER/lte-ue.c

@@ -1514,9 +1514,9 @@ void *UE_thread(void *arg) {
 				       UE->frame_parms.nb_antennas_rx);
 	}
 #endif
-	}
+      }
 
-        } // UE->is_synchronized==0
+    } // UE->is_synchronized==0
         else {
             if (start_rx_stream==0) {
                 start_rx_stream=1;

targets/RT/USER/lte-uesoftmodem.c

@@ -500,7 +500,7 @@ static void get_options(unsigned int *start_msc) {
   int CC_id;
   int tddflag, nonbiotflag;
   char *loopfile=NULL;
-  int dumpframe;
+  int dumpframe = 0;
   uint32_t online_log_messages;
   uint32_t glog_level;
   uint32_t start_telnetsrv;

targets/RT/USER/nr-ru.c

@@ -1499,7 +1499,7 @@ static void* ru_thread( void* param ) {
   int                ret;
   int                subframe =9;
   int                frame    =1023; 
-  char               filename[40];
+  char               filename[40],threadname[40];
   int                print_frame = 2;
   int                i = 0;
 
@@ -1508,7 +1508,8 @@ static void* ru_thread( void* param ) {
 
 
   // set default return value
-  thread_top_init("ru_thread",0,870000,1000000,1000000);
+  sprintf(threadname,"ru_thread %d",ru->idx);
+  thread_top_init(threadname,0,870000,1000000,1000000);
 
   LOG_I(PHY,"Starting RU %d (%s,%s),\n",ru->idx,NB_functions[ru->function],NB_timing[ru->if_timing]);
 

targets/RT/USER/nr-ue.c

@@ -681,11 +681,20 @@ static void *UE_thread_rxn_txnp4(void *arg) {
             UE->dci_ind.number_of_dcis = 0;
             //clean previous FAPI MESSAGE
 
+	    // call L2 for DL_CONFIG (DCI)
+	    UE->dcireq.module_id = UE->Mod_id;
+	    UE->dcireq.gNB_index = 0;
+	    UE->dcireq.cc_id     = 0;
+	    UE->dcireq.frame     = proc->frame_rx;
+	    UE->dcireq.slot      = proc->nr_tti_rx;
+	    //UE->if_inst->dcireq(&UE->dcireq);
+
 #ifdef UE_SLOT_PARALLELISATION
             phy_procedures_slot_parallelization_nrUE_RX( UE, proc, 0, 0, 1, UE->mode, no_relay, NULL );
 #else
-            phy_procedures_nrUE_RX( UE, proc, 0, 0, 1, UE->mode, no_relay);
-            //printf(">>> nr_ue_pdcch_procedures ended\n");
+            phy_procedures_nrUE_RX( UE, proc, 0, 1, UE->mode);
+            printf(">>> nr_ue_pdcch_procedures ended\n");
+
 #endif
         }
 
@@ -900,7 +909,7 @@ void *UE_thread(void *arg) {
                     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);
+		      //LOG_I(PHY,"Reading dummy sf %d\n",sf);
 		      AssertFatal(UE->frame_parms.samples_per_subframe==
 				 UE->rfdevice.trx_read_func(&UE->rfdevice,
 							    &timestamp,
@@ -997,7 +1006,7 @@ void *UE_thread(void *arg) {
                                 UE->rx_offset < 10*UE->frame_parms.samples_per_subframe )
                             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,subframe_nr,UE->rx_offset_diff,UE->rx_offset);
+                        LOG_I(PHY,"AbsSubframe %d.%d TTI SET rx_off_diff to %d rx_offset %d \n",proc->frame_rx,subframe_nr,UE->rx_offset_diff,UE->rx_offset);
                         readBlockSize=UE->frame_parms.samples_per_subframe -
                                       UE->frame_parms.ofdm_symbol_size -
                                       UE->frame_parms.nb_prefix_samples0 -
@@ -1139,7 +1148,7 @@ void *UE_thread(void *arg) {
 		      UE->if_inst->ul_indication(&UE->ul_indication);
 		    }
 
-		    phy_procedures_nrUE_RX( UE, proc, 0, 0, 1, UE->mode, no_relay);
+		    phy_procedures_nrUE_RX( UE, proc, 0, 1, UE->mode);
 		    getchar();
 		} // else loop_through_memory
             } // start_rx_stream==1

targets/RT/USER/nr-uesoftmodem.c

@@ -85,10 +85,10 @@ unsigned short config_frames[4] = {2,9,11,13};
 // current status is that every UE has a DL scope for a SINGLE eNB (eNB_id=0)
 // at eNB 0, an UL scope for every UE
 FD_lte_phy_scope_ue  *form_ue[NUMBER_OF_UE_MAX];
-FD_lte_phy_scope_enb *form_enb[MAX_NUM_CCs][NUMBER_OF_UE_MAX];
-FD_stats_form                  *form_stats=NULL,*form_stats_l2=NULL;
+//FD_lte_phy_scope_enb *form_enb[MAX_NUM_CCs][NUMBER_OF_UE_MAX];
+//FD_stats_form                  *form_stats=NULL,*form_stats_l2=NULL;
 char title[255];
-unsigned char                   scope_enb_num_ue = 2;
+//unsigned char                   scope_enb_num_ue = 2;
 static pthread_t                forms_thread; //xforms
 #endif //XFORMS
 #include "nr-uesoftmodem.h"
@@ -268,7 +268,7 @@ char uecap_xer[1024],uecap_xer_in=0;
 int oaisim_flag=0;
 int emulate_rf = 0;
 
-threads_t threads= {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
+threads_t threads= {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
 
 char* usrp_args=NULL;
 char* usrp_clksrc=NULL;
@@ -440,8 +440,8 @@ static void *scope_thread(void *arg) {
   while (!oai_exit) {
       //len = dump_ue_stats (PHY_vars_UE_g[0][0], &PHY_vars_UE_g[0][0]->proc.proc_rxtx[0],stats_buffer, 0, mode,rx_input_level_dBm);
       //fl_set_object_label(form_stats->stats_text, stats_buffer);
-      fl_clear_browser(form_stats->stats_text);
-      fl_add_browser_line(form_stats->stats_text, stats_buffer);
+      //fl_clear_browser(form_stats->stats_text);
+      //fl_add_browser_line(form_stats->stats_text, stats_buffer);
       
       //if (PHY_vars_UE_g[0][0]->is_synchronized == 1)
 	phy_scope_UE(form_ue[0],
@@ -451,7 +451,7 @@ static void *scope_thread(void *arg) {
       
       //printf("doing forms\n");
       //usleep(100000); // 100 ms
-      sleep(1);
+      sleep(0.1);
     }
 
     //  printf("%s",stats_buffer);
@@ -1030,7 +1030,20 @@ int main( int argc, char **argv ) {
   
   init_openair0();
   
-
+  threads.main = 16;
+  threads.iq   = 17;
+  threads.one  = 18;
+  threads.two  = 19;
+  threads.three = 20;
+  threads.slot1_proc_one = 21;
+  threads.slot1_proc_two = 22;
+  threads.slot1_proc_three = 23;
+  threads.dlsch_td_one = 24;
+  threads.dlsch_td_two = 25;
+  threads.dlsch_td_three = 26;
+  threads.dlsch_td1_one = 27;
+  threads.dlsch_td1_two = 28;
+  threads.dlsch_td1_three = 29;
 
 #ifndef DEADLINE_SCHEDULER
 
@@ -1042,7 +1055,7 @@ int main( int argc, char **argv ) {
     CPU_ZERO(&cpuset);
 #ifdef CPU_AFFINITY
     if (get_nprocs() > 2) {
-        CPU_SET(0, &cpuset);
+        CPU_SET(threads.main, &cpuset);
         s = pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
         if (s != 0) {
             perror( "pthread_setaffinity_np");
@@ -1127,8 +1140,8 @@ int main( int argc, char **argv ) {
     fl_initialize (&fl_argc, argv, NULL, 0, 0);
     // restore the original command line args
     // argv = fl_get_cmdline_args( &argc );
-    form_stats = create_form_stats_form();
-    fl_show_form (form_stats->stats_form, FL_PLACE_HOTSPOT, FL_FULLBORDER, "stats");
+    //form_stats = create_form_stats_form();
+    //fl_show_form (form_stats->stats_form, FL_PLACE_HOTSPOT, FL_FULLBORDER, "stats");
     UE_id = 0;
     form_ue[UE_id] = create_lte_phy_scope_ue();
     sprintf (title, "NR DL SCOPE UE");
@@ -1218,8 +1231,8 @@ int main( int argc, char **argv ) {
 
   if (do_forms==1) {
     pthread_join(forms_thread,&status);
-    fl_hide_form(form_stats->stats_form);
-    fl_free_form(form_stats->stats_form);
+    //fl_hide_form(form_stats->stats_form);
+    //fl_free_form(form_stats->stats_form);
     fl_hide_form(form_ue[0]->lte_phy_scope_ue);
     fl_free_form(form_ue[0]->lte_phy_scope_ue);
   }

targets/RT/USER/nr-uesoftmodem.h

@@ -157,12 +157,13 @@
 {"external-clock",          CONFIG_HLP_EXCCLK,      PARAMFLAG_BOOL,         uptr:&clock_source,                 defintval:0,                    TYPE_INT,       0},                     \
 {"wait-for-sync",           NULL,                   PARAMFLAG_BOOL,         iptr:&wait_for_sync,                defintval:0,                    TYPE_INT,       0},                     \
 {"single-thread-disable",   CONFIG_HLP_NOSNGLT,     PARAMFLAG_BOOL,         iptr:&single_thread_flag,           defintval:1,                    TYPE_INT,       0},                     \
-{"threadIQ",                NULL,                   0,                      iptr:&(threads.iq),                 defintval:1,                    TYPE_INT,       0},                     \
-{"threadOneSubframe",       NULL,                   0,                      iptr:&(threads.one),                defintval:1,                    TYPE_INT,       0},                     \
-{"threadTwoSubframe",       NULL,                   0,                      iptr:&(threads.two),                defintval:1,                    TYPE_INT,       0},                     \
-{"threadThreeSubframe",     NULL,                   0,                      iptr:&(threads.three),              defintval:1,                    TYPE_INT,       0},                     \
-{"threadSlot1ProcOne",      NULL,                   0,                      iptr:&(threads.slot1_proc_one),     defintval:1,                    TYPE_INT,       0},                     \
-{"threadSlot1ProcTwo",      NULL,                   0,                      iptr:&(threads.slot1_proc_two),     defintval:1,                    TYPE_INT,       0},                     \
+{"threadmain",                NULL,                   0,                      iptr:&(threads.main),              defintval:-1,                    TYPE_INT,       0},                     \
+{"threadIQ",                NULL,                   0,                      iptr:&(threads.iq),                 defintval:-1,                    TYPE_INT,       0},                     \
+{"threadOneSubframe",       NULL,                   0,                      iptr:&(threads.one),                defintval:-1,                    TYPE_INT,       0},                     \
+{"threadTwoSubframe",       NULL,                   0,                      iptr:&(threads.two),                defintval:-1,                    TYPE_INT,       0},                     \
+{"threadThreeSubframe",     NULL,                   0,                      iptr:&(threads.three),              defintval:-1,                    TYPE_INT,       0},                     \
+{"threadSlot1ProcOne",      NULL,                   0,                      iptr:&(threads.slot1_proc_one),     defintval:-1,                    TYPE_INT,       0},                     \
+{"threadSlot1ProcTwo",      NULL,                   0,                      iptr:&(threads.slot1_proc_two),     defintval:-1,                    TYPE_INT,       0},                     \
 {"nr_dlsch-demod-shift",    CONFIG_HLP_DLSHIFT,     0,                      iptr:(int32_t *)&nr_dlsch_demod_shift, defintval:0,                    TYPE_INT,       0},                     \
 {"A" ,                      CONFIG_HLP_TADV,        0,                      uptr:&timing_advance,               defintval:0,                    TYPE_UINT,      0},                     \
 {"C" ,                      CONFIG_HLP_DLF,         0,                      uptr:&(downlink_frequency[0][0]),   defuintval:2680000000,          TYPE_UINT,      0},                     \