lte_rate_matching.c 20.6 KB
Newer Older
1
/*******************************************************************************
2
    OpenAirInterface
ghaddab's avatar
ghaddab committed
3
    Copyright(c) 1999 - 2014 Eurecom
4

ghaddab's avatar
ghaddab committed
5 6 7 8
    OpenAirInterface is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
9 10


ghaddab's avatar
ghaddab committed
11 12 13 14
    OpenAirInterface is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
15

ghaddab's avatar
ghaddab committed
16
    You should have received a copy of the GNU General Public License
17 18
    along with OpenAirInterface.The full GNU General Public License is
   included in this distribution in the file called "COPYING". If not,
ghaddab's avatar
ghaddab committed
19
   see <http://www.gnu.org/licenses/>.
20 21

  Contact Information
ghaddab's avatar
ghaddab committed
22 23
  OpenAirInterface Admin: openair_admin@eurecom.fr
  OpenAirInterface Tech : openair_tech@eurecom.fr
24
  OpenAirInterface Dev  : openair4g-devel@lists.eurecom.fr
25

ghaddab's avatar
ghaddab committed
26
  Address      : Eurecom, Campus SophiaTech, 450 Route des Chappes, CS 50193 - 06904 Biot Sophia Antipolis cedex, FRANCE
27

ghaddab's avatar
ghaddab committed
28
 *******************************************************************************/
29 30 31
/* file: lte_rate_matching.c
   purpose: Procedures for rate matching/interleaving for LTE (turbo-coded transport channels) (TX/RX)
   author: raymond.knopp@eurecom.fr
32
   date: 21.10.2009
33 34 35 36 37
*/
#ifdef MAIN
#include <stdio.h>
#include <stdlib.h>
#endif
38
#include "PHY/defs.h"
39
#include "assertions.h"
40 41 42

//#define cmin(a,b) ((a)<(b) ? (a) : (b))

43 44
static uint32_t bitrev[32]    = {0,16,8,24,4,20,12,28,2,18,10,26,6,22,14,30,1,17,9,25,5,21,13,29,3,19,11,27,7,23,15,31};
static uint32_t bitrev_x3[32] = {0,48,24,72,12,60,36,84,6,54,30,78,18,66,42,90,3,51,27,75,15,63,39,87,9,57,33,81,21,69,45,93};
45 46 47 48 49 50
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};

//#define RM_DEBUG_TX 1
//#define RM_DEBUG 1
//#define RM_DEBUG2 1
//#define RM_DEBUG_CC 1
51 52 53

uint32_t sub_block_interleaving_turbo(uint32_t D, uint8_t *d,uint8_t *w)
{
54 55 56 57

  uint32_t RTC = (D>>5), ND, ND3;
  uint32_t row,col,Kpi,index;
  uint32_t index3,k,k2;
58
#ifdef RM_DEBUG
59
  uint32_t nulled=0;
60
#endif
61 62 63 64
  uint8_t *d1,*d2,*d3;

  if ((D&0x1f) > 0)
    RTC++;
65

66 67 68
  Kpi = (RTC<<5);
  //  Kpi3 = Kpi*3;
  ND = Kpi - D;
69
#ifdef RM_DEBUG
70 71
  printf("sub_block_interleaving_turbo : D = %d (%d)\n",D,D*3);
  printf("RTC = %d, Kpi=%d, ND=%d\n",RTC,Kpi,ND);
72
#endif
73 74 75 76
  ND3 = ND*3;

  // copy d02 to dD2 (for mod Kpi operation from clause (4), p.16 of 36.212
  d[(3*D)+2] = d[2];
77 78
  k=0;
  k2=0;
79 80 81 82
  d1 = d-ND3;
  d2 = d1+1;
  d3 = d1+5;

83
  for (col=0; col<32; col++) {
84 85 86 87 88
#ifdef RM_DEBUG
    printf("Col %d\n",col);
#endif
    index = bitrev[col];
    index3 = bitrev_x3[col];//3*index;
89 90

    for (row=0; row<RTC; row++) {
91 92 93

      w[k]            =  d1[index3];//d[index3-ND3];
      w[Kpi+k2]       =  d2[index3];//d[index3-ND3+1];
94
      w[Kpi+1+k2]     =  d3[index3];//d[index3-ND3+5];
95 96 97 98


#ifdef RM_DEBUG
      printf("row %d, index %d, index-Nd %d index-Nd+1 %d (k,Kpi+2k,Kpi+2k+1) (%d,%d,%d) w(%d,%d,%d)\n",row,index,index-ND,((index+1)%Kpi)-ND,k,Kpi+(k<<1),Kpi+(k<<1)+1,w[k],w[Kpi+(k<<1)],w[Kpi+1+(k<<1)]);
99

100
      if (w[k]== LTE_NULL)
101 102
        nulled++;

103
      if (w[Kpi+(k<<1)] ==LTE_NULL)
104 105
        nulled++;

106
      if (w[Kpi+1+(k<<1)] ==LTE_NULL)
107 108
        nulled++;

109 110 111 112
#endif
      index3+=96;
      index+=32;
      k++;
113 114 115
      k2++;
      k2++;
    }
116 117 118 119
  }

  if (ND>0)
    w[(3*Kpi) - 1] = LTE_NULL;
120

121
#ifdef RM_DEBUG
122

123 124 125 126
  if (ND>0) {
    printf("RM_TX: Nulled last component in pos %d\n",Kpi-1+k2);
    nulled++;
  }
127

128 129 130 131 132 133
  printf("RM_TX: Nulled %d\n",nulled);
#endif
  return(RTC);
}


