renaming variable name in ccoding_byte_NB_IoT.c, renaming function of...

renaming variable name in ccoding_byte_NB_IoT.c,  renaming function of lte_rate_matching_NB_IoT.c, adding new file:crc_byte_NB_IoT.c, adding missing functions to defs_nb_iot.h

openair1/PHY/CODING/ccoding_byte_NB_IoT.c

@@ -17,7 +17,7 @@
 #include "defs_nb_iot.h"
 
 unsigned char  ccodelte_table_NB_IoT[128];      // for transmitter
-unsigned short glte_NB[] = { 0133, 0171, 0165 }; // {A,B} //renaimed but is exactly the same as the one in the old implementation
+unsigned short glte_NB_IoT[] = { 0133, 0171, 0165 }; // {A,B} //renaimed but is exactly the same as the one in the old implementation
 //unsigned char  ccodelte_table_rev[128];  // for receiver
 
 /*************************************************************************
@@ -129,7 +129,7 @@ void ccodelte_init_NB_IoT(void)
       sum = 0;
 
       for (k = 0; k < 7; k++)
-        if ((i & glte_NB[j]) & (1 << k))
+        if ((i & glte_NB_IoT[j]) & (1 << k))
           sum++;
 
       /* Write the sum modulo 2 in bit j */

openair1/PHY/CODING/crc_byte_NB_IoT.c

