crc_byte.c 8.93 KB
Newer Older
1 2 3 4 5
/*
 * 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
6
 * the OAI Public License, Version 1.1  (the "License"); you may not use this file
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
 * 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
 */

22 23 24
/* file: crc_byte.c
   purpose: generate 3GPP LTE CRCs. Byte-oriented implementation of CRC's
   author: raymond.knopp@eurecom.fr
25
   date: 21.10.2009
26 27 28 29 30 31 32 33

   Original UMTS version by
   P. Humblet
   May 10, 2001
   Modified in June, 2001, to include  the length non multiple of 8
*/


34
#include "coding_defs.h"
35 36 37

/*ref 36-212 v8.6.0 , pp 8-9 */
/* the highest degree is set by default */
Guy De Souza's avatar
Guy De Souza committed
38

yilmazt's avatar
yilmazt committed
39 40 41 42 43 44
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             poly24c = 0xb2b11700;   // 1011 0010 1011 0001 0001 0111
												 // D^24+D^23+D^21+D^20+D^17+D^15+D^13+D^12+D^8+D^4+D^2+D+1
Guy De Souza's avatar
Guy De Souza committed
45

46 47 48
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
49 50 51
uint32_t poly6 = 0x84000000; // 10000100000... -> D^6+D^5+1
uint32_t poly11 = 0xc4200000; //11000100001000... -> D^11+D^10+D^9+D^5+1

52 53
/*********************************************************

54
For initialization && verification purposes,
55 56 57 58 59
   bit by bit implementation with any polynomial

The first bit is in the MSB of each byte

*********************************************************/
yilmazt's avatar
yilmazt committed
60 61 62
unsigned int crcbit (unsigned char * inputptr,
					 int octetlen,
					 unsigned int poly)
63
{
yilmazt's avatar
yilmazt committed
64
  unsigned int i, crc = 0, c;
65

66 67
  while (octetlen-- > 0) {
    c = (*inputptr++) << 24;
68

69 70 71 72 73
    for (i = 8; i != 0; i--) {
      if ((1 << 31) & (c ^ crc))
        crc = (crc << 1) ^ poly;
      else
        crc <<= 1;
74

75 76 77
      c <<= 1;
    }
  }
78

79 80 81 82 83 84 85 86
  return crc;
}

/*********************************************************

crc table initialization

*********************************************************/
yilmazt's avatar
yilmazt committed
87 88 89
static unsigned int        crc24aTable[256];
static unsigned int        crc24bTable[256];
static unsigned int        crc24cTable[256];
90 91 92 93 94 95
static unsigned short      crc16Table[256];
static unsigned short      crc12Table[256];
static unsigned char       crc8Table[256];

void crcTableInit (void)
{
yilmazt's avatar
yilmazt committed
96
  unsigned char c = 0;
97

98 99 100
  do {
    crc24aTable[c] = crcbit (&c, 1, poly24a);
    crc24bTable[c] = crcbit (&c, 1, poly24b);
yilmazt's avatar
yilmazt committed
101
    crc24cTable[c] = crcbit (&c, 1, poly24c);
102 103 104 105 106
    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);
}
107 108 109 110 111 112 113 114 115 116 117 118

//Generic version
void crcTable256Init (uint32_t poly, uint32_t* crc256Table)
{
        unsigned char c = 0;

        do {
                crc256Table[c] = crcbit(&c, 1, poly);
        } while (++c);

}

119 120
/*********************************************************

121
Byte by byte implementations,
122 123 124
assuming initial byte is 0 padded (in MSB) if necessary

*********************************************************/
yilmazt's avatar
yilmazt committed
125 126
unsigned int crc24a (unsigned char * inptr,
					 int bitlen)
127 128 129 130 131 132
{

  int             octetlen, resbit;
  unsigned int             crc = 0;
  octetlen = bitlen / 8;        /* Change in octets */
  resbit = (bitlen % 8);
133

134
  while (octetlen-- > 0) {
knopp's avatar
knopp committed
135
    //   printf("crc24a: in %x => crc %x\n",crc,*inptr);
136 137
    crc = (crc << 8) ^ crc24aTable[(*inptr++) ^ (crc >> 24)];
  }
138

139 140
  if (resbit > 0)
    crc = (crc << resbit) ^ crc24aTable[((*inptr) >> (8 - resbit)) ^ (crc >> (32 - resbit))];
141

142 143 144
  return crc;
}

yilmazt's avatar
yilmazt committed
145 146
unsigned int crc24b (unsigned char * inptr,
					 int bitlen)