134 135
uint32_t sub_block_interleaving_cc(uint32_t D, uint8_t *d,uint8_t *w)
{
136 137 138 139 140 141 142 143 144 145

  uint32_t RCC = (D>>5), ND, ND3;
  uint32_t row,col,Kpi,index;
  uint32_t index3,k;
#ifdef RM_DEBUG_CC
  uint32_t nulled=0;
#endif

  if ((D&0x1f) > 0)
    RCC++;
146

147 148 149 150 151 152 153 154 155 156
  Kpi = (RCC<<5);
  //  Kpi3 = Kpi*3;
  ND = Kpi - D;
#ifdef RM_DEBUG_CC
  printf("sub_block_interleaving_cc : D = %d (%d), d %p, w %p\n",D,D*3,d,w);
  printf("RCC = %d, Kpi=%d, ND=%d\n",RCC,Kpi,ND);
#endif
  ND3 = ND*3;

  k=0;
157 158

  for (col=0; col<32; col++) {
159 160 161 162 163
#ifdef RM_DEBUG_CC
    printf("Col %d\n",col);
#endif
    index = bitrev_cc[col];
    index3 = 3*index;
164 165

    for (row=0; row<RCC; row++) {
166 167
      w[k]          =  d[(int32_t)index3-(int32_t)ND3];
      w[Kpi+k]     =   d[(int32_t)index3-(int32_t)ND3+1];
168
      w[(Kpi<<1)+k] =  d[(int32_t)index3-(int32_t)ND3+2];
169 170
#ifdef RM_DEBUG_CC
      printf("row %d, index %d k %d w(%d,%d,%d)\n",row,index,k,w[k],w[Kpi+k],w[(Kpi<<1)+k]);
171

172
      if (w[k]== LTE_NULL)
173 174
        nulled++;

175
      if (w[Kpi+k] ==LTE_NULL)
176 177
        nulled++;

178
      if (w[(Kpi<<1)+k] ==LTE_NULL)
179 180
        nulled++;

181 182 183 184
#endif
      index3+=96;
      index+=32;
      k++;
185
    }
186
  }
187

188 189 190 191 192 193
#ifdef RM_DEBUG_CC
  printf("RM_TX: Nulled %d\n",nulled);
#endif
  return(RCC);
}