+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+/* file: crc_byte.c
+   purpose: generate 3GPP LTE CRCs. Byte-oriented implementation of CRC's
+   author: raymond.knopp@eurecom.fr, matthieu.kanj@b-com.com
+   date: 07/2017
+
+*/
+
+
+#ifndef USER_MODE
+#define __NO_VERSION__
+
+#endif
+
+//#include "PHY/types.h"
+
+#include "defs.h"   // to delete in final code version
+
+#include "defs_nb_iot.h"  //
+/*ref 36-212 v8.6.0 , pp 8-9 */
+/* the highest degree is set by default */
+unsigned int             poly24a = 0x864cfb00;   //1000 0110 0100 1100 1111 1011  D^24 + D^23 + D^18 + D^17 + D^14 + D^11 + D^10 + D^7 + D^6 + D^5 + D^4 + D^3 + D + 1
+unsigned int             poly24b = 0x80006300;    // 1000 0000 0000 0000 0110 0011  D^24 + D^23 + D^6 + D^5 + D + 1
+unsigned int             poly16 = 0x10210000;    // 0001 0000 0010 0001            D^16 + D^12 + D^5 + 1
+unsigned int             poly12 = 0x80F00000;    // 1000 0000 1111                 D^12 + D^11 + D^3 + D^2 + D + 1
+unsigned int             poly8 = 0x9B000000;     // 1001 1011                      D^8  + D^7  + D^4 + D^3 + D + 1
+/*********************************************************
+
+For initialization && verification purposes,
+   bit by bit implementation with any polynomial
+
+The first bit is in the MSB of each byte
+
+*********************************************************/
+unsigned int
+crcbit_NB_IoT (unsigned char * inputptr, int octetlen, unsigned int poly)
+{
+  unsigned int             i, crc = 0, c;
+
+  while (octetlen-- > 0) {
+    c = (*inputptr++) << 24;
+
+    for (i = 8; i != 0; i--) {
+      if ((1 << 31) & (c ^ crc))
+        crc = (crc << 1) ^ poly;
+      else
+        crc <<= 1;
+
+      c <<= 1;
+    }
+  }
+
+  return crc;
+}
+
+/*********************************************************
+
+crc table initialization
+
+*********************************************************/
+static unsigned int      crc24aTable[256];
+static unsigned int      crc24bTable[256];
+static unsigned short      crc16Table[256];
+static unsigned short      crc12Table[256];
+static unsigned char       crc8Table[256];
+
+void crcTableInit_NB_IoT (void)
+{
+  unsigned char              c = 0;
+
+  do {
+    crc24aTable[c] = crcbit (&c, 1, poly24a);
+    crc24bTable[c] = crcbit (&c, 1, poly24b);
+    crc16Table[c] = (unsigned short) (crcbit (&c, 1, poly16) >> 16);
+    crc12Table[c] = (unsigned short) (crcbit (&c, 1, poly12) >> 16);
+    crc8Table[c] = (unsigned char) (crcbit (&c, 1, poly8) >> 24);
+  } while (++c);
+}
+/*********************************************************
+
+Byte by byte implementations,
+assuming initial byte is 0 padded (in MSB) if necessary
+
+*********************************************************/
+unsigned int
+crc24a_NB_IoT (unsigned char * inptr, int bitlen)
+{
+
+  int             octetlen, resbit;
+  unsigned int             crc = 0;
+  octetlen = bitlen / 8;        /* Change in octets */
+  resbit = (bitlen % 8);
+
+  while (octetlen-- > 0) {
+    //    printf("in %x => crc %x\n",crc,*inptr);
+    crc = (crc << 8) ^ crc24aTable[(*inptr++) ^ (crc >> 24)];
+  }
+
+  if (resbit > 0)
+    crc = (crc << resbit) ^ crc24aTable[((*inptr) >> (8 - resbit)) ^ (crc >> (32 - resbit))];
+
+  return crc;
+}
+
+unsigned int crc24b_NB_IoT (unsigned char * inptr, int bitlen)
+{
+
+  int             octetlen, resbit;
+  unsigned int             crc = 0;
+  octetlen = bitlen / 8;        /* Change in octets */
+  resbit = (bitlen % 8);
+
+  while (octetlen-- > 0) {
+    crc = (crc << 8) ^ crc24bTable[(*inptr++) ^ (crc >> 24)];
+  }
+
+  if (resbit > 0)
+    crc = (crc << resbit) ^ crc24bTable[((*inptr) >> (8 - resbit)) ^ (crc >> (32 - resbit))];
+
+  return crc;
+}
+
+unsigned int
+crc16_NB_IoT (unsigned char * inptr, int bitlen)
+{
+  int             octetlen, resbit;
+  unsigned int             crc = 0;
+  octetlen = bitlen / 8;        /* Change in octets */
+  resbit = (bitlen % 8);
+
+  while (octetlen-- > 0) {
+
+    crc = (crc << 8) ^ (crc16Table[(*inptr++) ^ (crc >> 24)] << 16);
+  }
+
+  if (resbit > 0)
+    crc = (crc << resbit) ^ (crc16Table[((*inptr) >> (8 - resbit)) ^ (crc >> (32 - resbit))] << 16);
+
+  return crc;
+}
+
+
+#ifdef DEBUG_CRC
+/*******************************************************************/
+/**
+   Test code
+********************************************************************/
+
+// #include <stdio.h>
+
+// main()
+// {
+//   unsigned char test[] = "Thebigredfox";
+//   crcTableInit();
+//   printf("%x\n", crcbit(test, sizeof(test) - 1, poly24));
+//   printf("%x\n", crc24(test, (sizeof(test) - 1)*8));
+//   printf("%x\n", crcbit(test, sizeof(test) - 1, poly8));
+//   printf("%x\n", crc8(test, (sizeof(test) - 1)*8));
+// }
+#endif
+

openair1/PHY/CODING/defs_nb_iot.h

@@ -21,7 +21,7 @@
 
 /* file: PHY/CODING/defs_nb_iot.h
    purpose: Top-level definitions, data types and function prototypes for openairinterface coding blocks for NB-IoT
-   author: raymond.knopp@eurecom.fr, michele.paffetti@studio.unibo.it
+   author: matthieu.kanj@b-com.com, raymond.knopp@eurecom.fr, michele.paffetti@studio.unibo.it
    date: 29.06.2017
 */
 
@@ -31,19 +31,142 @@
 #include <stdint.h>
 #include "PHY/defs.h"
 
