src/5gnrsch/rg_sch_uhm.c

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2017-2019] [Radisys]                                        #
   4 #                                                                              #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
   6 #   you may not use this file except in compliance with the License.           #
   7 #   You may obtain a copy of the License at                                    #
   8 #                                                                              #
   9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
  10 #                                                                              #
  11 #   Unless required by applicable law or agreed to in writing, software        #
  12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
  14 #   See the License for the specific language governing permissions and        #
  15 #   limitations under the License.                                             #
  16 ################################################################################
  17 *******************************************************************************/
  18
  19 /************************************************************************
  20
  21      Name:     LTE-MAC layer
  22
  23      Type:     C source file
  24
  25      Desc:     C source code for Entry point fucntions
  26
  27      File:     rg_sch_uhm.c
  28
  29 **********************************************************************/
  30
  31 /** @file rg_sch_uhm.c
  32 @brief This module handles uplink harq related functionality in MAC.
  33 */
  34
  35 /* header include files -- defines (.h) */
  36 #include "common_def.h"
  37 #include "rg_env.h"        /* MAC Environment Defines */
  38 #include "tfu.h"           /* TFU Interface defines */
  39 #include "rgr.h"           /* RGR Interface defines */
  40 #include "lrg.h"           /* LRG Interface defines */
  41
  42 #include "rg_sch.h"            /* Scheduler defines */
  43 #include "rg_sch_inf.h"            /* Scheduler defines */
  44 #include "rg_sch_err.h"        /* MAC error defines */
  45
  46 /* header/extern include files (.x) */
  47
  48 #include "tfu.x"           /* TFU Interface defines */
  49 #include "rgr.x"           /* RGR Interface includes */
  50 #include "lrg.x"           /* LRG Interface includes */
  51 #include "rgm.x"
  52 #include "rg_sch_inf.x"            /* Scheduler defines */
  53 #include "rg_sch.x"            /* Scheduler includes */
  54 #include "rg_sch_cmn.h"
  55 #include "rg_sch_cmn.x"
  56
  57 /* local defines */
  58
  59 /* local typedefs */
  60
  61 /* local externs */
  62
  63 /* forward references */
  64
  65 #ifdef EMTC_ENABLE
  66    U32 gUlRetxPassCntr = 0;
  67    /*EXTERN U32 gUlRetxFailCntr;
  68    EXTERN U32 gUlCrcPassCounter;
  69    EXTERN U32 gUlCrcFailCounter;*/
  70 #endif
  71 U8 rgRvIdxTable[] = {0, 3, 1, 2}; /* This gives rvIdx for a given rv */
  72 U8 rgRvTable[] = {0, 2, 3 ,1};    /* This gives rv for a given rvIdx */
  73
  74 #ifdef EMTC_ENABLE
  75 Void rgSCHCmnEmtcHdlHarqProcFail
  76 (
  77 RgSchCellCb       *cell,
  78 RgSchUeCb         *ue,
  79 RgSchUlHqProcCb   *hqProc,
  80 CmLteTimingInfo   frm
  81 );
  82 Void rgSCHEmtcInitUlUeHqEnt
  83 (
  84 RgSchCellCb      *cell,
  85 RgrUeCfg         *ueCfg,
  86 RgSchUeCb        *ueCb
  87 );
  88
  89 #endif
  90
  91 /**
  92  * @brief Handler for HARQ processing on recieving Data indication from PHY.
  93  *
  94  * @details
  95  *
  96  *     Function: rgSCHUhmProcDatInd
  97  *
  98  *     Invoked by: rgSCHTomTfuDatInd of  TOM
  99  *
 100  *     Processing Steps:
 101  *      - Set rcvdCrcInd variable to TRUE
 102  *
 103  *  @param[in] *cell
 104  *  @param[in] *ue
 105  *  @param[in] frm
 106  *  @return  Void
 107  **/
 108 #ifndef MAC_SCH_STATS
 109 #ifdef ANSI
 110 Void rgSCHUhmProcDatInd
 111 (
 112 RgSchCellCb          *cell,
 113 RgSchUeCb            *ue,
 114 CmLteTimingInfo      frm
 115 )
 116 #else
 117 Void rgSCHUhmProcDatInd(cell, ue, frm)
 118 RgSchCellCb          *cell;
 119 RgSchUeCb            *ue;
 120 CmLteTimingInfo      frm;
 121 #endif
 122 #else  /* MAC_SCH_STATS */
 123 #ifdef ANSI
 124 Void rgSCHUhmProcDatInd
 125 (
 126 RgSchCellCb          *cell,
 127 RgSchUeCb            *ue,
 128 CmLteTimingInfo      frm,
 129 U8                   cqi
 130 )
 131 #else
 132 Void rgSCHUhmProcDatInd(cell, ue, frm, cqi)
 133 RgSchCellCb          *cell;
 134 RgSchUeCb            *ue;
 135 CmLteTimingInfo      frm;
 136 U8                   cqi;
 137 #endif
 138 #endif /* MAC_SCH_STATS */
 139 {
 140    RgSchUlHqProcCb   *hqProc;
 141 #ifdef UL_LA
 142    RgSchCmnUlUe   *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
 143    S32            iTbs;
 144    U8             maxiTbs = rgSchCmnUlCqiToTbsTbl[cell->isCpUlExtend]
 145                                                  [ueUl->maxUlCqi];
 146 #endif
 147
 148    rgSCHUtlUlHqProcForUe(cell, frm, ue, &hqProc);
 149    if (hqProc == NULLP)
 150    {
 151       printf("UE[%d] failed to find UL HqProc for [%d:%d]\n",
 152                       ue->ueId, frm.sfn, frm.slot);
 153       RETVOID;
 154    }
 155    hqProc->rcvdCrcInd = TRUE;
 156
 157 #ifdef UL_LA
 158    {
 159       ueUl->ulLaCb.deltaiTbs += UL_LA_STEPUP;
 160       iTbs = (ueUl->ulLaCb.cqiBasediTbs + ueUl->ulLaCb.deltaiTbs)/100;
 161
 162       if (iTbs > maxiTbs)
 163       {
 164          ueUl->ulLaCb.deltaiTbs = (maxiTbs * 100) - ueUl->ulLaCb.cqiBasediTbs;
 165       }
 166
 167    }
 168 #endif
 169 #ifdef MAC_SCH_STATS
 170    /** Stats update over here
 171     */
 172    {
 173       hqFailStats.ulCqiStat[cqi - 1].numOfAcks++;
 174    }
 175 #endif
 176
 177 #ifdef TENB_STATS
 178    /* UL stats are filled in primary index as of now */
 179    cell->tenbStats->sch.ulAckNack[rgRvTable[hqProc->rvIdx]]++;
 180    ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(cell)].ulAckNackCnt++;
 181    if(hqProc->alloc)
 182    {
 183       ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(cell)].ulTpt += (hqProc->alloc->grnt.datSz << 3);
 184       cell->tenbStats->sch.ulTtlTpt +=(hqProc->alloc->grnt.datSz << 3);//pverma
 185    }
 186 #endif
 187
 188    RETVOID;
 189 }  /* rgSCHUhmProcDatInd */
 190
 191 /**
 192  * @brief Handler for HARQ processing on recieving Data indication from PHY.
 193  *
 194  * @details
 195  *
 196  *     Function: rgSCHUhmProcMsg3DatInd
 197  *
 198  *     Invoked by: rgSCHTomTfuDatInd of  TOM
 199  *
 200  *     Processing Steps:
 201  *      - Set rcvdCrcInd variable to TRUE
 202  *
 203  *  @param[in,out] *hqProc
 204  *  @return  Void
 205  **/
 206 #ifdef ANSI
 207 Void rgSCHUhmProcMsg3DatInd
 208 (
 209 RgSchUlHqProcCb *hqProc
 210 )
 211 #else
 212 Void rgSCHUhmProcMsg3DatInd(hqProc)
 213 RgSchUlHqProcCb *hqProc;
 214 #endif
 215 {
 216    hqProc->rcvdCrcInd = TRUE;
 217    hqProc->remTx = 0;        /*Reseting the value of rem Tx*/
 218    printf("\nrgSCHUhmProcMsg3DatInd,id:%u\n",hqProc->procId);
 219    RETVOID;
 220 }  /* rgSCHUhmProcMsg3DatInd */
 221
 222 /**
 223  * @brief Handler for HARQ processing on recieving Data indication from PHY.
 224  *
 225  * @details
 226  *
 227  *     Function: rgSCHUhmProcMsg3Failure
 228  *
 229  *     Invoked by: rgSCHTomTfuDatInd of  TOM
 230  *
 231  *     Processing Steps:
 232  *      - Set rcvdCrcInd variable to TRUE
 233  *
 234  *  @param[in,out] *hqProc
 235  *  @return  Void
 236  **/
 237 #ifdef ANSI
 238 Void rgSCHUhmProcMsg3Failure
 239 (
 240 RgSchUlHqProcCb *hqProc
 241 )
 242 #else
 243 Void rgSCHUhmProcMsg3Failure(hqProc)
 244 RgSchUlHqProcCb *hqProc;
 245 #endif
 246 {
 247 #ifdef EMTC_ENABLE
 248    RG_SCH_EMTC_IS_CRCIND_RCVD_CHK_RACB(hqProc);
 249 #endif
 250    if(hqProc->rcvdCrcInd != TRUE)
 251    {
 252       hqProc->rcvdCrcInd = FALSE;
 253    }
 254
 255    RETVOID;
 256 }  /* rgSCHUhmProcMsg3Failure */
 257
 258 /**
 259  * @brief Handler for HARQ processing on recieving Decode failure from PHY.
 260  *
 261  * @details
 262  *
 263  *     Function: rgSCHUhmProcHqFailure
 264  *
 265  *     Invoked by: rgSCHTomTfuDecFailInd of TOM
 266  *
 267  *     Processing Steps:
 268  *      - Update NACK information in harq info.
 269  *      - Update RV index of received RV from PHY in harq info.
 270  *      - Set PhichInfo in DlSf
 271  *
 272  *  @param[in] *cell
 273  *  @param[in] *ue
 274  *  @param[in] frm
 275  *  @param[in] rv
 276  *  @return  Void
 277  **/
 278 #ifndef MAC_SCH_STATS
 279 #ifdef ANSI
 280 Void rgSCHUhmProcHqFailure
 281 (
 282 RgSchCellCb          *cell,
 283 RgSchUeCb            *ue,
 284 CmLteTimingInfo      frm,
 285 TknU8                rv
 286 )
 287 #else
 288 Void rgSCHUhmProcHqFailure(cell, ue, frm, rv)
 289 RgSchCellCb          *cell;
 290 RgSchUeCb            *ue;
 291 CmLteTimingInfo      frm;
 292 TknU8                rv;
 293 #endif
 294 #else /* MAC_SCH_STATS */
 295 #ifdef ANSI
 296 Void rgSCHUhmProcHqFailure
 297 (
 298 RgSchCellCb          *cell,
 299 RgSchUeCb            *ue,
 300 CmLteTimingInfo      frm,
 301 TknU8                rv,
 302 U8                   cqi
 303 )
 304 #else
 305 Void rgSCHUhmProcHqFailure(cell, ue, frm, rv, cqi)
 306 RgSchCellCb          *cell;
 307 RgSchUeCb            *ue;
 308 CmLteTimingInfo      frm;
 309 TknU8                rv;
 310 U8                   cqi;
 311 #endif
 312 #endif /* MAC_SCH_STATS */
 313 {
 314    RgSchUlHqProcCb   *hqProc;
 315 #ifdef UL_LA
 316    RgSchCmnUlUe   *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
 317    S32               iTbs;
 318 #endif
 319
 320    rgSCHUtlUlHqProcForUe(cell, frm, ue, &hqProc);
 321    if (hqProc == NULLP)
 322    {
 323       printf("UE[%d] failed to find UL HqProc for [%d:%d]\n",
 324                       ue->ueId, frm.sfn, frm.slot);
 325       RETVOID;
 326    }
 327 #ifdef UL_LA
 328    {
 329       ueUl->ulLaCb.deltaiTbs -= UL_LA_STEPDOWN;
 330       iTbs = (ueUl->ulLaCb.cqiBasediTbs + ueUl->ulLaCb.deltaiTbs)/100;
 331
 332       if (iTbs < 0)
 333       {
 334          ueUl->ulLaCb.deltaiTbs = -(ueUl->ulLaCb.cqiBasediTbs);
 335       }
 336
 337    }
 338 #endif
 339 #ifdef MAC_SCH_STATS
 340    /** Stats update over here */
 341    {
 342       static U32 retxCnt = 0;
 343       ++retxCnt;
 344       hqFailStats.ulCqiStat[cqi - 1].numOfNacks++;
 345    }
 346 #endif /* MAC_SCH_STATS */
 347    if(hqProc->rcvdCrcInd != TRUE)
 348    {
 349       hqProc->rcvdCrcInd = FALSE;
 350    }
 351 #ifdef TENB_STATS
 352    /* UL stats are filled in primary index as of now */
 353    cell->tenbStats->sch.ulAckNack[rgRvTable[hqProc->rvIdx]]++;
 354    ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(cell)].ulAckNackCnt++;
 355    cell->tenbStats->sch.ulNack[rgRvTable[hqProc->rvIdx]]++;
 356    ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(cell)].ulNackCnt++;
 357 #endif
 358    hqProc->rvIdxPhy.pres = rv.pres;
 359    if(rv.pres)
 360    {
 361       hqProc->rvIdxPhy.val = rgRvIdxTable[rv.val];
 362    }
 363    RETVOID;
 364 } /* rgSCHUhmProcHqFailure */
 365
 366 /**
 367  * @brief Handler for identifying the HARQ process cb associated with the
 368  * index.
 369  *
 370  * @details
 371  *
 372  *     Function: rgSCHUhmGetUlHqProc
 373  *
 374  *     Processing Steps:
 375  *      - Return pointer to uplink harq process corresponding to the timing
 376  *        information passed.
 377  *
 378  *  @param[in]  *ue
 379  *  @param[in]  idx
 380  *  @return  RgSchUlHqProcCb*
 381  *      -# Pointer to harq process corresponding to index
 382  *      -# NULL
 383  **/
 384 #ifdef ANSI
 385 RgSchUlHqProcCb* rgSCHUhmGetUlHqProc
 386 (
 387 RgSchCellCb      *cell,
 388 RgSchUeCb        *ue,
 389 U8               idx
 390 )
 391 #else
 392 RgSchUlHqProcCb* rgSCHUhmGetUlHqProc(cell, ue, idx)
 393 RgSchCellCb      *cell;
 394 RgSchUeCb        *ue;
 395 U8               idx;
 396 #endif
 397 {
 398    RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
 399
 400 #if (ERRCLASS & ERRCLS_DEBUG)
 401    if(idx >= ueUl->hqEnt.numHqPrcs)
 402    {
 403       return (NULLP);
 404    }
 405 #endif
 406    return (&(ueUl->hqEnt.hqProcCb[idx]));
 407 }  /* rgSCHUhmGetUlHqProc */
 408
 409 /**
 410  * @brief Handler for HARQ processing on recieving new trasmission indication
 411  * from USM.
 412  *
 413  * @details
 414  *
 415  *     Function: rgSCHUhmNewTx
 416  *
 417  *     Invoked by: USM
 418  *
 419  *     Processing Steps:
 420  *      - Update harq info with values indicating new HARQ transmission.
 421  *
 422  *  @param[in,out]  *hqProc
 423  *  @param[in]      *alloc
 424  *  @return  Void
 425  **/
 426 #ifdef ANSI
 427 Void rgSCHUhmNewTx
 428 (
 429 RgSchUlHqProcCb *hqProc,
 430 U8              maxHqRetx,
 431 RgSchUlAlloc    *alloc
 432 )
 433 #else
 434 Void rgSCHUhmNewTx(hqProc, maxHqRetx, alloc)
 435 RgSchUlHqProcCb *hqProc;
 436 U8              maxHqRetx;
 437 RgSchUlAlloc    *alloc;
 438 #endif
 439 {
 440
 441    hqProc->ndi ^= 1;
 442    hqProc->alloc = alloc;
 443    hqProc->remTx = maxHqRetx;
 444    hqProc->rcvdCrcInd = FALSE;
 445    hqProc->rvIdx = 0;
 446    hqProc->rvIdxPhy.pres = FALSE;
 447 #ifdef LTE_L2_MEAS
 448    if (hqProc->alloc->ue)
 449    {
 450       ((RgUeUlHqCb*)hqProc->hqEnt)->numBusyHqProcs++;
 451    }
 452 #endif
 453    RETVOID;
 454 }  /* rgSCHUhmNewTx */
 455
 456 /**
 457  * @brief Free an uplink HARQ process.
 458  *
 459  * @details
 460  *
 461  *     Function: rgSCHUhmFreeProc
 462  *
 463  *     Invoked by: USM
 464  *
 465  *     Processing Steps:
 466  *      - Set alloc pointer to NULLP
 467  *
 468  *  @param[in]  RgSchUlHqProcCb   *hqProc
 469  *  @param[in]  RgSchCellCb      *cell
 470  *  @return  Void
 471  **/
 472 #ifdef ANSI
 473 Void rgSCHUhmFreeProc
 474 (
 475 RgSchUlHqProcCb *hqProc,
 476 RgSchCellCb      *cell
 477 )
 478 #else
 479 Void rgSCHUhmFreeProc(hqProc, cell)
 480 RgSchUlHqProcCb *hqProc;
 481 RgSchCellCb      *cell;
 482 #endif
 483 {
 484 #ifdef LTE_L2_MEAS
 485    RgSchUeCb         *ueCb;
 486    U8 qci = 1;
 487 #endif
 488
 489 #ifdef LTE_L2_MEAS
 490    if (hqProc->alloc && hqProc->alloc->ue)
 491    {
 492       ueCb = hqProc->alloc->ue;
 493       if (ueCb && cell)
 494       {
 495          U32 nonLcg0ReportedBs = ((RgSchCmnLcg *)(ueCb->ul.lcgArr[1].sch))->reportedBs + \
 496                                ((RgSchCmnLcg *)(ueCb->ul.lcgArr[2].sch))->reportedBs + \
 497                                ((RgSchCmnLcg *)(ueCb->ul.lcgArr[3].sch))->reportedBs;
 498          ((RgUeUlHqCb*)hqProc->hqEnt)->numBusyHqProcs--;
 499          if (! ((RgUeUlHqCb*)hqProc->hqEnt)->numBusyHqProcs && !(nonLcg0ReportedBs))
 500          {
 501             while (ueCb->ulActiveLCs)
 502             {
 503                if (ueCb->ulActiveLCs & 0x1)
 504                {
 505                   cell->qciArray[qci].ulUeCount--;
 506                }
 507                qci++;
 508                ueCb->ulActiveLCs >>= 1;
 509             }
 510          }
 511       }
 512    }
 513 #endif
 514
 515
 516  if(hqProc && (RgUeUlHqCb*)hqProc->hqEnt)
 517  {
 518
 519 #ifdef UL_ADPT_DBG
 520     printf("\n\n########HARQ FREED HARQPROC ID (%d )after rgSCHUhmFreeProc inuse %ld free %ld \n",hqProc->alloc->grnt.hqProcId, (CmLListCp *)(&((RgUeUlHqCb*)hqProc->hqEnt)->inUse)->count,(CmLListCp *) (&((RgUeUlHqCb*)hqProc->hqEnt)->free)->count);
 521 #endif
 522    hqProc->alloc = NULLP;
 523    hqProc->ulSfIdx = RGSCH_INVALID_INFO;
 524    /*ccpu00116293 - Correcting relation between UL slot and DL slot based on RG_UL_DELTA*/
 525    hqProc->isRetx  = FALSE;
 526    hqProc->remTx = 0; /*Reseting the remTx value to 0*/
 527 #ifdef EMTC_ENABLE
 528    RG_SCH_EMTC_SET_ISDTX_TO_FALSE(hqProc);
 529 #endif
 530    cmLListDelFrm(&((RgUeUlHqCb*)hqProc->hqEnt)->inUse,&hqProc->lnk);
 531    cmLListAdd2Tail(&((RgUeUlHqCb*)hqProc->hqEnt)->free, &hqProc->lnk);
 532
 533    /*
 534    printf("after rgSCHUhmFreeProc inuse %ld free %ld \n",
 535         (CmLListCp *)(&((RgUeUlHqCb*)hqProc->hqEnt)->inUse)->count,
 536          (CmLListCp *) (&((RgUeUlHqCb*)hqProc->hqEnt)->free)->count);
 537    */
 538  }
 539  else
 540  {
 541      printf("\nhqEnt is NULL\n");
 542  }
 543    RETVOID;
 544 }  /* rgSCHUhmFreeProc */
 545
 546 /**
 547  * @brief Handler for HARQ processing on recieving re-trasmission
 548  * indication from USM.
 549  *
 550  * @details
 551  *
 552  *     Function: rgSCHUhmRetx
 553  *
 554  *     Invoked by: USM
 555  *
 556  *     Processing Steps:
 557  *      - Update harq info with values corresponding to
 558  *        re-transmission.
 559  *
 560  *  @param[in,out]  *hqProc
 561  *  @return  Void
 562  **/
 563 #ifdef ANSI
 564 Void rgSCHUhmRetx
 565 (
 566 RgSchUlHqProcCb *hqProc,
 567 RgSchUlAlloc    *alloc
 568 )
 569 #else
 570 Void rgSCHUhmRetx(hqProc, alloc)
 571 RgSchUlHqProcCb *hqProc;
 572 RgSchUlAlloc    *alloc;
 573 #endif
 574 {
 575
 576    hqProc->alloc = alloc;
 577    --hqProc->remTx;
 578    hqProc->rvIdx = (hqProc->rvIdx + 1) % 4;
 579    hqProc->rvIdxPhy.pres = FALSE;
 580    RETVOID;
 581 }  /* rgSCHUhmRetx */
 582
 583
 584 /**
 585  * @brief Handler for initializing the HARQ entity.
 586  *
 587  * @details
 588  *
 589  *     Function: rgSCHUhmRgrUeCfg
 590  *
 591  *     Invoked by: RGR
 592  *
 593  *     Processing Steps:
 594  *      -  Initialize maxHqRetx
 595  *
 596  *  @param[in]      *cellCb
 597  *  @param[in,out]  *ueCb
 598  *  @param[in]      *ueCfg
 599  *  @param[out]     *err
 600  *  @return  Void
 601  **/
 602 #ifdef ANSI
 603 Void rgSCHUhmRgrUeCfg
 604 (
 605 RgSchCellCb       *cellCb,
 606 RgSchUeCb         *ueCb,
 607 RgrUeCfg          *ueCfg
 608 )
 609 #else
 610 Void rgSCHUhmRgrUeCfg(cellCb, ueCb, ueCfg)
 611 RgSchCellCb       *cellCb;
 612 RgSchUeCb         *ueCb;
 613 RgrUeCfg          *ueCfg;
 614 #endif
 615 {
 616    U8 i;
 617    RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ueCb, cellCb);
 618
 619    ueUl->hqEnt.maxHqRetx = ((ueCfg->ueUlHqCfg.maxUlHqTx) - 1);
 620 #ifdef TFU_UPGRADE
 621    /* Storing the delta HARQ offset for HARQ + PUSCH */
 622    ueCb->ul.betaHqOffst = ueCfg->puschDedCfg.bACKIdx;
 623 #endif
 624    cmLListInit(&ueUl->hqEnt.free);
 625    cmLListInit(&ueUl->hqEnt.inUse);
 626    for(i=0; i < ueUl->hqEnt.numHqPrcs; i++)
 627    {
 628       ueUl->hqEnt.hqProcCb[i].hqEnt = (void*)(&ueUl->hqEnt);
 629       ueUl->hqEnt.hqProcCb[i].procId = i;
 630       ueUl->hqEnt.hqProcCb[i].remTx = 0;
 631       ueUl->hqEnt.hqProcCb[i].ulSfIdx = RGSCH_INVALID_INFO;
 632       ueUl->hqEnt.hqProcCb[i].alloc = NULLP;
 633 #ifdef LTEMAC_SPS
 634       /* ccpu00139513- Initializing SPS flags*/
 635       ueUl->hqEnt.hqProcCb[i].isSpsActvnHqP = FALSE;
 636       ueUl->hqEnt.hqProcCb[i].isSpsOccnHqP = FALSE;
 637 #endif
 638       cmLListAdd2Tail(&ueUl->hqEnt.free, &ueUl->hqEnt.hqProcCb[i].lnk);
 639       ueUl->hqEnt.hqProcCb[i].lnk.node = (PTR)&ueUl->hqEnt.hqProcCb[i];
 640    }
 641
 642 #ifdef EMTC_ENABLE
 643    rgSCHEmtcInitUlUeHqEnt(cellCb, ueCfg, ueCb);
 644 #endif
 645    RETVOID;
 646 }  /* rgSCHUhmRgrUeCfg */
 647
 648 /**
 649  * @brief Handler for re-initializing the HARQ entity.
 650  *
 651  * @details
 652  *
 653  *     Function: rgSCHUhmRgrUeRecfg
 654  *
 655  *     Invoked by: RGR
 656  *
 657  *     Processing Steps:
 658  *      -  Re-initialize maxHqRetx
 659  *
 660  *  @param[in]      *cellCb
 661  *  @param[in,out]  *ueCb
 662  *  @param[in]      *ueCfg
 663  *  @param[out]     *err
 664  *  @return  Void
 665  **/
 666 #ifdef ANSI
 667 Void rgSCHUhmRgrUeRecfg
 668 (
 669 RgSchCellCb       *cellCb,
 670 RgSchUeCb         *ueCb,
 671 RgrUeRecfg        *ueRecfg
 672 )
 673 #else
 674 Void rgSCHUhmRgrUeRecfg(cellCb, ueCb, ueRecfg)
 675 RgSchCellCb       *cellCb;
 676 RgSchUeCb         *ueCb;
 677 RgrUeRecfg        *ueRecfg;
 678 #endif
 679 {
 680    RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ueCb, cellCb);
 681
 682    /* [ccpu00123958]-ADD- Check for HARQ Reconfig from the bit mask  */
 683    if(RGR_UE_ULHARQ_RECFG & ueRecfg->ueRecfgTypes)
 684    {
 685       ueUl->hqEnt.maxHqRetx = (ueRecfg->ueUlHqRecfg.maxUlHqTx - 1);
 686    }
 687
 688    RETVOID;
 689 }  /* rgSCHUhmRgrUeRecfg */
 690
 691 /**
 692  * @brief Handler for de-initializing the HARQ entity.
 693  *
 694  * @details
 695  *
 696  *     Function: rgSCHUhmFreeUe
 697  *
 698  *     Invoked by: RGR
 699  *
 700  *     Processing Steps:
 701  *      -
 702  *
 703  *  @param[in,out]  *ueCb
 704  *  @return  Void
 705  **/
 706 #ifdef ANSI
 707 Void rgSCHUhmFreeUe
 708 (
 709 RgSchCellCb       *cellCb,
 710 RgUeUlHqCb        *hqEnt
 711 )
 712 #else
 713 Void rgSCHUhmFreeUe(cellCb, hqEnt)
 714 RgSchCellCb       *cellCb;
 715 RgUeUlHqCb       *hqEnt;
 716 #endif
 717 {
 718 #ifdef LTE_TDD
 719    /* ccpu00117052 - MOD - Passing double pointer
 720    for proper NULLP assignment*/
 721    rgSCHUtlFreeSBuf(cellCb->instIdx,
 722                   (Data **)(&(hqEnt->hqProcCb)),
 723                   hqEnt->numHqPrcs * sizeof(RgSchUlHqProcCb));
 724 #endif
 725
 726    RETVOID;
 727 }  /* rgSCHUhmFreeUe */
 728
 729
 730 /**
 731 * @brief Handler for appending the PHICH information in to the dlSf.
 732 *
 733 * @details
 734 *
 735 *     Function: rgSCHUhmAppendPhich
 736 *
 737 *     Invoked by: TOM
 738 *
 739 *     Processing Steps:
 740 *      - Set PhichInfo in DlSf for each Hq
 741 *
 742 *  @param[in] *RgSchCellCb
 743 *  @param[in] CmLteTimingInfo
 744 *  @param[in] idx
 745 *  @return  Void
 746 */
 747 #ifdef ANSI
 748 S16 rgSCHUhmAppendPhich
 749 (
 750 RgSchCellCb            *cellCb,
 751 CmLteTimingInfo        frm,
 752 U8                     idx
 753 )
 754 #else
 755 S16 rgSCHUhmAppendPhich (cellCb, frm, idx)
 756 RgSchCellCb            *cellCb;
 757 CmLteTimingInfo        frm;
 758 U8                     idx;
 759 #endif
 760 {
 761    U8              nDmrs;
 762    U8              rbStart;
 763 #ifdef LTE_TDD
 764    U8              iPhich;
 765 #endif
 766    RgSchUlAlloc    *ulAlloc;
 767 #ifdef LTEMAC_HDFDD
 768    Bool            allwNack = TRUE;
 769 #endif /* LTEMAC_HDFDD */
 770    RgSchCmnUlCell  *cellUl = RG_SCH_CMN_GET_UL_CELL(cellCb);
 771
 772 #ifdef RG_5GTF
 773    return ROK;
 774 #endif
 775    if(cellUl->hqFdbkIdx[idx] != RGSCH_INVALID_INFO)
 776    {
 777       ulAlloc = rgSCHUtlFirstHqFdbkAlloc (cellCb, idx);
 778       while (ulAlloc)
 779       {
 780          /*ccpu00106104 MOD added check for ACKNACK rep*/
 781          /*added check for acknack so that adaptive retx considers ue
 782            inactivity due to ack nack repetition*/
 783          if((ulAlloc->ue != NULLP) && ((TRUE != ulAlloc->forMsg3) &&
 784                   ((ulAlloc->ue->measGapCb.isMeasuring == TRUE) ||
 785                    (ulAlloc->ue->ackNakRepCb.isAckNakRep == TRUE))))
 786          {
 787             /* Mark the UE for retransmission */
 788             /* If UE is measuring then we should not be sending PHICH unless msg3 */
 789             /*UE assumes ack, if nack then do adaptive re-transmission*/
 790             /*ulAlloc->hqProc->rcvdCrcInd = FALSE;--*/
 791             ulAlloc = rgSCHUtlNextHqFdbkAlloc (cellCb, ulAlloc, idx);
 792             continue;
 793          }
 794 #ifdef LTE_TDD
 795          if (rgSCHUtlGetPhichInfo (ulAlloc->hqProc, &rbStart, &nDmrs, &iPhich) != ROK)
 796 #else
 797             if (rgSCHUtlGetPhichInfo (ulAlloc->hqProc, &rbStart, &nDmrs) != ROK)
 798 #endif
 799             {
 800                return  (RFAILED);
 801             }
 802          if(nDmrs != RGSCH_INVALID_NDMRS)
 803          {
 804             if(cellCb->dynCfiCb.switchOvrInProgress)
 805             {
 806                ulAlloc->hqProc->rcvdCrcInd = TRUE;
 807             }
 808
 809             if(ulAlloc->hqProc->rcvdCrcInd)
 810             {
 811 #ifdef LTE_TDD
 812                rgSCHUtlAddPhich (cellCb, frm, TRUE, nDmrs, rbStart, iPhich);
 813 #else
 814                rgSCHUtlAddPhich (cellCb, frm, TRUE, nDmrs, rbStart, ulAlloc->forMsg3);
 815 #endif
 816             }
 817             /* Sending NACK in PHICH for failed UL TX */
 818             else
 819             {
 820 #ifdef LTE_TDD
 821                rgSCHUtlAddPhich (cellCb, frm, FALSE, nDmrs, rbStart, iPhich);
 822 #else
 823 #ifdef LTEMAC_HDFDD
 824                if (ulAlloc->ue != NULLP && ulAlloc->ue->hdFddEnbld)
 825                {
 826                   rgSCHCmnHdFddChkNackAllow( cellCb, ulAlloc->ue, frm, &allwNack);
 827                   /* Present implementaion of non-HDFDD does not send phich req
 828                      incase of NACK. So commented this part to maintain same right
 829                      now.*/
 830
 831                   if (allwNack)
 832                   {
 833                      rgSCHUtlAddPhich (cellCb, frm, FALSE, nDmrs, rbStart, ulAlloc->forMsg3);
 834                   }
 835                   else
 836                   {
 837                      rgSCHUtlAddPhich (cellCb, frm, TRUE, nDmrs, rbStart, ulAlloc->forMsg3);
 838                   }
 839                }
 840                else
 841                {
 842                   rgSCHUtlAddPhich (cellCb, frm, FALSE, nDmrs, rbStart, ulAlloc->forMsg3);
 843                }
 844 #else
 845                rgSCHUtlAddPhich (cellCb, frm, FALSE, nDmrs, rbStart, ulAlloc->forMsg3);
 846 #endif/* LTEMAC_HDFDD */
 847 #endif
 848             }
 849          }
 850          ulAlloc = rgSCHUtlNextHqFdbkAlloc (cellCb, ulAlloc, idx);
 851       }
 852    }
 853    return ROK;
 854 } /* rgSCHUhmAppendPhich */
 855
 856 /**
 857  * @brief This function initializes the DL HARQ Entity of UE.
 858  *
 859  * @details
 860  *
 861  *     Function: rgSCHUhmHqEntInit
 862  *     Purpose:  This function initializes the UL HARQ Processes of
 863  *               UE control block. This is performed at the time
 864  *               of creating UE control block.
 865  *
 866  *     Invoked by: configuration module
 867  *
 868  *  @param[in]  RgSchUeCb*    ueCb
 869  *  @return  S16
 870  *           -# ROK
 871  *           -# RFAILED
 872  *
 873  **/
 874 #ifdef ANSI
 875 S16 rgSCHUhmHqEntInit
 876 (
 877 RgSchCellCb       *cellCb,
 878 RgSchUeCb           *ueCb
 879 )
 880 #else
 881 S16 rgSCHUhmHqEntInit(cellCb, ueCb)
 882 RgSchCellCb       *cellCb;
 883 RgSchUeCb           *ueCb;
 884 #endif
 885 {
 886    RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ueCb, cellCb);
 887 #ifdef LTE_TDD
 888    Inst              inst = ueCb->cell->instIdx;
 889 #endif
 890
 891 #ifndef LTE_TDD
 892    /* Init the HARQ processes */
 893    ueUl->hqEnt.numHqPrcs = RGSCH_NUM_UL_HQ_PROC;
 894 #else
 895    /* Init the HARQ processes */
 896    ueUl->hqEnt.numHqPrcs =
 897                         rgSchTddUlNumHarqProcTbl[ueCb->cell->ulDlCfgIdx];
 898    if (rgSCHUtlAllocSBuf(inst, (Data **)&ueUl->hqEnt.hqProcCb,
 899                            ueUl->hqEnt.numHqPrcs * \
 900                            sizeof(RgSchUlHqProcCb)) != ROK)
 901    {
 902       return RFAILED;
 903    }
 904 #endif
 905
 906    return ROK;
 907 } /* rgSCHUhmHqEntInit */
 908
 909 #ifdef RG_5GTF
 910 /**
 911  * @brief This function gets an available HARQ process.
 912  *
 913  * @details
 914  *
 915  *     Function: rgSCHUhmGetAvlHqProc
 916  *     Purpose:  This function returns an available HARQ process in
 917  *               the UL direction. All HARQ processes are maintained
 918  *               in queues of free and inuse.
 919  *
 920  *               1. Check if the free queue is empty. If yes, return
 921  *                  RFAILED
 922  *               2. If not empty, update the proc variable with the
 923  *                  first process in the queue. Return ROK.
 924  *
 925  *     Invoked by: scheduler
 926  *
 927  *  @param[in]  RgSchUeCb           *ue
 928  *  @param[in]  CmLteTimingInfo  timingInfo
 929  *  @param[out] RgSchDlHqProc       **hqP
 930  *  @return  S16
 931  *         -#ROK     if successful
 932  *         -#RFAILED otherwise
 933  *
 934  **/
 935 #ifdef ANSI
 936 S16 rgSCHUhmGetAvlHqProc
 937 (
 938 RgSchCellCb           *cell,
 939 RgSchUeCb               *ue,
 940 RgSchUlHqProcCb         **hqP
 941 )
 942 #else
 943 S16 rgSCHUhmGetAvlHqProc (cell, ue, hqP)
 944 RgSchCellCb           *cell;
 945 RgSchUeCb             *ue;
 946 RgSchUlHqProcCb       **hqP;
 947 #endif
 948 {
 949    RgSchCmnUlCell    *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
 950    RgSchCmnUlUe      *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
 951    RgSchUlHqProcCb   *tmpHqProc;
 952    CmLList           *tmp;
 953    RgUeUlHqCb        *hqE;
 954
 955    hqE = &ueUl->hqEnt;
 956
 957    CM_LLIST_FIRST_NODE(&(hqE->free), tmp);
 958
 959    if (NULLP == tmp)
 960    {
 961       //RLOG_ARG3(L_ERROR,DBG_CELLID,cell->cellId,
 962        //                "rgSCHUhmGetAvlHqProc free %ld inUse %ld ue %d"
 963         //                                   , hqE->free.count, hqE->inUse.count, ue->ueId);
 964       //printf("5GTF_ERROR rgSCHUhmGetAvlHqProc cellId %d  %ld inUse %ld ue %d"
 965                               //, cell->cellId, hqE->free.count, hqE->inUse.count, ue->ueId);
 966       /* No Harq Process available in the free queue. */
 967       return RFAILED;
 968    }
 969
 970    tmpHqProc = (RgSchUlHqProcCb *)(tmp->node);
 971
 972    /* Remove the element from the free Queue */
 973    cmLListDelFrm(&hqE->free, tmp);
 974
 975    /* Add the element into the inUse Queue as well */
 976    cmLListAdd2Tail(&hqE->inUse, &tmpHqProc->lnk);
 977
 978 #ifdef UL_ADPT_DBG
 979          printf("rgSCHUhmGetAvlHqProc cellId %d  free %ld inUse %ld ue %d time (%d %d)\n",cell->cellId, hqE->free.count, hqE->inUse.count, ue->ueId,cellUl->schdTime.sfn,cellUl->schdTime.slot);
 980 #endif
 981    tmpHqProc->schdTime = cellUl->schdTime;
 982
 983    *hqP = tmpHqProc;
 984
 985    return ROK;
 986 } /* rgSCHUhmGetAvlHqProc */
 987
 988 /**
 989  * @brief Handler for identifying the HARQ process cb associated with the
 990  * TX Time.
 991  *
 992  * @details
 993  *
 994  *     Function: rgSCHUhmGetUlProcByTime
 995  *
 996  *     Processing Steps:
 997  *      - Return pointer to uplink harq process corresponding to the timing
 998  *        information passed.
 999  *
1000  *  @param[in]  *ue
1001  *  @param[in]  idx
1002  *  @return  RgSchUlHqProcCb*
1003  *      -# Pointer to harq process corresponding to index
1004  *      -# NULL
1005  **/
1006 #ifdef ANSI
1007 RgSchUlHqProcCb* rgSCHUhmGetUlProcByTime
1008 (
1009 RgSchCellCb      *cell,
1010 RgSchUeCb        *ue,
1011 CmLteTimingInfo  frm
1012 )
1013 #else
1014 RgSchUlHqProcCb* rgSCHUhmGetUlProcByTime(cell, ue, frm)
1015 RgSchCellCb      *cell;
1016 RgSchUeCb        *ue;
1017 CmLteTimingInfo  frm;
1018 #endif
1019 {
1020    RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
1021    CmLListCp    *lst = &ueUl->hqEnt.inUse;
1022    CmLList      *lnk = lst->first;
1023    RgSchUlHqProcCb   *proc;
1024
1025    while (lnk)
1026    {
1027       proc = (RgSchUlHqProcCb *)(lnk->node);
1028       lnk = lnk->next;
1029       //   printf("compare rgSCHUhmGetUlProcByTime time (%d %d) CRC time (%d %d) proc->procId %d \n",proc->schdTime.sfn,proc->schdTime.slot,frm.sfn,frm.slot ,proc->procId);
1030       if (RGSCH_TIMEINFO_SAME(proc->schdTime, frm))
1031       {
1032         // printf("Harq timing Matched rgSCHUhmGetUlProcByTime time (%d %d) proc->procId %d \n",proc->schdTime.sfn,proc->schdTime.slot, proc->procId);
1033          return (proc);
1034       }
1035    }
1036
1037    return (NULLP);
1038 }  /* rgSCHUhmGetUlProcByTime */
1039 #endif
1040
1041
1042 /**********************************************************************
1043
1044          End of file
1045 **********************************************************************/