194 195
void sub_block_deinterleaving_turbo(uint32_t D,int16_t *d,int16_t *w)
{
196 197 198 199 200 201 202 203

  uint32_t RTC = (D>>5), ND, ND3;
  uint32_t row,col,Kpi,index;
  uint32_t index3,k,k2;
  int16_t *d1,*d2,*d3;

  if ((D&0x1f) > 0)
    RTC++;
204

205 206 207 208 209 210 211 212 213 214
  Kpi = (RTC<<5);
  //  Kpi3 = Kpi*3;
  ND = Kpi - D;
#ifdef RM_DEBUG2
  printf("sub_block_interleaving_turbo : D = %d (%d)\n",D,D*3);
  printf("RTC = %d, Kpi=%d, ND=%d\n",RTC,Kpi,ND);
#endif
  ND3 = ND*3;

  // copy d02 to dD2 (for mod Kpi operation from clause (4), p.16 of 36.212
215 216
  k=0;
  k2=0;
217 218 219 220
  d1 = d-ND3;
  d2 = d1+1;
  d3 = d1+5;

221
  for (col=0; col<32; col++) {
222 223 224 225 226
#ifdef RM_DEBUG2
    printf("Col %d\n",col);
#endif
    index = bitrev[col];
    index3 = bitrev_x3[col];//3*index;
227 228

    for (row=0; row<RTC; row++) {
229 230

      d1[index3]   = w[k];
231 232
      d2[index3]   = w[Kpi+k2];
      d3[index3]   = w[Kpi+1+k2];
233 234
      index3+=96;
      index+=32;
235 236 237 238
      k++;
      k2++;
      k2++;
    }
239
  }
240 241 242

  //  if (ND>0)
  //    d[2] = LTE_NULL;//d[(3*D)+2];
243 244 245

}

246 247
void sub_block_deinterleaving_cc(uint32_t D,int8_t *d,int8_t *w)
{
248 249 250 251 252 253 254 255 256 257 258

  //WANG_Hao uint32_t RCC = (D>>5), ND, ND3;
  uint32_t RCC = (D>>5);
  ptrdiff_t   ND, ND3;
  uint32_t row,col,Kpi,index;
  //WANG_Hao uint32_t index3,k;
  ptrdiff_t index3;
  uint32_t k;

  if ((D&0x1f) > 0)
    RCC++;
259

260 261 262 263 264 265 266 267 268 269
  Kpi = (RCC<<5);
  //  Kpi3 = Kpi*3;
  ND = Kpi - D;
#ifdef RM_DEBUG2
  printf("sub_block_interleaving_cc : D = %d (%d), d %p, w %p\n",D,D*3,d,w);
  printf("RCC = %d, Kpi=%d, ND=%d\n",RCC,Kpi,ND);
#endif
  ND3 = ND*3;

  k=0;
270 271

  for (col=0; col<32; col++) {
272 273 274 275 276
#ifdef RM_DEBUG2
    printf("Col %d\n",col);
#endif
    index = bitrev_cc[col];
    index3 = 3*index;
277 278

    for (row=0; row<RCC; row++) {
279 280

      d[index3-ND3]   = w[k];
281 282
      d[index3-ND3+1] = w[Kpi+k];
      d[index3-ND3+2] = w[(Kpi<<1)+k];
283 284 285 286 287 288
#ifdef RM_DEBUG2
      printf("row %d, index %d k %d index3-ND3 %d w(%d,%d,%d)\n",row,index,k,index3-ND3,w[k],w[Kpi+k],w[(Kpi<<1)+k]);
#endif
      index3+=96;
      index+=32;
      k++;
289
    }
290 291 292 293
  }

}