+/** \fn uint32_t sub_block_interleaving_cc(uint32_t D, uint8_t *d,uint8_t *w)
+\brief This is the subblock interleaving algorithm for convolutionally coded blocks from 36-212 (Release 13.4, 2017).
+This function takes the d-sequence and generates the w-sequence.  The nu-sequence from 36-212 is implicit.
+\param D Number of input bits
+\param d Pointer to input (d-sequence, convolutional code output)
+\param w Pointer to output (w-sequence, interleaver output)
+\returns Interleaving matrix cardinality (\f$K_{\pi}\f$  from 36-212)
+*/
 uint32_t sub_block_interleaving_cc_NB_IoT(uint32_t D, uint8_t *d,uint8_t *w);
 
+/**
+\brief This is the NB-IoT rate matching algorithm for Convolutionally-coded channels (e.g. BCH,DCI,UCI).  It is taken directly from 36-212 (Rel 8 8.6, 2009-03), pages 16-18 )
+\param RCC R^CC_subblock from subblock interleaver (number of rows in interleaving matrix) for up to 8 segments
+\param E Number of coded channel bits
+\param w This is a pointer to the w-sequence (second interleaver output)
+\param e This is a pointer to the e-sequence (rate matching output, channel input/output bits)
+\returns \f$E\f$, the number of coded bits per segment */
+
 uint32_t lte_rate_matching_cc_NB_IoT(uint32_t RCC,      // RRC = 2
 				     uint16_t E,        // E = 1600
 				     uint8_t *w,	// length
 				     uint8_t *e);	// length 1600
 
+/** \fn void ccodelte_encode(int32_t numbits,uint8_t add_crc, uint8_t *inPtr,uint8_t *outPtr,uint16_t rnti)
+\brief This function implements the LTE convolutional code of rate 1/3
+  with a constraint length of 7 bits. The inputs are bit packed in octets
+(from MSB to LSB). Trellis tail-biting is included here.
+@param numbits Number of bits to encode
+@param add_crc crc to be appended (8 bits) if add_crc = 1
+@param inPtr Pointer to input buffer
+@param outPtr Pointer to output buffer
+@param rnti RNTI for CRC scrambling
+*/
+
 void ccode_encode_NB_IoT (int32_t numbits,
 						  uint8_t add_crc,
 						  uint8_t *inPtr,
 						  uint8_t *outPtr,
 						  uint16_t rnti);
 
+/*!\fn void ccodelte_init(void)
+\brief This function initializes the generator polynomials for an LTE convolutional code.*/
+void ccodelte_init_NB_IoT(void);
+
+/*!\fn void crcTableInit(void)
+\brief This function initializes the different crc tables.*/
+void crcTableInit_NB_IoT (void);
+
+
+/*!\fn uint32_t crc24a(uint8_t *inPtr, int32_t bitlen)
+\brief This computes a 24-bit crc ('a' variant for overall transport block)
+based on 3GPP UMTS/LTE specifications.
+@param inPtr Pointer to input byte stream
+@param bitlen length of inputs in bits
+*/
+uint32_t crc24a_NB_IoT (uint8_t *inPtr, int32_t bitlen);
+
+/*!\fn uint32_t crc24b(uint8_t *inPtr, int32_t bitlen)
+\brief This computes a 24-bit crc ('b' variant for transport-block segments)
+based on 3GPP UMTS/LTE specifications.
+@param inPtr Pointer to input byte stream
+@param bitlen length of inputs in bits
+*/
+uint32_t crc24b_NB_IoT (uint8_t *inPtr, int32_t bitlen);
+
+/*!\fn uint32_t crc16(uint8_t *inPtr, int32_t bitlen)
+\brief This computes a 16-bit crc based on 3GPP UMTS specifications.
+@param inPtr Pointer to input byte stream
+@param bitlen length of inputs in bits*/
+uint32_t crc16_NB_IoT (uint8_t *inPtr, int32_t bitlen);
+
+
+
+uint32_t crcbit_NB_IoT (uint8_t * ,
+                 int32_t,
+                 uint32_t);
+
+/** \fn void sub_block_deinterleaving_turbo(uint32_t D, int16_t *d,int16_t *w)
+\brief This is the subblock deinterleaving algorithm from 36-212 (Release 8, 8.6 2009-03), pages 15-16.
+This function takes the w-sequence and generates the d-sequence.  The nu-sequence from 36-212 is implicit.
+\param D Number of systematic bits plus 4 (plus 4 for termination)
+\param d Pointer to output (d-sequence, turbo code output)
+\param w Pointer to input (w-sequence, interleaver output)
+*/
+//*****************void sub_block_deinterleaving_turbo(uint32_t D, int16_t *d,int16_t *w);
+
+/**
+\brief This is the LTE rate matching algorithm for Turbo-coded channels (e.g. DLSCH,ULSCH).  It is taken directly from 36-212 (Rel 8 8.6, 2009-03), pages 16-18 )
+\param RTC R^TC_subblock from subblock interleaver (number of rows in interleaving matrix)
+\param G This the number of coded transport bits allocated in sub-frame
+\param w This is a pointer to the soft w-sequence (second interleaver output) with soft-combined outputs from successive HARQ rounds
+\param dummy_w This is the first row of the interleaver matrix for identifying/discarding the "LTE-NULL" positions
+\param soft_input This is a pointer to the soft channel output
+\param C Number of segments (codewords) in the sub-frame
+\param Nsoft Total number of soft bits (from UE capabilities in 36-306)
+\param Mdlharq Number of HARQ rounds
+\param Kmimo MIMO capability for this DLSCH (0 = no MIMO)
+\param rvidx round index (0-3)
+\param clear 1 means clear soft buffer (start of HARQ round)
+\param Qm modulation order (2,4,6)
+\param Nl number of layers (1,2)
+\param r segment number
+\param E_out the number of coded bits per segment
+\returns 0 on success, -1 on failure
+*/
+
+// int lte_rate_matching_turbo_rx(uint32_t RTC,
+//                                uint32_t G,
+//                                int16_t *w,
+//                                uint8_t *dummy_w,
+//                                int16_t *soft_input,
+//                                uint8_t C,
+//                                uint32_t Nsoft,
+//                                uint8_t Mdlharq,
+//                                uint8_t Kmimo,
+//                                uint8_t rvidx,
+//                                uint8_t clear,
+//                                uint8_t Qm,
+//                                uint8_t Nl,
+//                                uint8_t r,
+//                                uint32_t *E_out);
 