147
{
yilmazt's avatar
yilmazt committed
148 149
  int octetlen, resbit;
  unsigned int crc = 0;
150 151
  octetlen = bitlen / 8;        /* Change in octets */
  resbit = (bitlen % 8);
152

153
  while (octetlen-- > 0) {
knopp's avatar
knopp committed
154
    //    printf("crc24b: in %x => crc %x (%x)\n",crc,*inptr,crc24bTable[(*inptr) ^ (crc >> 24)]);
155 156
    crc = (crc << 8) ^ crc24bTable[(*inptr++) ^ (crc >> 24)];
  }
157

158 159
  if (resbit > 0)
    crc = (crc << resbit) ^ crc24bTable[((*inptr) >> (8 - resbit)) ^ (crc >> (32 - resbit))];
160

161 162 163
  return crc;
}

yilmazt's avatar
yilmazt committed
164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184
unsigned int crc24c (unsigned char * inptr,
					 int bitlen)
{
  int octetlen, resbit;
  unsigned int crc = 0;
  octetlen = bitlen / 8;        /* Change in octets */
  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)
    crc = (crc << resbit) ^ crc24cTable[((*inptr) >> (8 - resbit)) ^ (crc >> (32 - resbit))];

  return crc;
}

185 186 187 188 189 190 191
unsigned int
crc16 (unsigned char * inptr, int bitlen)
{
  int             octetlen, resbit;
  unsigned int             crc = 0;
  octetlen = bitlen / 8;        /* Change in octets */
  resbit = (bitlen % 8);
192

193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210
  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;
}

unsigned int
crc12 (unsigned char * inptr, int bitlen)
{
  int             octetlen, resbit;
  unsigned int             crc = 0;
  octetlen = bitlen / 8;        /* Change in octets */
  resbit = (bitlen % 8);
211

212 213 214
  while (octetlen-- > 0) {
    crc = (crc << 8) ^ (crc12Table[(*inptr++) ^ (crc >> 24)] << 16);
  }
215

216 217
  if (resbit > 0)
    crc = (crc << resbit) ^ (crc12Table[((*inptr) >> (8 - resbit)) ^ (crc >> (32 - resbit))] << 16);
218

219 220 221 222 223 224 225 226 227 228
  return crc;
}

unsigned int
crc8 (unsigned char * inptr, int bitlen)
{
  int             octetlen, resbit;
  unsigned int             crc = 0;
  octetlen = bitlen / 8;        /* Change in octets */
  resbit = (bitlen % 8);
229

230 231 232
  while (octetlen-- > 0) {
    crc = crc8Table[(*inptr++) ^ (crc >> 24)] << 24;
  }
233

234 235
  if (resbit > 0)
    crc = (crc << resbit) ^ (crc8Table[((*inptr) >> (8 - resbit)) ^ (crc >> (32 - resbit))] << 24);
236

237 238 239
  return crc;
}

240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259
//Generic version
unsigned int crcPayload(unsigned char * inptr, int bitlen, uint32_t* crc256Table)
{
        int octetlen, resbit;
        unsigned int crc = 0;
        octetlen = bitlen/8; // Change in bytes
        resbit = (bitlen % 8);

        while (octetlen-- > 0)
        {
                crc = (crc << 8) ^ crc256Table[(*inptr++) ^ (crc >> 24)];
        }

        if (resbit > 0)
        {
                crc = (crc << resbit) ^ crc256Table[((*inptr) >> (8 - resbit)) ^ (crc >> (32 - resbit))];
        }
        return crc;
}

260 261
int check_crc(uint8_t* decoded_bytes, uint32_t n, uint32_t F, uint8_t crc_type)
{
Guy De Souza's avatar
Guy De Souza committed
262
  uint32_t crc=0,oldcrc=0;
263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282
  uint8_t crc_len,temp;

  switch (crc_type) {
  case CRC24_A:
  case CRC24_B:
    crc_len=3;
    break;

  case CRC16:
    crc_len=2;
    break;

  case CRC8:
    crc_len=1;
    break;

  default:
    crc_len=3;
  }

Guy De Souza's avatar
Guy De Souza committed
283 284
  for (int i=0; i<crc_len; i++)
    oldcrc |= (decoded_bytes[(n>>3)-crc_len+i])<<((crc_len-1-i)<<3);
285 286 287 288 289

  switch (crc_type) {
    
  case CRC24_A:
    oldcrc&=0x00ffffff;
Guy De Souza's avatar
Guy De Souza committed
290 291
    crc = crc24a(decoded_bytes,
		 n-24)>>8;
292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321
    
    break;
    
  case CRC24_B:
      oldcrc&=0x00ffffff;
      crc = crc24b(decoded_bytes,
                   n-24)>>8;
      
      break;

    case CRC16:
      oldcrc&=0x0000ffff;
      crc = crc16(decoded_bytes,
                  n-16)>>16;
      
      break;

    case CRC8:
      oldcrc&=0x000000ff;
      crc = crc8(decoded_bytes,
                 n-8)>>24;
      break;
    }

    if (crc == oldcrc)
      return(1);
    else
      return(0);

}
322 323


324 325 326
#ifdef DEBUG_CRC
/*******************************************************************/
/**
327
   Test code
328 329 330 331 332 333 334 335 336 337 338 339 340 341 342
********************************************************************/

#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

343