294 295
uint32_t generate_dummy_w(uint32_t D, uint8_t *w,uint8_t F)
{
296 297 298 299 300 301 302 303 304 305 306

  uint32_t RTC = (D>>5), ND;
  uint32_t col,Kpi,index;
  int32_t k,k2;
#ifdef RM_DEBUG
  uint32_t nulled=0;
#endif
  uint8_t *wKpi,*wKpi1,*wKpi2,*wKpi4;

  if ((D&0x1f) > 0)
    RTC++;
307

308 309 310 311 312 313 314
  Kpi = (RTC<<5);
  //  Kpi3 = Kpi*3;
  ND = Kpi - D;
#ifdef RM_DEBUG
  printf("dummy sub_block_interleaving_turbo : D = %d (%d)\n",D,D*3);
  printf("RTC = %d, Kpi=%d, ND=%d, F=%d (Nulled %d)\n",RTC,Kpi,ND,F,(2*F + 3*ND));
#endif
315 316


317 318 319 320 321 322
  k=0;
  k2=0;
  wKpi = &w[Kpi];
  wKpi1 = &w[Kpi+1];
  wKpi2 = &w[Kpi+2];
  wKpi4 = &w[Kpi+4];
323 324

  for (col=0; col<32; col++) {
325 326 327 328
#ifdef RM_DEBUG
    printf("Col %d\n",col);
#endif
    index = bitrev[col];
329

330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345
    if (index<(ND+F)) {
      w[k]   =  LTE_NULL;
      wKpi[k2] = LTE_NULL;
#ifdef RM_DEBUG
      nulled+=2;
#endif
    }

    //bits beyond 32 due to "filler" bits
    if ((index+32)<(ND+F)) {
      w[k+1]   =  LTE_NULL;
      wKpi2[k2] = LTE_NULL;
#ifdef RM_DEBUG
      nulled+=2;
#endif
    }
346

347 348 349 350 351 352 353 354 355 356 357 358 359 360
    if ((index+64)<(ND+F)) {
      w[k+2]   =  LTE_NULL;
      wKpi4[k2] = LTE_NULL;
#ifdef RM_DEBUG
      nulled+=2;
#endif
    }

    if ((index+1)<ND) {
      wKpi1[k2] =  LTE_NULL;
#ifdef RM_DEBUG
      nulled+=1;
#endif
    }
361

362 363 364 365 366 367 368
#ifdef RM_DEBUG
    printf("k %d w (%d,%d,%d) w+1 (%d,%d,%d), index %d index-ND-F %d index+32-ND-F %d\n",k,w[k],w[Kpi+(k<<1)],w[Kpi+1+(k<<1)],w[k+1],w[2+Kpi+(k<<1)],w[2+Kpi+1+(k<<1)],index,index-ND-F,index+32-ND-F);
#endif
    k+=RTC;
    k2=k<<1;
  }

369
  // copy d02 to dD2 (for mod Kpi operation from clause (4), p.16 of 36.212
370 371
  if (ND>0)
    w[(3*Kpi)-1] = LTE_NULL;
372

373
#ifdef RM_DEBUG
374

375 376 377 378
  if (ND>0) {
    nulled++;
    printf("dummy_w: Nulled final position %d\n",(3*Kpi)-1);
  }
379

380 381 382 383 384
  printf("Nulled = %d\n",nulled);
#endif
  return(RTC);
}

385 386
uint32_t generate_dummy_w_cc(uint32_t D, uint8_t *w)
{
387 388 389

  uint32_t RCC = (D>>5), ND;
  uint32_t col,Kpi,index;
390
  int32_t k;
391 392 393 394 395 396
#ifdef RM_DEBUG_CC
  uint32_t nulled=0;
#endif

  if ((D&0x1f) > 0)
    RCC++;
397

398 399 400 401 402 403 404 405 406 407 408 409
  Kpi = (RCC<<5);
  //  Kpi3 = Kpi*3;
  ND = Kpi - D;
#ifdef RM_DEBUG_CC
  printf("dummy sub_block_interleaving_cc : D = %d (%d)\n",D,D*3);
  printf("RCC = %d, Kpi=%d, ND=%d, (Nulled %d)\n",RCC,Kpi,ND,3*ND);
#endif
  //  ND3 = ND*3;

  // copy d02 to dD2 (for mod Kpi operation from clause (4), p.16 of 36.212
  k=0;

410
  for (col=0; col<32; col++) {
411 412 413 414
#ifdef RM_DEBUG_CC
    printf("Col %d\n",col);
#endif
    index = bitrev_cc[col];
415

416 417 418 419 420 421 422 423
    if (index<ND) {
      w[k]          = LTE_NULL;
      w[Kpi+k]      = LTE_NULL;
      w[(Kpi<<1)+k] = LTE_NULL;
#ifdef RM_DEBUG_CC
      nulled+=3;
#endif
    }
424

425 426 427 428 429 430
    /*
    //bits beyond 32 due to "filler" bits
    if (index+32<ND) {
      w[k+1]          = LTE_NULL;
      w[Kpi+1+k]      = LTE_NULL;
      w[(Kpi<<1)+1+k] = LTE_NULL;
431
    #ifdef RM_DEBUG
432
      nulled+=3;
433
    #endif
434 435 436 437 438
    }
    if (index+64<ND) {
      w[k+2]          = LTE_NULL;
      w[Kpi+2+k]      = LTE_NULL;
      w[(Kpi<<1)+2+k] = LTE_NULL;
439
    #ifdef RM_DEBUG
440
      nulled+=3;
441
    #endif
442 443 444 445 446
    }


    if ((index+1)<ND) {
      w[Kpi+1+(k<<1)] =  LTE_NULL;
447
    #ifdef RM_DEBUG
448
      nulled+=1;
449
    #endif
450
    }
451
    */
452 453 454 455 456 457 458 459 460 461 462 463 464 465
#ifdef RM_DEBUG_CC
    printf("k %d w (%d,%d,%d), index-ND %d index+32-ND %d\n",k,w[k],w[Kpi+k],w[(Kpi<<1)+k],index-ND,index+32-ND);
#endif
    k+=RCC;
  }

#ifdef RM_DEBUG_CC
  printf("Nulled = %d\n",nulled);
#endif
  return(RCC);
}