+// uint32_t lte_rate_matching_turbo_rx_abs(uint32_t RTC,
+//                                         uint32_t G,
+//                                         double *w,
+//                                         uint8_t *dummy_w,
+//                                         double *soft_input,
+//                                         uint8_t C,
+//                                         uint32_t Nsoft,
+//                                         uint8_t Mdlharq,
+//                                         uint8_t Kmimo,
+//                                         uint8_t rvidx,
+//                                         uint8_t clear,
+//                                         uint8_t Qm,
+//                                         uint8_t Nl,
+//                                         uint8_t r,
+//                                         uint32_t *E_out);
 
 #endif /* OPENAIR1_PHY_CODING_DEFS_NB_IOT_H_ */

openair1/PHY/CODING/lte_rate_matching_NB_IoT.c

@@ -19,9 +19,9 @@
 #include "PHY/defs.h"
 #include "assertions.h"
 
-#include "PHY/LTE_REFSIG/defs_NB_IoT.h"
+#include "PHY/LTE_REFSIG/defs_NB_IoT.h"   // does this file is needed ?
 
-static uint32_t bitrev_cc[32] = {1,17,9,25,5,21,13,29,3,19,11,27,7,23,15,31,0,16,8,24,4,20,12,28,2,18,10,26,6,22,14,30};
+static uint32_t bitrev_cc_NB_IoT[32] = {1,17,9,25,5,21,13,29,3,19,11,27,7,23,15,31,0,16,8,24,4,20,12,28,2,18,10,26,6,22,14,30};
 
 uint32_t sub_block_interleaving_cc_NB_IoT(uint32_t D, uint8_t *d,uint8_t *w)
 {
@@ -39,7 +39,7 @@ uint32_t sub_block_interleaving_cc_NB_IoT(uint32_t D, uint8_t *d,uint8_t *w)
 
   for (col=0; col<32; col++) {
 
-    index = bitrev_cc[col];
+    index = bitrev_cc_NB_IoT[col];
     index3 = 3*index;
 
     for (row=0; row<RCC; row++) {