uint32_t lte_rate_matching_turbo(uint32_t RTC,
466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481
                                 uint32_t G,
                                 uint8_t *w,
                                 uint8_t *e,
                                 uint8_t C,
                                 uint32_t Nsoft,
                                 uint8_t Mdlharq,
                                 uint8_t Kmimo,
                                 uint8_t rvidx,
                                 uint8_t Qm,
                                 uint8_t Nl,
                                 uint8_t r,
                                 uint8_t nb_rb,
                                 uint8_t m)
{


482 483 484 485
  uint32_t Nir,Ncb,Gp,GpmodC,E,Ncbmod,ind,k;
  //  int cnt=0;
  uint8_t *e2;
#ifdef RM_DEBUG_TX
486
  int code_block,round;
487 488 489 490 491 492 493 494 495 496
  int cnt;
  int zeroed=0;
  int oned=0;
  int twoed=0;
  int threed =0;
  uint32_t nulled=0;
  static unsigned char *counter_buffer[MAX_NUM_DLSCH_SEGMENTS][4];
  FILE *counter_fd;
  char fname[512];
#endif
497

498 499 500
  Nir = Nsoft/Kmimo/cmin(8,Mdlharq);
  Ncb = cmin(Nir/C,3*(RTC<<5));
#ifdef RM_DEBUG_TX
501 502 503 504 505 506

  if (rvidx==0 && r==0) {
    for(round=0; round<4; round++)
      for (code_block=0; code_block<MAX_NUM_DLSCH_SEGMENTS; code_block++) {
        counter_buffer[code_block][round] = (unsigned char *)malloc(Ncb*sizeof(char));
        memset(counter_buffer[code_block][round],0,Ncb*sizeof(char));
507
      }
508 509 510 511
  } else if(rvidx==3) {
    sprintf(fname, "mcs%d_rate_matching_RB_%d.txt", m, nb_rb);
    // sprintf(fname,"mcs0_rate_matching_RB_6.txt");
    counter_fd = fopen(fname,"w");
512
  }
513

514
#endif
515

516 517 518
  // if (rvidx==3)
  //  for (cnt=0;cnt<Ncb;cnt++)
  //    counter_buffer[rvidx][cnt]=0;
519 520
  AssertFatal(Ncb>=(3*RTC<<5),"Exiting, RM condition (Ncb %d, Nir/C %d, Nsoft %d, Kw %d\n",Ncb,Nir/C,Nsoft,3*(RTC<<5));
  
521

522 523 524 525
  Gp = G/Nl/Qm;
  GpmodC = Gp%C;

#ifdef RM_DEBUG
526
  printf("lte_rate_matching_turbo: Ncb %d, Kw %d, Nir/C %d, rvidx %d, G %d, Qm %d, Nl%d, r %d\n",Ncb,3*(RTC<<5),Nir/C,rvidx, G, Qm,Nl,r);
527 528 529 530 531 532 533 534 535 536 537 538 539 540 541
#endif

  if (r < (C-(GpmodC)))
    E = Nl*Qm * (Gp/C);
  else
    E = Nl*Qm * ((GpmodC==0?0:1) + (Gp/C));

  Ncbmod = Ncb%(RTC<<3);

  ind = RTC * (2+(rvidx*(((Ncbmod==0)?0:1) + (Ncb/(RTC<<3)))*2));

#ifdef RM_DEBUG_TX
  printf("lte_rate_matching_turbo: E %d, k0 %d, Ncbmod %d, Ncb/(RTC<<3) %d\n",E,ind,Ncbmod,Ncb/(RTC<<3));
#endif

542 543
  //e2=e+(r*E);
  e2 = e;
544

545 546
  k=0;

547
  for (; (ind<Ncb)&&(k<E); ind++) {
548
    //    e2[k]=w[ind];
549 550 551
#ifdef RM_DEBUG_TX
    printf("RM_TX k%d Ind: %d (%d)\n",k,ind,w[ind]);
#endif
552

553
    if (w[ind] != LTE_NULL) e2[k++]=w[ind];
554
  }
555

556
  while(k<E) {
557
    for (ind=0; (ind<Ncb)&&(k<E); ind++) {
558
      //      e2[k] = w[ind];
559
#ifdef RM_DEBUG_TX
560
      printf("RM_TX k%d Ind: %d (%d)\n",k,ind,w[ind]);
561
#endif
562

563
      if (w[ind] != LTE_NULL) e2[k++]=w[ind];
564 565
    }
  }
566 567

  /*
568
  for (k=0;k<E;k++) {
569

570 571

    while(w[ind] == LTE_NULL) {
572
  #ifdef RM_DEBUG_TX
573 574
      printf("RM_tx : ind %d, NULL\n",ind);
      nulled++;
575
  #endif
576 577
      ind++;
      if (ind==Ncb)
578
  ind=0;
579 580 581 582 583
    }

    e2[k] = w[ind];
    //    printf("RM_TX k%d Ind: %d (%d)\n",k,ind,w[ind]);
    //    cnt = cnt+1;
584
  #ifdef RM_DEBUG_TX
585 586 587 588
    counter_buffer[r][rvidx][ind]++;
    // printf("Bit_Counter[%d][%d][%d]=%d\n",r,rvidx,ind,counter_buffer[r][rvidx][ind]);
    //    printf("k %d ind %d, w %c(%d)\n",k,ind,w[ind],w[ind]);
    // printf("RM_TX %d (%d) Ind: %d (%d)\n",k,k+r*E,ind,e2[k]);
589
  #endif
590 591 592 593
    ind++;
    if (ind==Ncb)
      ind=0;
  }
594 595

  #ifdef RM_DEBUG_TX
596 597 598
  if (rvidx==3){
    for(cnt=0;cnt<Ncb;cnt++)
      {
599 600 601 602 603 604
  fprintf(counter_fd,"%d %x %x %x %x %x %x %x %x %x %x %x %x\n",cnt,
    counter_buffer[0][0][cnt],counter_buffer[1][0][cnt],counter_buffer[2][0][cnt],
    counter_buffer[0][1][cnt],counter_buffer[1][1][cnt],counter_buffer[2][1][cnt],
    counter_buffer[0][2][cnt],counter_buffer[1][2][cnt],counter_buffer[2][2][cnt],
    counter_buffer[0][3][cnt],counter_buffer[1][3][cnt],counter_buffer[2][3][cnt]
    );
605 606
    }
    fclose(counter_fd);
607

608
  }
609 610


611 612 613 614 615 616 617 618 619 620 621 622
   for(cnt=0;cnt<Ncb;cnt++){
    printf("Bit_Counter[%d][%d]=%d\n",rvidx,cnt,counter_buffer[r][rvidx][cnt]);
    if(counter_buffer[r][rvidx][cnt]==0)
      zeroed++;
    else if(counter_buffer[r][rvidx][cnt]==1)
      oned++;
    else if(counter_buffer[r][rvidx][cnt]==2)
      twoed++;
    else if(counter_buffer[r][rvidx][cnt]==3)
      threed++;
   }

623 624 625 626 627
  printf("zeroed %d\n",zeroed);
  printf("oned %d\n",oned);
  printf("twoed %d\n",twoed);
  printf("threed %d\n",threed);

628
  printf("nulled %d\n",nulled);
629 630 631

  #endif
  */
632 633
  return(E);
}
634

635 636

uint32_t lte_rate_matching_cc(uint32_t RCC,
637 638 639 640 641
                              uint16_t E,
                              uint8_t *w,
                              uint8_t *e)
{

642 643 644

  uint32_t ind=0,k;

645
  uint16_t Kw = 3*(RCC<<5);
646 647 648 649 650 651 652

#ifdef RM_DEBUG_CC
  uint32_t nulled=0;

  printf("lte_rate_matching_cc: Kw %d, E %d\n",Kw, E);
#endif

653
  for (k=0; k<E; k++) {
654 655 656 657 658 659 660 661 662


    while(w[ind] == LTE_NULL) {

#ifdef RM_DEBUG_CC
      nulled++;
      printf("RM_TX_CC : ind %d, NULL\n",ind);
#endif
      ind++;
663

664
      if (ind==Kw)
665
        ind=0;
666 667 668 669 670
    }


    e[k] = w[ind];
#ifdef RM_DEBUG_CC
671
    //    printf("k %d ind %d, w %c(%d)\n",k,ind,w[ind],w[ind]);
672 673 674
    printf("RM_TX_CC %d Ind: %d (%d)\n",k,ind,e[k]);
#endif
    ind++;
675

676 677 678
    if (ind==Kw)
      ind=0;
  }
679

680 681 682 683 684 685 686 687
#ifdef RM_DEBUG_CC
  printf("nulled %d\n",nulled);
#endif
  return(E);
}


int lte_rate_matching_turbo_rx(uint32_t RTC,
688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704
                               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)
{


705 706
  uint32_t Nir,Ncb,Gp,GpmodC,E,Ncbmod,ind,k;
  int16_t *soft_input2;
707
  //   int32_t w_tmp;
708 709 710
#ifdef RM_DEBUG
  int nulled=0;
#endif
711

712
  if (Kmimo==0 || Mdlharq==0 || C==0 || Qm==0 || Nl==0) {
713
    printf("lte_rate_matching.c: invalid parameters (Kmimo %d, Mdlharq %d, C %d, Qm %d, Nl %d\n",
714
        Kmimo,Mdlharq,C,Qm,Nl);
715 716 717 718 719
    return(-1);
  }

  Nir = Nsoft/Kmimo/cmin(8,Mdlharq);
  Ncb = cmin(Nir/C,3*(RTC<<5));
720

721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741

  Gp = G/Nl/Qm;
  GpmodC = Gp%C;



  if (r < (C-(GpmodC)))
    E = Nl*Qm * (Gp/C);
  else
    E = Nl*Qm * ((GpmodC==0?0:1) + (Gp/C));

  Ncbmod = Ncb%(RTC<<3);

  ind = RTC * (2+(rvidx*(((Ncbmod==0)?0:1) + (Ncb/(RTC<<3)))*2));

#ifdef RM_DEBUG
  printf("lte_rate_matching_turbo_rx: Clear %d, E %d, Ncb %d, Kw %d, rvidx %d, G %d, Qm %d, Nl%d, r %d\n",clear,E,Ncb,3*(RTC<<5),rvidx, G, Qm,Nl,r);
#endif

  if (clear==1)
    memset(w,0,Ncb*sizeof(int16_t));
742

knopp's avatar
knopp committed
743
  soft_input2 = soft_input;// + (r*E);
744 745
  k=0;

746 747 748
  for (; (ind<Ncb)&&(k<E); ind++) {
    if (dummy_w[ind] != LTE_NULL) {
      w[ind] += soft_input2[k++];
749 750 751 752
#ifdef RM_DEBUG
      printf("RM_RX k%d Ind: %d (%d)\n",k-1,ind,w[ind]);
#endif
    }
753

754 755 756 757 758
#ifdef RM_DEBUG
    else {
      printf("RM_RX Ind: %d NULL %d\n",ind,nulled);
      nulled++;
    }
759

760 761
#endif
  }
762

763
  while(k<E) {
764 765 766
    for (ind=0; (ind<Ncb)&&(k<E); ind++) {
      if (dummy_w[ind] != LTE_NULL) {
        w[ind] += soft_input2[k++];
767
#ifdef RM_DEBUG
768
        printf("RM_RX k%d Ind: %d (%d)(soft in %d)\n",k-1,ind,w[ind],soft_input2[k-1]);
769 770
#endif
      }
771

772 773
#ifdef RM_DEBUG
      else {
774 775 776 777
        printf("RM_RX Ind: %d NULL %d\n",ind,nulled);
        nulled++;
      }

778 779 780 781 782 783 784 785 786
#endif
    }
  }

  /*
  for (k=0;k<E;k++) {


    while(dummy_w[ind] == LTE_NULL) {
787
  #ifdef RM_DEBUG
788
      printf("RM_rx : ind %d, NULL\n",ind);
789
  #endif
790 791
      ind++;
      if (ind==Ncb)
792
  ind=0;
793 794
    }
  */
795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815
  /*
  if (w[ind] != 0)
    printf("repetition %d (%d,%d,%d)\n",ind,rvidx,E,Ncb);
  */
  // Maximum-ratio combining of repeated bits and retransmissions
  /*
  w_tmp = (int) w[ind] + (int) soft_input2[k];
  if (w_tmp > 32767) {
    //#ifdef DEBUG_RM
    printf("OVERFLOW!!!!!, w_tmp = %d\n",w_tmp);
    //#endif
    w[ind] = 32767;
  }
  else if (w_tmp < -32768) {
    //#ifdef DEBUG_RM
    printf("UNDERFLOW!!!!!, w_tmp = %d\n",w_tmp);
    //#endif
    w[ind] = -32768;
  }
  else
  */
816 817
  /*
    w[ind] += soft_input2[k];
818
  #ifdef RM_DEBUG
819
      printf("RM_RX k%d Ind: %d (%d)\n",k,ind,w[ind]);
820
  #endif
821 822 823 824 825 826 827 828 829 830 831 832 833
    ind++;
    if (ind==Ncb)
      ind=0;
  }
  */

  *E_out = E;
  return(0);

}


void lte_rate_matching_cc_rx(uint32_t RCC,
834 835 836 837 838 839 840
                             uint16_t E,
                             int8_t *w,
                             uint8_t *dummy_w,
                             int8_t *soft_input)
{


841 842

  uint32_t ind=0,k;
843
  uint16_t Kw = 3*(RCC<<5);
844 845 846 847 848 849 850 851 852 853 854 855
  uint32_t acc=1;
  int16_t w16[Kw];
#ifdef RM_DEBUG_CC
  uint32_t nulled=0;

  printf("lte_rate_matching_cc_rx: Kw %d, E %d, w %p, soft_input %p\n",3*(RCC<<5),E,w,soft_input);
#endif


  memset(w,0,Kw);
  memset(w16,0,Kw*sizeof(int16_t));

856
  for (k=0; k<E; k++) {
857 858 859 860 861 862 863 864


    while(dummy_w[ind] == LTE_NULL) {
#ifdef RM_DEBUG_CC
      nulled++;
      printf("RM_RX : ind %d, NULL\n",ind);
#endif
      ind++;
865

866
      if (ind==Kw)
867
        ind=0;
868
    }
869

870 871 872 873 874 875
    /*
    if (w[ind] != 0)
      printf("repetition %d (%d,%d,%d)\n",ind,rvidx,E,Ncb);
    */
    // Maximum-ratio combining of repeated bits and retransmissions
#ifdef RM_DEBUG_CC
876
    printf("RM_RX_CC k %d (%d) ind: %d (%d)\n",k,soft_input[k],ind,w16[ind]);
877 878 879
#endif


880
    w16[ind] += soft_input[k];
881

882 883 884 885 886 887
    ind++;

    if (ind==Kw) {
      ind=0;
      acc++;
    }
888
  }
889

890
  // rescale
891
  for (ind=0; ind<Kw; ind++) {
892 893 894 895 896 897 898 899
    //    w16[ind]=(w16[ind]/acc);
    if (w16[ind]>7)
      w[ind]=7;
    else if (w16[ind]<-8)
      w[ind]=-8;
    else
      w[ind]=(int8_t)w16[ind];
  }
900

901 902 903 904 905 906 907 908 909
#ifdef RM_DEBUG_CC

  printf("Nulled %d\n",nulled);
#endif
}


#ifdef MAIN

910 911
void main()
{
912 913 914 915 916 917 918 919 920
  uint8_t d[96+3+(3*6144)];
  uint8_t w[3*6144],e[12*6144];
  uint32_t RTC,G,rvidx;
  uint32_t nb_rb=6;
  uint32_t mod_order = 4;
  uint32_t first_dlsch_symbol = 2;
  uint32_t i;

  G = ( nb_rb * (12 * mod_order) * (12-first_dlsch_symbol-3)) ;//( nb_rb * (12 * mod_order) * (14-first_dlsch_symbol-3)) :
921

922
  // initialize 96 first positions to "LTE_NULL"
923
  for (i=0; i<96; i++)
924 925 926
    d[i]=LTE_NULL;

  RTC = sub_block_interleaving_turbo(4+(192*8), &d[96], w);
927 928

  for (rvidx=0; rvidx<4; rvidx++) {
929
    lte_rate_matching_turbo(RTC,
930 931 932 933 934 935 936 937 938 939 940 941 942
                            G,
                            w,
                            e,
                            1,           //C
                            1827072,     //Nsoft,
                            8,           //Mdlharq,
                            1,           //Kmimo,
                            rvidx,       //rvidx,
                            mod_order,   //Qm,
                            1,           //Nl,
                            0            //r
                           );
  }
943 944 945 946
}

#endif