src/5gnrsch/sch_common.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:     5G NR SCH layer
  22
  23 Type:     C source file
  24
  25 Desc:     C source code for Entry point fucntions
  26
  27 File:     sch_common.c
  28
  29  **********************************************************************/
  30
  31 /** @file sch_common.c
  32   @brief This module performs common scheduling
  33  */
  34 #include "common_def.h"
  35 #include "tfu.h"
  36 #include "lrg.h"
  37
  38 #include "tfu.x"
  39 #include "lrg.x"
  40 #include "du_log.h"
  41 #include "du_app_mac_inf.h"
  42 #include "mac_sch_interface.h"
  43 #include "sch.h"
  44 #include "sch_utils.h"
  45
  46 SchMacUlSchInfoFunc schMacUlSchInfoOpts[] =
  47 {
  48    packSchMacUlSchInfo,
  49    MacProcUlSchInfo,
  50    packSchMacUlSchInfo
  51 };
  52
  53 /**
  54  * @brief common resource allocation for SSB
  55  *
  56  * @details
  57  *
  58  *     Function : schBroadcastSsbAlloc
  59  *
  60  *     This function handles common scheduling for SSB
  61  *
  62  *  @param[in]  SchCellCb *cell, cell cb
  63  *  @param[in]  DlBrdcstAlloc *dlBrdcstAlloc, DL brdcst allocation
  64  *  @return  void
  65  **/
  66 uint8_t schBroadcastSsbAlloc(SchCellCb *cell, SlotTimingInfo slotTime, DlBrdcstAlloc *dlBrdcstAlloc)
  67 {
  68    /* schedule SSB */
  69    uint8_t ssbStartSymb, idx;
  70    uint16_t ssbStartPrb;
  71    SchDlSlotInfo *schDlSlotInfo;
  72    SsbInfo ssbInfo;
  73
  74    if(cell == NULL)
  75    {
  76       DU_LOG("\nERROR  -->  SCH: schBroadcastSsbAlloc() : Cell is NULL");
  77       return RFAILED;
  78    }
  79
  80    if(dlBrdcstAlloc == NULL)
  81    {
  82       DU_LOG("\nERROR  -->  SCH: schBroadcastSsbAlloc() : dlBrdcstAlloc is NULL");
  83       return RFAILED;
  84    }
  85
  86    schDlSlotInfo = cell->schDlSlotInfo[slotTime.slot];
  87    ssbStartPrb = cell->cellCfg.ssbSchCfg.ssbOffsetPointA; //+Kssb
  88    ssbStartSymb = cell->ssbStartSymbArr[dlBrdcstAlloc->ssbIdxSupported-1]; /*since we are supporting only 1 ssb beam */
  89
  90    /* Assign interface structure */
  91    for(idx=0; idx<dlBrdcstAlloc->ssbIdxSupported; idx++)
  92    {
  93       ssbInfo.ssbIdx              = idx;
  94       ssbInfo.fdAlloc.startPrb    = ssbStartPrb;
  95       ssbInfo.fdAlloc.numPrb      = SCH_SSB_NUM_PRB;
  96       ssbInfo.tdAlloc.startSymb   = ssbStartSymb;
  97       ssbInfo.tdAlloc.numSymb     = SCH_SSB_NUM_SYMB;
  98       dlBrdcstAlloc->ssbInfo[idx] = ssbInfo;
  99       schDlSlotInfo->ssbInfo[idx] = ssbInfo;
 100    }
 101
 102    if((allocatePrbDl(cell, slotTime, ssbStartSymb, SCH_SSB_NUM_SYMB, &ssbInfo.fdAlloc.startPrb, ssbInfo.fdAlloc.numPrb)) != ROK)
 103    {
 104        DU_LOG("\nERROR  -->  SCH: PRB allocation failed for SSB in SFN:SLOT [%d : %d]", slotTime.sfn, slotTime.slot);
 105        return RFAILED;
 106    }
 107
 108
 109    schDlSlotInfo->ssbPres = true;
 110    schDlSlotInfo->ssbIdxSupported = dlBrdcstAlloc->ssbIdxSupported;
 111    return ROK;
 112 }
 113
 114 /**
 115  * @brief common resource allocation for SIB1
 116  *
 117  * @details
 118  *
 119  *     Function : schBroadcastSib1Alloc
 120  *
 121  *     This function handles common scheduling for SIB1
 122  *
 123  *  @param[in]  SchCellCb *cell, cell cb
 124  *  @param[in]  DlBrdcstAlloc *dlBrdcstAlloc, DL brdcst allocation
 125  *  @return  void
 126  **/
 127 uint8_t schBroadcastSib1Alloc(SchCellCb *cell, SlotTimingInfo slotTime, DlBrdcstAlloc *dlBrdcstAlloc)
 128 {
 129    uint8_t dmrsStartSymbol, startSymbol, numSymbol ;
 130    DmrsInfo dmrs;
 131    FreqDomainAlloc freqAlloc;
 132    TimeDomainAlloc timeAlloc;
 133    SchDlSlotInfo *schDlSlotInfo = NULLP;
 134
 135    if(cell == NULL)
 136    {
 137       DU_LOG("\nERROR  -->  SCH: schBroadcastSsbAlloc() : Cell is NULL");
 138       return RFAILED;
 139    }
 140
 141    if(dlBrdcstAlloc == NULL)
 142    {
 143       DU_LOG("\nERROR  -->  SCH: schBroadcastSsbAlloc() : dlBrdcstAlloc is NULL");
 144       return RFAILED;
 145    }
 146
 147    dmrs = cell->cellCfg.sib1SchCfg.sib1PdschCfg.dmrs;
 148    freqAlloc = cell->cellCfg.sib1SchCfg.sib1PdschCfg.pdschFreqAlloc.freqAlloc;
 149    timeAlloc = cell->cellCfg.sib1SchCfg.sib1PdschCfg.pdschTimeAlloc.timeAlloc;
 150    schDlSlotInfo = cell->schDlSlotInfo[slotTime.slot];
 151
 152    /* Find total symbols used including DMRS */
 153    /* If there are no DRMS symbols, findDmrsStartSymbol() returns MAX_SYMB_PER_SLOT,
 154     * in that case only PDSCH symbols are marked as occupied */
 155    dmrsStartSymbol = findDmrsStartSymbol(dmrs.dlDmrsSymbPos);
 156    if(dmrsStartSymbol == MAX_SYMB_PER_SLOT)
 157    {
 158       startSymbol = timeAlloc.startSymb;
 159       numSymbol = timeAlloc.numSymb;
 160    }
 161    /* If DMRS symbol is found, mark DMRS and PDSCH symbols as occupied */
 162    else
 163    {
 164       startSymbol = dmrsStartSymbol;
 165       numSymbol = dmrs.nrOfDmrsSymbols + timeAlloc.numSymb;
 166    }
 167
 168    /* Allocate PRB */
 169    if((allocatePrbDl(cell, slotTime, startSymbol, numSymbol, &freqAlloc.startPrb, freqAlloc.numPrb)) != ROK)
 170    {
 171        DU_LOG("\nERROR  -->  SCH: PRB allocation failed for SIB1 in SFN:Slot [%d : %d]", slotTime.sfn, slotTime.slot);
 172        return RFAILED;
 173    }
 174
 175    memcpy(&dlBrdcstAlloc->sib1Alloc.bwp, &cell->cellCfg.sib1SchCfg.bwp, sizeof(BwpCfg));
 176    memcpy(&dlBrdcstAlloc->sib1Alloc.sib1PdcchCfg, &cell->cellCfg.sib1SchCfg.sib1PdcchCfg, sizeof(PdcchCfg));
 177    memcpy(&dlBrdcstAlloc->sib1Alloc.sib1PdschCfg, &cell->cellCfg.sib1SchCfg.sib1PdschCfg, sizeof(PdschCfg));
 178    dlBrdcstAlloc->sib1Alloc.sib1PdcchCfg.dci.pdschCfg = &dlBrdcstAlloc->sib1Alloc.sib1PdschCfg;
 179    schDlSlotInfo->sib1Pres = true;
 180    return ROK;
 181 }
 182
 183 /*******************************************************************
 184  *
 185  * @brief Handles sending UL scheduler info to MAC
 186  *
 187  * @details
 188  *
 189  *    Function : sendUlSchInfoToMac
 190  *
 191  *    Functionality:
 192  *     Sends UL Sch info to MAC from SCH
 193  *
 194  * @params[in]
 195  * @return ROK     - success
 196  *         RFAILED - failure
 197  *
 198  * ****************************************************************/
 199 int sendUlSchInfoToMac(UlSchedInfo *ulSchedInfo, Inst inst)
 200 {
 201    Pst pst;
 202
 203    memset(&pst, 0, sizeof(Pst));
 204    FILL_PST_SCH_TO_MAC(pst, inst);
 205    pst.event = EVENT_UL_SCH_INFO;
 206
 207    return(*schMacUlSchInfoOpts[pst.selector])(&pst, ulSchedInfo);
 208 }
 209
 210 /**
 211  * @brief Function to fill Pucch Format 0
 212  *
 213  * @details
 214  *
 215  *     Function : fillPucchFormat0
 216  *
 217  *     Function to fill Pucch format 0
 218  *
 219  *  @param[in]  SchPucchInfo pointer, SchPucchResrcInfo pointer
 220  *  @return  void
 221  **/
 222
 223 void fillPucchFormat0(SchPucchInfo *ulSchedPucch, SchPucchResrcInfo *resrcInfo)
 224 {
 225    if(resrcInfo->SchPucchFormat.format0)
 226    {
 227       ulSchedPucch->fdAlloc.numPrb = PUCCH_NUM_PRB_FORMAT_0_1_4;
 228       ulSchedPucch->pucchFormat  = PUCCH_FORMAT_0;
 229       ulSchedPucch->initialCyclicShift =  resrcInfo->SchPucchFormat.format0->initialCyclicShift;
 230       ulSchedPucch->tdAlloc.numSymb = resrcInfo->SchPucchFormat.format0->numSymbols;
 231       ulSchedPucch->tdAlloc.startSymb = resrcInfo->SchPucchFormat.format0->startSymbolIdx;
 232    }
 233 }
 234
 235 /**
 236  * @brief Function to fill Pucch Format 1
 237  *
 238  * @details
 239  *
 240  *     Function : fillPucchFormat1
 241  *
 242  *     Function to fill Pucch format 1
 243  *
 244  *  @param[in]  SchPucchInfo pointer, SchPucchResrcInfo pointer
 245  *  @return  void
 246  **/
 247
 248 void fillPucchFormat1(SchPucchInfo *ulSchedPucch, SchPucchResrcInfo *resrcInfo)
 249 {
 250    if(resrcInfo->SchPucchFormat.format1)
 251    {
 252       ulSchedPucch->fdAlloc.numPrb = PUCCH_NUM_PRB_FORMAT_0_1_4;
 253       ulSchedPucch->pucchFormat  = PUCCH_FORMAT_1;
 254       ulSchedPucch->initialCyclicShift =  resrcInfo->SchPucchFormat.format1->initialCyclicShift;
 255       ulSchedPucch->tdAlloc.numSymb = resrcInfo->SchPucchFormat.format1->numSymbols;
 256       ulSchedPucch->tdAlloc.startSymb = resrcInfo->SchPucchFormat.format1->startSymbolIdx;
 257       ulSchedPucch->timeDomOCC =  resrcInfo->SchPucchFormat.format1->timeDomOCC;
 258   }
 259 }
 260
 261 /**
 262  * @brief Function to fill Pucch format for UL Sched Info
 263  *
 264  * @details
 265  *
 266  *     Function : fillUlSchedPucchFormat
 267  *
 268  *     Function to fill Pucch format for UL Sched Info
 269  *
 270  *  @param[in]  pucchFormat , SchPucchInfo pointer,
 271  *  @param[in]  SchPucchFormatCfg pointer, SchPucchResrcInfo pointer
 272  *  @return  void
 273  **/
 274
 275 uint8_t fillUlSchedPucchFormat(uint8_t pucchFormat, SchPucchInfo *ulSchedPucch,\
 276    SchPucchResrcInfo *resrcInfo, SchPucchFormatCfg *formatCfg)
 277 {
 278    uint8_t ret = ROK;
 279
 280    switch(pucchFormat)
 281    {
 282       case PUCCH_FORMAT_0:
 283          {
 284             if(resrcInfo)
 285                fillPucchFormat0(ulSchedPucch, resrcInfo);
 286             return ret;
 287          }
 288       case PUCCH_FORMAT_1:
 289          {
 290             if(resrcInfo)
 291             {
 292                fillPucchFormat1(ulSchedPucch, resrcInfo);
 293             }
 294             if(formatCfg)
 295             {
 296                memcpy(&ulSchedPucch->cmnFormatCfg, formatCfg, sizeof(SchPucchFormatCfg));
 297             }
 298             return ret;
 299          }/* To Add support for more Pucch Format */
 300
 301       default:
 302          DU_LOG("\nERROR  --> SCH : Invalid PUCCH format[%d] in fillUlSchedPucchFormatCfg()", pucchFormat);
 303          ret = RFAILED;
 304          return ret;
 305    }
 306    return ret;
 307 }
 308
 309 /**
 310  * @brief Function to fill Pucch Dedicated Cfg for UL Sched Info
 311  *
 312  * @details
 313  *
 314  *     Function : fillUlSchedPucchDedicatedCfg
 315  *
 316  *     Function to fill Pucch Dedicated Cfg for UL Sched Info
 317  *
 318  *  @param[in]  pucchFormat to be filled
 319  *  @param[in]  SchPucchFormatCfg pointer, SchPucchCfg pointer
 320  *  @return  void
 321  **/
 322
 323 uint8_t fillUlSchedPucchDedicatedCfg(uint16_t numSlots, SchPucchCfg *pucchDedCfg,\
 324    SlotTimingInfo *slotInfo, SchPucchInfo *ulSchedPucch)
 325 {
 326    uint8_t ret, resrcSetIdx, resrcIdx, schedReqIdx, srPeriodicity = 0;
 327    uint16_t srOffset = 0;
 328
 329    ret = ROK;
 330    if(pucchDedCfg->resrcSet && pucchDedCfg->resrc)
 331    {
 332       //Assuming one entry in the list
 333       for(resrcSetIdx = 0; resrcSetIdx < pucchDedCfg->resrcSet->resrcSetToAddModListCount; resrcSetIdx++)
 334       {
 335          for(resrcIdx = 0; resrcIdx < pucchDedCfg->resrc->resrcToAddModListCount; resrcIdx++)
 336          {
 337             if(pucchDedCfg->resrcSet->resrcSetToAddModList[resrcSetIdx].resrcList[resrcSetIdx] ==\
 338                pucchDedCfg->resrc->resrcToAddModList[resrcIdx].resrcId)
 339             {
 340                ulSchedPucch->intraFreqHop = pucchDedCfg->resrc->resrcToAddModList[resrcIdx].intraFreqHop;
 341                ulSchedPucch->secondPrbHop = pucchDedCfg->resrc->resrcToAddModList[resrcIdx].secondPrbHop;
 342                ulSchedPucch->fdAlloc.startPrb = pucchDedCfg->resrc->resrcToAddModList[resrcIdx].startPrb;
 343                ulSchedPucch->pucchFormat = pucchDedCfg->resrc->resrcToAddModList[resrcIdx].pucchFormat;
 344                ret = fillUlSchedPucchFormat(ulSchedPucch->pucchFormat, ulSchedPucch,\
 345                         &pucchDedCfg->resrc->resrcToAddModList[resrcIdx], NULLP);
 346                if(ret == RFAILED)
 347                   return ret;
 348             }
 349          }
 350       }
 351    }
 352    if(pucchDedCfg->format1)
 353    {
 354       memset(&ulSchedPucch->cmnFormatCfg, 0, sizeof(SchPucchFormatCfg));
 355       ret = fillUlSchedPucchFormat(ulSchedPucch->pucchFormat, ulSchedPucch, NULLP, pucchDedCfg->format1);
 356       if(ret == RFAILED)
 357          return ret;
 358    }
 359
 360    /* setting SR and UCI flag */
 361    if(pucchDedCfg->schedReq)
 362    {
 363       for(schedReqIdx = 0; schedReqIdx < pucchDedCfg->schedReq->schedAddModListCount; schedReqIdx++)
 364       {
 365          srPeriodicity = pucchDedCfg->schedReq->schedAddModList[schedReqIdx].periodicity;
 366          srOffset      = pucchDedCfg->schedReq->schedAddModList[schedReqIdx].offset;
 367          break;
 368       }
 369       if(((numSlots * slotInfo->sfn + slotInfo->slot - srOffset) % srPeriodicity) == 0)
 370       {
 371          ulSchedPucch->srFlag  = true;
 372          ulSchedPucch->uciFlag = true;
 373       }
 374    }
 375    return ret;
 376 }
 377
 378 /**
 379  * @brief Function to fill Pucch Resource Info
 380  *
 381  * @details
 382  *
 383  *     Function : fillPucchResourceInfo
 384  *
 385  *     Function to fill Pucch Resource Info
 386  *
 387  *  @param[in]  SchPucchInfo *schPucchInfo, Inst inst
 388  *  @return  ROK/RFAILED
 389  **/
 390
 391 uint16_t fillPucchResourceInfo(SchPucchInfo *schPucchInfo, Inst inst)
 392 {
 393    uint8_t ret = ROK, ueIdx = 0, pucchIdx = 0;
 394    SchCellCb  *cell = schCb[inst].cells[inst];
 395    SchPucchCfgCmn *pucchCfg = NULLP;
 396    SchBwpParams *ulBwp = NULLP;
 397
 398    GET_UE_IDX(schPucchInfo->rnti, ueIdx);
 399    if(cell->ueCb[ueIdx].ueCfg.spCellCfg.servCellCfg.initUlBwp.pucchCfgPres)
 400    {
 401       /* fill pucch dedicated cfg */
 402       ret = fillUlSchedPucchDedicatedCfg(cell->numSlots,\
 403        &cell->ueCb[ueIdx].ueCfg.spCellCfg.servCellCfg.initUlBwp.pucchCfg, &cell->slotInfo, schPucchInfo);
 404       if(ret == RFAILED)
 405       {
 406          memset(schPucchInfo, 0, sizeof(SchPucchInfo));
 407          DU_LOG("\nERROR  --> SCH : Filling PUCCH dedicated cfg failed at fillPucchResourceInfo()");
 408          return ret;
 409       }
 410    }
 411    else
 412    {
 413       /* fill pucch common cfg */
 414       /* derive pucchResourceSet from schCellCfg */
 415       pucchCfg = &cell->cellCfg.schInitialUlBwp.pucchCommon;
 416       pucchIdx = pucchCfg->pucchResourceCommon;
 417       ulBwp = &cell->cellCfg.schInitialUlBwp.bwp;
 418       schPucchInfo->fdAlloc.startPrb = ulBwp->freqAlloc.startPrb + pucchResourceSet[pucchIdx][3];
 419       schPucchInfo->fdAlloc.numPrb = PUCCH_NUM_PRB_FORMAT_0_1_4;
 420       schPucchInfo->tdAlloc.startSymb = pucchResourceSet[pucchIdx][1];
 421       schPucchInfo->tdAlloc.numSymb = pucchResourceSet[pucchIdx][2];
 422       schPucchInfo->pucchFormat = pucchResourceSet[pucchIdx][0];
 423
 424       /* set SR and UCI flag to false */
 425       schPucchInfo->srFlag  = true;
 426       schPucchInfo->uciFlag = true;
 427    }
 428    /* set HARQ flag to true */
 429    schPucchInfo->harqFlag = true;
 430    schPucchInfo->numHarqBits = 1; /* 1 bit for HARQ */
 431
 432    return ROK;
 433 }
 434
 435 /**
 436  * @brief resource allocation for UL
 437  *
 438  * @details
 439  *
 440  *     Function : schUlResAlloc
 441  *
 442  *     This function handles UL Resource allocation
 443  *
 444  *  @param[in]  SchCellCb *cell, cellCb
 445  *  @return  void
 446  **/
 447 uint8_t schUlResAlloc(SchCellCb *cell, Inst schInst)
 448 {
 449    int ret = ROK;
 450    UlSchedInfo ulSchedInfo;
 451    SchUlSlotInfo  *schUlSlotInfo = NULLP;
 452    SlotTimingInfo ulTimingInfo;
 453    memset(&ulSchedInfo, 0, sizeof(UlSchedInfo));
 454
 455    /* add PHY delta */
 456    ADD_DELTA_TO_TIME(cell->slotInfo,ulTimingInfo,PHY_DELTA_UL+SCHED_DELTA);
 457
 458    ulSchedInfo.cellId = cell->cellId;
 459    ulSchedInfo.slotIndInfo.cellId = ulSchedInfo.cellId;
 460    ulSchedInfo.slotIndInfo.sfn = ulTimingInfo.sfn;
 461    ulSchedInfo.slotIndInfo.slot = ulTimingInfo.slot;
 462
 463    /* Schedule resources for PRACH */
 464    if(cell->firstSib1Transmitted)
 465     schPrachResAlloc(cell, &ulSchedInfo, ulTimingInfo);
 466
 467    schUlSlotInfo = cell->schUlSlotInfo[ulTimingInfo.slot];
 468    if(schUlSlotInfo->schPuschInfo)
 469    {
 470       ulSchedInfo.crnti = schUlSlotInfo->schPuschInfo->crnti;
 471       ulSchedInfo.dataType |= SCH_DATATYPE_PUSCH;
 472       memcpy(&ulSchedInfo.schPuschInfo, schUlSlotInfo->schPuschInfo,
 473             sizeof(SchPuschInfo));
 474       SCH_FREE(schUlSlotInfo->schPuschInfo, sizeof(SchPuschInfo));
 475       schUlSlotInfo->schPuschInfo = NULL;
 476    }
 477
 478    if(schUlSlotInfo->pucchPres)
 479    {
 480       ulSchedInfo.dataType |= SCH_DATATYPE_UCI;
 481       fillPucchResourceInfo(&schUlSlotInfo->schPucchInfo, schInst);
 482       memcpy(&ulSchedInfo.schPucchInfo, &schUlSlotInfo->schPucchInfo,
 483             sizeof(SchPucchInfo));
 484       memset(&schUlSlotInfo->schPucchInfo, 0, sizeof(SchPucchInfo));
 485    }
 486
 487    //send msg to MAC
 488    ret = sendUlSchInfoToMac(&ulSchedInfo, schInst);
 489    if(ret != ROK)
 490    {
 491       DU_LOG("\nERROR  -->  SCH : Sending UL Sch info from SCH to MAC failed");
 492    }
 493
 494    schInitUlSlot(schUlSlotInfo);
 495    return ret;
 496 }
 497
 498 /*******************************************************************
 499  *
 500  * @brief Fills pdcch and pdsch info for msg4
 501  *
 502  * @details
 503  *
 504  *    Function : schDlRsrcAllocMsg4
 505  *
 506  *    Functionality:
 507  *       Fills pdcch and pdsch info for msg4
 508  *
 509  * @params[in]
 510  * @return ROK     - success
 511  *         RFAILED - failure
 512  *
 513  * ****************************************************************/
 514 uint8_t schDlRsrcAllocMsg4(SchCellCb *cell, SlotTimingInfo slotTime, DlMsgAlloc *msg4Alloc)
 515 {
 516    uint8_t coreset0Idx = 0;
 517    uint8_t firstSymbol = 0;
 518    uint8_t numSymbols = 0;
 519    uint8_t mcs = DEFAULT_MCS;                         /* MCS fixed to 4 */
 520    uint8_t dmrsStartSymbol = 0, startSymbol = 0, numSymbol = 0;
 521    uint16_t tbSize = 0;
 522    uint16_t numRbs;
 523    SchBwpDlCfg *initialBwp = NULLP;
 524    PdcchCfg *pdcch = NULLP;
 525    PdschCfg *pdsch = NULLP;
 526    BwpCfg *bwp = NULLP;
 527
 528    if(cell == NULL)
 529    {
 530       DU_LOG("\nERROR  -->  SCH: schDlRsrcAllocMsg4() : Cell is NULL");
 531       return RFAILED;
 532    }
 533
 534    if(msg4Alloc == NULL)
 535    {
 536       DU_LOG("\nERROR  -->  SCH: schDlRsrcAllocMsg4() :  msg4Alloc is NULL");
 537       return RFAILED;
 538    }
 539
 540    pdcch = &msg4Alloc->dlMsgPdcchCfg;
 541    pdsch = &msg4Alloc->dlMsgPdschCfg;
 542    bwp = &msg4Alloc->bwp;
 543    initialBwp   = &cell->cellCfg.schInitialDlBwp;
 544    coreset0Idx  = initialBwp->pdcchCommon.commonSearchSpace.coresetId;
 545
 546    /* derive the sib1 coreset0 params from table 13-1 spec 38.213 */
 547    numRbs     = coresetIdxTable[coreset0Idx][1];
 548    numSymbols = coresetIdxTable[coreset0Idx][2];
 549
 550    /* calculate time domain parameters */
 551    uint16_t mask = 0x2000;
 552    for(firstSymbol=0; firstSymbol<MAX_SYMB_PER_SLOT; firstSymbol++)
 553    {
 554       if(initialBwp->pdcchCommon.commonSearchSpace.monitoringSymbol & mask)
 555          break;
 556       else
 557          mask = mask>>1;
 558    }
 559
 560    /* fill BWP */
 561    bwp->freqAlloc.numPrb   = initialBwp->bwp.freqAlloc.numPrb;
 562    bwp->freqAlloc.startPrb = initialBwp->bwp.freqAlloc.startPrb;
 563    bwp->subcarrierSpacing  = initialBwp->bwp.scs;
 564    bwp->cyclicPrefix       = initialBwp->bwp.cyclicPrefix;
 565
 566    /* fill the PDCCH PDU */
 567    pdcch->coresetCfg.startSymbolIndex = firstSymbol;
 568    pdcch->coresetCfg.durationSymbols = numSymbols;
 569    memcpy(pdcch->coresetCfg.freqDomainResource, \
 570       cell->cellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.freqDomainRsrc, FREQ_DOM_RSRC_SIZE);
 571
 572    pdcch->coresetCfg.cceRegMappingType = 1; /* coreset0 is always interleaved */
 573    pdcch->coresetCfg.regBundleSize = 6;    /* spec-38.211 sec 7.3.2.2 */
 574    pdcch->coresetCfg.interleaverSize = 2;  /* spec-38.211 sec 7.3.2.2 */
 575    pdcch->coresetCfg.coreSetType = 0;
 576    pdcch->coresetCfg.coreSetSize = numRbs;
 577    pdcch->coresetCfg.shiftIndex = cell->cellCfg.phyCellId;
 578    pdcch->coresetCfg.precoderGranularity = 0; /* sameAsRegBundle */
 579    pdcch->numDlDci = 1;
 580    pdcch->dci.rnti = cell->schDlSlotInfo[slotTime.slot]->dlMsgInfo->crnti;
 581    pdcch->dci.scramblingId = cell->cellCfg.phyCellId;
 582    pdcch->dci.scramblingRnti = 0;
 583    pdcch->dci.cceIndex = 4; /* considering SIB1 is sent at cce 0-1-2-3 */
 584    pdcch->dci.aggregLevel = 4;
 585    pdcch->dci.beamPdcchInfo.numPrgs = 1;
 586    pdcch->dci.beamPdcchInfo.prgSize = 1;
 587    pdcch->dci.beamPdcchInfo.digBfInterfaces = 0;
 588    pdcch->dci.beamPdcchInfo.prg[0].pmIdx = 0;
 589    pdcch->dci.beamPdcchInfo.prg[0].beamIdx[0] = 0;
 590    pdcch->dci.txPdcchPower.powerValue = 0;
 591    pdcch->dci.txPdcchPower.powerControlOffsetSS = 0;
 592
 593    /* fill the PDSCH PDU */
 594    uint8_t cwCount = 0;
 595    pdsch->pduBitmap = 0; /* PTRS and CBG params are excluded */
 596    pdsch->rnti = cell->schDlSlotInfo[slotTime.slot]->dlMsgInfo->crnti;
 597    pdsch->pduIndex = 0;
 598    pdsch->numCodewords = 1;
 599    for(cwCount = 0; cwCount < pdsch->numCodewords; cwCount++)
 600    {
 601       pdsch->codeword[cwCount].targetCodeRate = 308;
 602       pdsch->codeword[cwCount].qamModOrder = 2;
 603       pdsch->codeword[cwCount].mcsIndex = mcs; /* mcs configured to 4 */
 604       pdsch->codeword[cwCount].mcsTable = 0; /* notqam256 */
 605       pdsch->codeword[cwCount].rvIndex = 0;
 606       tbSize = schCalcTbSize(msg4Alloc->dlMsgInfo.dlMsgPduLen + TX_PAYLOAD_HDR_LEN); /* MSG4 size + FAPI header size*/
 607       pdsch->codeword[cwCount].tbSize = tbSize;
 608    }
 609    pdsch->dataScramblingId = cell->cellCfg.phyCellId;
 610    pdsch->numLayers = 1;
 611    pdsch->transmissionScheme = 0;
 612    pdsch->refPoint = 0;
 613    pdsch->dmrs.dlDmrsSymbPos = 4; /* Bitmap value 00000000000100 i.e. using 3rd symbol for PDSCH DMRS */
 614    pdsch->dmrs.dmrsConfigType = 0; /* type-1 */
 615    pdsch->dmrs.dlDmrsScramblingId = cell->cellCfg.phyCellId;
 616    pdsch->dmrs.scid = 0;
 617    pdsch->dmrs.numDmrsCdmGrpsNoData = 1;
 618    pdsch->dmrs.dmrsPorts = 0;
 619    pdsch->dmrs.mappingType      = DMRS_MAP_TYPE_A; /* Setting to Type-A */
 620    pdsch->dmrs.nrOfDmrsSymbols  = NUM_DMRS_SYMBOLS;
 621    pdsch->dmrs.dmrsAddPos       = DMRS_ADDITIONAL_POS;
 622
 623    pdsch->pdschTimeAlloc.timeAlloc.startSymb = 3; /* spec-38.214, Table 5.1.2.1-1 */
 624    pdsch->pdschTimeAlloc.timeAlloc.numSymb = NUM_PDSCH_SYMBOL;
 625
 626    pdsch->pdschFreqAlloc.resourceAllocType = 1; /* RAT type-1 RIV format */
 627    pdsch->pdschFreqAlloc.freqAlloc.startPrb = MAX_NUM_RB;
 628    pdsch->pdschFreqAlloc.freqAlloc.numPrb = schCalcNumPrb(tbSize, mcs, NUM_PDSCH_SYMBOL);
 629    pdsch->pdschFreqAlloc.vrbPrbMapping = 0; /* non-interleaved */
 630
 631    /* Find total symbols occupied including DMRS */
 632    dmrsStartSymbol = findDmrsStartSymbol(pdsch->dmrs.dlDmrsSymbPos);
 633    /* If there are no DRMS symbols, findDmrsStartSymbol() returns MAX_SYMB_PER_SLOT,
 634     * in that case only PDSCH symbols are marked as occupied */
 635    if(dmrsStartSymbol == MAX_SYMB_PER_SLOT)
 636    {
 637       startSymbol = pdsch->pdschTimeAlloc.timeAlloc.startSymb;
 638       numSymbol = pdsch->pdschTimeAlloc.timeAlloc.numSymb;
 639    }
 640    /* If DMRS symbol is found, mark DMRS and PDSCH symbols as occupied */
 641    else
 642    {
 643       startSymbol = dmrsStartSymbol;
 644       numSymbol = pdsch->dmrs.nrOfDmrsSymbols + pdsch->pdschTimeAlloc.timeAlloc.numSymb;
 645    }
 646
 647    /* Allocate the number of PRBs required for RAR PDSCH */
 648    if((allocatePrbDl(cell, slotTime, startSymbol, numSymbol,\
 649       &pdsch->pdschFreqAlloc.freqAlloc.startPrb, pdsch->pdschFreqAlloc.freqAlloc.numPrb)) != ROK)
 650    {
 651       DU_LOG("\nERROR  --> SCH : Resource allocation failed for MSG4");
 652       return RFAILED;
 653    }
 654
 655    pdsch->beamPdschInfo.numPrgs = 1;
 656    pdsch->beamPdschInfo.prgSize = 1;
 657    pdsch->beamPdschInfo.digBfInterfaces = 0;
 658    pdsch->beamPdschInfo.prg[0].pmIdx = 0;
 659    pdsch->beamPdschInfo.prg[0].beamIdx[0] = 0;
 660    pdsch->txPdschPower.powerControlOffset = 0;
 661    pdsch->txPdschPower.powerControlOffsetSS = 0;
 662
 663    pdcch->dci.pdschCfg = pdsch;
 664
 665    return ROK;
 666 }
 667
 668 uint16_t schAllocPucchResource(SchCellCb *cell, uint16_t crnti, uint16_t slot)
 669 {
 670    uint8_t k1 = SCH_DEFAULT_K1, ueIdx = 0, dlToUlAckIdx;
 671    uint16_t pucchSlot = 0;
 672    SchUlSlotInfo  *schUlSlotInfo = NULLP;
 673    SchPucchCfg    *schPucchCfg = NULLP;
 674
 675    GET_UE_IDX(crnti, ueIdx);
 676    if(cell->ueCb[ueIdx].ueCfg.spCellCfg.servCellCfg.initUlBwp.pucchCfgPres)
 677    {
 678       schPucchCfg = &(cell->ueCb[ueIdx].ueCfg.spCellCfg.servCellCfg.initUlBwp.pucchCfg);
 679       if(schPucchCfg->dlDataToUlAck)
 680       {
 681          for(dlToUlAckIdx = 0; dlToUlAckIdx < schPucchCfg->dlDataToUlAck->dlDataToUlAckListCount; dlToUlAckIdx++)
 682          {
 683             //For now considering only the first value in the list
 684             k1 = schPucchCfg->dlDataToUlAck->dlDataToUlAckList[dlToUlAckIdx];
 685             break;
 686          }
 687       }
 688    }
 689
 690    pucchSlot = (slot + k1)  % cell->numSlots;
 691    schUlSlotInfo = cell->schUlSlotInfo[pucchSlot];
 692    memset(&schUlSlotInfo->schPucchInfo, 0, sizeof(SchPucchInfo));
 693
 694    schUlSlotInfo->pucchPres = true;
 695    schUlSlotInfo->schPucchInfo.rnti = crnti;
 696
 697    return ROK;
 698 }
 699
 700 /*******************************************************************
 701  *
 702  * @brief Fills pdcch and pdsch info for dedicated DL msg
 703  *
 704  * @details
 705  *
 706  *    Function : schDlRsrcAllocDlMsg
 707  *
 708  *    Functionality:
 709  *       Fills pdcch and pdsch info for dl msg
 710  *
 711  * @params[in]
 712  * @return ROK     - success
 713  *         RFAILED - failure
 714  *
 715  * ****************************************************************/
 716 uint8_t schDlRsrcAllocDlMsg(SchCellCb *cell, SlotTimingInfo slotTime, uint16_t crnti,
 717                 uint32_t tbSize, DlMsgAlloc *dlMsgAlloc, uint16_t startPRB)
 718 {
 719    uint8_t ueIdx;
 720    PdcchCfg *pdcch = NULLP;
 721    PdschCfg *pdsch = NULLP;
 722    BwpCfg *bwp = NULLP;
 723    SchUeCb ueCb;
 724    SchControlRsrcSet coreset1;
 725    SchPdschConfig pdschCfg;
 726    uint8_t dmrsStartSymbol, startSymbol, numSymbol;
 727
 728    pdcch = &dlMsgAlloc->dlMsgPdcchCfg;
 729    pdsch = &dlMsgAlloc->dlMsgPdschCfg;
 730    bwp = &dlMsgAlloc->bwp;
 731
 732    GET_UE_IDX(crnti, ueIdx);
 733    ueCb  = cell->ueCb[ueIdx-1];
 734    coreset1 = ueCb.ueCfg.spCellCfg.servCellCfg.initDlBwp.pdcchCfg.cRSetToAddModList[0];
 735    pdschCfg = ueCb.ueCfg.spCellCfg.servCellCfg.initDlBwp.pdschCfg;
 736
 737    /* fill BWP */
 738    bwp->freqAlloc.numPrb = MAX_NUM_RB;
 739    bwp->freqAlloc.startPrb = 0;
 740    bwp->subcarrierSpacing = cell->cellCfg.sib1SchCfg.bwp.subcarrierSpacing;
 741    bwp->cyclicPrefix = cell->cellCfg.sib1SchCfg.bwp.cyclicPrefix;
 742
 743    /* fill the PDCCH PDU */
 744    //Considering coreset1 also starts from same symbol as coreset0
 745    pdcch->coresetCfg.startSymbolIndex = coresetIdxTable[0][3];
 746    pdcch->coresetCfg.durationSymbols = coreset1.duration;
 747    memcpy(pdcch->coresetCfg.freqDomainResource, coreset1.freqDomainRsrc, FREQ_DOM_RSRC_SIZE);
 748    pdcch->coresetCfg.cceRegMappingType = coreset1.cceRegMappingType; /* non-interleaved */
 749    pdcch->coresetCfg.regBundleSize = 6;   /* must be 6 for non-interleaved */
 750    pdcch->coresetCfg.interleaverSize = 0; /* NA for non-interleaved */
 751    pdcch->coresetCfg.coreSetType = 1; /* non PBCH coreset */
 752    //Considering number of RBs in coreset1 is same as coreset0
 753    pdcch->coresetCfg.coreSetSize = coresetIdxTable[0][1];
 754    pdcch->coresetCfg.shiftIndex = cell->cellCfg.phyCellId;
 755    pdcch->coresetCfg.precoderGranularity =  coreset1.precoderGranularity;
 756    pdcch->numDlDci = 1;
 757    pdcch->dci.rnti = ueCb.crnti;
 758    pdcch->dci.scramblingId = cell->cellCfg.phyCellId;
 759    pdcch->dci.scramblingRnti = 0;
 760    pdcch->dci.cceIndex = 0; /* 0-3 for UL and 4-7 for DL */
 761    pdcch->dci.aggregLevel = 4;
 762    pdcch->dci.beamPdcchInfo.numPrgs = 1;
 763    pdcch->dci.beamPdcchInfo.prgSize = 1;
 764    pdcch->dci.beamPdcchInfo.digBfInterfaces = 0;
 765    pdcch->dci.beamPdcchInfo.prg[0].pmIdx = 0;
 766    pdcch->dci.beamPdcchInfo.prg[0].beamIdx[0] = 0;
 767    pdcch->dci.txPdcchPower.powerValue = 0;
 768    pdcch->dci.txPdcchPower.powerControlOffsetSS = 0;
 769
 770    /* fill the PDSCH PDU */
 771    uint8_t cwCount = 0;
 772    pdsch->pduBitmap = 0; /* PTRS and CBG params are excluded */
 773    pdsch->rnti = ueCb.crnti;
 774    pdsch->pduIndex = 0;
 775    pdsch->numCodewords = 1;
 776    for(cwCount = 0; cwCount < pdsch->numCodewords; cwCount++)
 777    {
 778       pdsch->codeword[cwCount].targetCodeRate = 308;
 779       pdsch->codeword[cwCount].qamModOrder = ueCb.ueCfg.dlModInfo.modOrder;
 780       pdsch->codeword[cwCount].mcsIndex = ueCb.ueCfg.dlModInfo.mcsIndex;
 781       pdsch->codeword[cwCount].mcsTable = ueCb.ueCfg.dlModInfo.mcsTable;
 782       pdsch->codeword[cwCount].rvIndex = 0;
 783
 784       tbSize +=TX_PAYLOAD_HDR_LEN;
 785       pdsch->codeword[cwCount].tbSize = tbSize;
 786    }
 787    pdsch->dataScramblingId = cell->cellCfg.phyCellId;
 788    pdsch->numLayers = 1;
 789    pdsch->transmissionScheme = 0;
 790    pdsch->refPoint = 0;
 791    pdsch->dmrs.dlDmrsSymbPos = 4; /* Bitmap value 00000000000100 i.e. using 3rd symbol for PDSCH DMRS */
 792    pdsch->dmrs.dmrsConfigType = 0; /* type-1 */
 793    pdsch->dmrs.dlDmrsScramblingId = cell->cellCfg.phyCellId;
 794    pdsch->dmrs.scid = 0;
 795    pdsch->dmrs.numDmrsCdmGrpsNoData = 1;
 796    pdsch->dmrs.dmrsPorts = 0;
 797    pdsch->dmrs.mappingType      = DMRS_MAP_TYPE_A; /* Setting to Type-A */
 798    pdsch->dmrs.nrOfDmrsSymbols  = NUM_DMRS_SYMBOLS;
 799    pdsch->dmrs.dmrsAddPos       = pdschCfg.dmrsDlCfgForPdschMapTypeA.addPos;
 800
 801    pdsch->pdschTimeAlloc.timeAlloc.startSymb = pdschCfg.timeDomRsrcAllociList[0].startSymbol;
 802    pdsch->pdschTimeAlloc.timeAlloc.numSymb = pdschCfg.timeDomRsrcAllociList[0].symbolLength;
 803
 804    pdsch->pdschFreqAlloc.vrbPrbMapping = 0; /* non-interleaved */
 805    pdsch->pdschFreqAlloc.resourceAllocType = 1; /* RAT type-1 RIV format */
 806    pdsch->pdschFreqAlloc.freqAlloc.startPrb = startPRB; /*Start PRB will be already known*/
 807    pdsch->pdschFreqAlloc.freqAlloc.numPrb = schCalcNumPrb(tbSize, ueCb.ueCfg.dlModInfo.mcsIndex, \
 808                    pdschCfg.timeDomRsrcAllociList[0].symbolLength);
 809
 810    /* Find total symbols occupied including DMRS */
 811    dmrsStartSymbol = findDmrsStartSymbol(pdsch->dmrs.dlDmrsSymbPos);
 812    /* If there are no DRMS symbols, findDmrsStartSymbol() returns MAX_SYMB_PER_SLOT,
 813     * in that case only PDSCH symbols are marked as occupied */
 814    if(dmrsStartSymbol == MAX_SYMB_PER_SLOT)
 815    {
 816       startSymbol = pdsch->pdschTimeAlloc.timeAlloc.startSymb;
 817       numSymbol = pdsch->pdschTimeAlloc.timeAlloc.numSymb;
 818    }
 819    /* If DMRS symbol is found, mark DMRS and PDSCH symbols as occupied */
 820    else
 821    {
 822       startSymbol = dmrsStartSymbol;
 823       numSymbol = pdsch->dmrs.nrOfDmrsSymbols + pdsch->pdschTimeAlloc.timeAlloc.numSymb;
 824    }
 825
 826    /* Allocate the number of PRBs required for DL PDSCH */
 827    if((allocatePrbDl(cell, slotTime, startSymbol, numSymbol,\
 828       &pdsch->pdschFreqAlloc.freqAlloc.startPrb, pdsch->pdschFreqAlloc.freqAlloc.numPrb)) != ROK)
 829    {
 830       DU_LOG("\nERROR  --> SCH : allocatePrbDl() failed for DL MSG");
 831       return RFAILED;
 832    }
 833
 834    pdsch->beamPdschInfo.numPrgs = 1;
 835    pdsch->beamPdschInfo.prgSize = 1;
 836    pdsch->beamPdschInfo.digBfInterfaces = 0;
 837    pdsch->beamPdschInfo.prg[0].pmIdx = 0;
 838    pdsch->beamPdschInfo.prg[0].beamIdx[0] = 0;
 839    pdsch->txPdschPower.powerControlOffset = 0;
 840    pdsch->txPdschPower.powerControlOffsetSS = 0;
 841
 842    pdcch->dci.pdschCfg = pdsch;
 843    return ROK;
 844 }
 845
 846 /*******************************************************************
 847  *
 848  * @brief Fills k0 and k1 information table for FDD
 849  *
 850  * @details
 851  *
 852  *    Function : BuildK0K1TableForFdd
 853  *
 854  *    Functionality:
 855  *      Fills k0 and k1 information table for FDD
 856  *
 857  * @params[in] SchCellCb *cell,SchK0K1TimingInfoTbl *k0K1InfoTbl,bool
 858  * pdschCfgCmnPres,uint8_t numTimeDomAlloc, SchPdschCfgCmnTimeDomRsrcAlloc
 859  * cmnTimeDomRsrcAllocList[], SchPdschTimeDomRsrcAlloc
 860  * dedTimeDomRsrcAllocList[], uint8_t ulAckListCount, uint8_t *UlAckTbl
 861  * @return ROK     - success
 862  *         RFAILED - failure
 863  *
 864  * ****************************************************************/
 865 void BuildK0K1TableForFdd(SchCellCb *cell, SchK0K1TimingInfoTbl *k0K1InfoTbl, bool pdschCfgCmnPres,SchPdschCfgCmn pdschCmnCfg,\
 866 SchPdschConfig pdschDedCfg, uint8_t ulAckListCount, uint8_t *UlAckTbl)
 867 {
 868
 869    uint8_t k1TmpVal =0, cfgIdx=0;
 870    uint8_t slotIdx=0, k0Index=0, k1Index=0, numK0=0, numK1=0, numTimeDomAlloc=0;
 871
 872    /* TODO Commented these below lines for resolving warnings. Presently these variable are not
 873     * required but this will require for harq processing */
 874    // uint8_t k0TmpVal = 0;
 875    // SchPdschCfgCmnTimeDomRsrcAlloc cmnTimeDomRsrcAllocList[MAX_NUM_DL_ALLOC];
 876    // SchPdschTimeDomRsrcAlloc dedTimeDomRsrcAllocList[MAX_NUM_DL_ALLOC];
 877
 878    /* Initialization the structure and storing the total slot values. */
 879    memset(k0K1InfoTbl, 0, sizeof(SchK0K1TimingInfoTbl));
 880    k0K1InfoTbl->tblSize = cell->numSlots;
 881
 882    /* Storing time domain resource allocation list based on common or dedicated configuration. */
 883    if(pdschCfgCmnPres == true)
 884    {
 885       numTimeDomAlloc = pdschCmnCfg.numTimeDomAlloc;
 886       for(cfgIdx = 0; cfgIdx<numTimeDomAlloc; cfgIdx++)
 887       {
 888          /*TODO uncomment this line during harq processing */
 889          //cmnTimeDomRsrcAllocList[cfgIdx] = pdschCmnCfg.timeDomRsrcAllocList[cfgIdx];
 890       }
 891    }
 892    else
 893    {
 894       numTimeDomAlloc = pdschDedCfg.numTimeDomRsrcAlloc;
 895       for(cfgIdx = 0; cfgIdx<numTimeDomAlloc; cfgIdx++)
 896       {
 897          /*TODO uncomment this line during harq processing */
 898          //dedTimeDomRsrcAllocList[cfgIdx] = pdschDedCfg.timeDomRsrcAllociList[cfgIdx];
 899       }
 900    }
 901
 902    /* Checking all the slots for K0 and K1 values. */
 903    for(slotIdx = 0; slotIdx < cell->numSlots; slotIdx++)
 904    {
 905       numK0 = 0;
 906       /* Storing the values of k0 based on time domain resource
 907        * allocation list. If the value is unavailable then fill default values,
 908        * As per 38.331 PDSCH-TimeDomainResourceAllocation field descriptions. */
 909       for(k0Index = 0; ((k0Index < numTimeDomAlloc) && (k0Index < MAX_NUM_K0_IDX));  k0Index++)
 910       {
 911          /* TODO These if 0 we will remove during harq processing */
 912 #if 0
 913          if(pdschCfgCmnPres == true)
 914          {
 915             k0TmpVal = cmnTimeDomRsrcAllocList[k0Index].k0;
 916          }
 917          else
 918          {
 919             if(dedTimeDomRsrcAllocList[k0Index].k0 != NULLP)
 920             {
 921                k0TmpVal = *(dedTimeDomRsrcAllocList[k0Index].k0);
 922             }
 923             else
 924             {
 925                k0TmpVal = DEFAULT_K0_VALUE;
 926             }
 927          }
 928 #endif
 929          /* Checking all the Ul Alloc values. If value is less than MIN_NUM_K1_IDX
 930           * then skip else continue storing the values. */
 931          numK1 = 0;
 932          for(k1Index = 0; k1Index < ulAckListCount; k1Index++)
 933          {
 934             k1TmpVal = UlAckTbl[k1Index];
 935             if(k1TmpVal <= MIN_NUM_K1_IDX)
 936             {
 937                continue;
 938             }
 939
 940             k0K1InfoTbl->k0k1TimingInfo[slotIdx].k0Indexes[numK0].k1TimingInfo.k1Indexes[numK1++] = k1Index;
 941             /* TODO Store K1 index where harq feedback will be received in harq table. */
 942          }
 943          if(numK1)
 944          {
 945             k0K1InfoTbl->k0k1TimingInfo[slotIdx].k0Indexes[numK0].k1TimingInfo.numK1 = numK1;
 946             k0K1InfoTbl->k0k1TimingInfo[slotIdx].k0Indexes[numK0].k0Index = k0Index;
 947             numK0++;
 948          }
 949       }
 950       if(numK0)
 951       {
 952          k0K1InfoTbl->k0k1TimingInfo[slotIdx].numK0 = numK0;
 953       }
 954    }
 955 }
 956
 957 /*******************************************************************
 958  *
 959  * @brief Fills k0 and k1 information table
 960  *
 961  * @details
 962  *
 963  *    Function : BuildK0K1Table
 964  *
 965  *    Functionality:
 966  *       Fills K0 and k1 information table
 967  *
 968  * @params[in] SchCellCb *cell,SchK0K1TimingInfoTbl *k0K1InfoTbl,bool
 969  * pdschCfgCmnPres,uint8_t numTimeDomAlloc, SchPdschCfgCmnTimeDomRsrcAlloc
 970  * cmnTimeDomRsrcAllocList[], SchPdschTimeDomRsrcAlloc
 971  * dedTimeDomRsrcAllocList[], uint8_t ulAckListCount, uint8_t *UlAckTbl
 972  * @return ROK     - success
 973  *         RFAILED - failure
 974  *
 975  * ****************************************************************/
 976 void BuildK0K1Table(SchCellCb *cell, SchK0K1TimingInfoTbl *k0K1InfoTbl, bool pdschCfgCmnPres, SchPdschCfgCmn pdschCmnCfg,\
 977 SchPdschConfig pdschDedCfg, uint8_t ulAckListCount, uint8_t *UlAckTbl)
 978 {
 979
 980 #ifdef NR_TDD
 981    SlotConfig  slotCfg;
 982    bool ulSlotPresent = false;
 983    uint8_t k0TmpVal = 0, k1TmpVal =0, tmpSlot=0, startSymbol=0, endSymbol=0, checkSymbol=0;
 984    uint8_t slotIdx=0, k0Index=0, k1Index=0, numK0=0, numK1=0, cfgIdx=0, numTimeDomAlloc =0, totalCfgSlot =0;
 985    SchPdschCfgCmnTimeDomRsrcAlloc cmnTimeDomRsrcAllocList[MAX_NUM_DL_ALLOC];
 986    SchPdschTimeDomRsrcAlloc dedTimeDomRsrcAllocList[MAX_NUM_DL_ALLOC];
 987 #endif
 988
 989    if(cell->cellCfg.dupMode == DUPLEX_MODE_FDD)
 990    {
 991       BuildK0K1TableForFdd(cell, k0K1InfoTbl, pdschCfgCmnPres, pdschCmnCfg, pdschDedCfg, ulAckListCount, UlAckTbl);
 992    }
 993    else
 994    {
 995 #ifdef NR_TDD
 996
 997       /* Initialization the K0K1 structure, total num of slot and calculating the slot pattern length. */
 998       memset(k0K1InfoTbl, 0, sizeof(SchK0K1TimingInfoTbl));
 999       k0K1InfoTbl->tblSize = cell->numSlots;
1000       totalCfgSlot = calculateSlotPatternLength(cell->cellCfg.ssbSchCfg.scsCommon, cell->cellCfg.tddCfg.tddPeriod);
1001
1002       /* Storing time domain resource allocation list based on common or
1003        * dedicated configuration availability. */
1004       if(pdschCfgCmnPres == true)
1005       {
1006          numTimeDomAlloc = pdschCmnCfg.numTimeDomAlloc;
1007          for(cfgIdx = 0; cfgIdx<numTimeDomAlloc; cfgIdx++)
1008          {
1009             cmnTimeDomRsrcAllocList[cfgIdx] = pdschCmnCfg.timeDomRsrcAllocList[cfgIdx];
1010          }
1011       }
1012       else
1013       {
1014          numTimeDomAlloc = pdschDedCfg.numTimeDomRsrcAlloc;
1015          for(cfgIdx = 0; cfgIdx<numTimeDomAlloc; cfgIdx++)
1016          {
1017             dedTimeDomRsrcAllocList[cfgIdx] = pdschDedCfg.timeDomRsrcAllociList[cfgIdx];
1018          }
1019       }
1020
1021       /* Checking all possible indexes for K0 and K1 values. */
1022       for(slotIdx = 0; slotIdx < cell->numSlots; slotIdx++)
1023       {
1024          /* If current slot is UL or FLEXI then Skip because PDCCH is sent only in DL slots. */
1025          slotCfg = schGetSlotSymbFrmt(slotIdx%totalCfgSlot, cell->slotFrmtBitMap);
1026          if(slotCfg == UL_SLOT || slotCfg == FLEXI_SLOT)
1027          {
1028             continue;
1029          }
1030
1031          /* Storing K0 , start symbol and length symbol for further processing.
1032           * If K0 value is not available then we can fill the default values
1033           * given in spec 38.331. */
1034          numK0 = 0;
1035          for(k0Index = 0; ((k0Index < numTimeDomAlloc) && (k0Index < MAX_NUM_K0_IDX)); k0Index++)
1036          {
1037             if(pdschCfgCmnPres == true)
1038             {
1039                k0TmpVal = cmnTimeDomRsrcAllocList[k0Index].k0;
1040                startSymbol = cmnTimeDomRsrcAllocList[k0Index].startSymbol;
1041                endSymbol = startSymbol + cmnTimeDomRsrcAllocList[k0Index].lengthSymbol;
1042             }
1043             else
1044             {
1045                if(dedTimeDomRsrcAllocList[k0Index].k0 != NULLP)
1046                {
1047                   k0TmpVal =  *(dedTimeDomRsrcAllocList[k0Index].k0);
1048                }
1049                else
1050                {
1051                   k0TmpVal = DEFAULT_K0_VALUE;
1052                }
1053                startSymbol = dedTimeDomRsrcAllocList[k0Index].startSymbol;
1054                endSymbol = startSymbol + dedTimeDomRsrcAllocList[k0Index].symbolLength;
1055             }
1056
1057             /* If current slot + k0 is UL then skip the slot
1058              * else if it is DL slot then continue the next steps
1059              * else if it is a FLEXI slot then check symbols of slot, It should not
1060              * contain any UL slot. */
1061             tmpSlot = (slotIdx+k0TmpVal) % totalCfgSlot;
1062             slotCfg = schGetSlotSymbFrmt(tmpSlot, cell->slotFrmtBitMap);
1063             if(slotCfg == UL_SLOT)
1064             {
1065                continue;
1066             }
1067             if(slotCfg == FLEXI_SLOT)
1068             {
1069                for(checkSymbol = startSymbol; checkSymbol<endSymbol; checkSymbol ++)
1070                {
1071                   slotCfg = cell->cellCfg.tddCfg.slotCfg[tmpSlot][checkSymbol];
1072                   if(slotCfg == UL_SLOT)
1073                   {
1074                      continue;
1075                   }
1076                }
1077             }
1078
1079             /* If current slot + k0 + k1 is a DL slot then skip the slot
1080              * else if it is UL slot then store the information
1081              * else if it is FLEXI slot then check the symbols, it must have
1082              * at least one UL symbol. */
1083             numK1 = 0;
1084             for(k1Index = 0; k1Index < ulAckListCount; k1Index++)
1085             {
1086                k1TmpVal = UlAckTbl[k1Index];
1087                if(k1TmpVal > MIN_NUM_K1_IDX)
1088                {
1089                   tmpSlot = (slotIdx+k0TmpVal+k1TmpVal) % totalCfgSlot;
1090                   slotCfg =  schGetSlotSymbFrmt(tmpSlot, cell->slotFrmtBitMap);
1091                   if(slotCfg == DL_SLOT)
1092                   {
1093                      continue;
1094                   }
1095                   if(slotCfg == FLEXI_SLOT)
1096                   {
1097                      for(checkSymbol = 0; checkSymbol< MAX_SYMB_PER_SLOT;checkSymbol++)
1098                      {
1099                         if(cell->cellCfg.tddCfg.slotCfg[tmpSlot][checkSymbol] == UL_SLOT)
1100                         {
1101                            ulSlotPresent = true;
1102                            break;
1103                         }
1104                      }
1105                   }
1106                   if(ulSlotPresent == true || slotCfg ==  UL_SLOT)
1107                   {
1108                      k0K1InfoTbl->k0k1TimingInfo[slotIdx].k0Indexes[numK0].k1TimingInfo.k1Indexes[numK1++] = k1Index;
1109                      /* TODO Store K1 index where harq feedback will be received
1110                       * in harq table. */
1111                   }
1112                }
1113             }
1114
1115             /* Store all the values if all condition satisfies. */
1116             if(numK1)
1117             {
1118                k0K1InfoTbl->k0k1TimingInfo[slotIdx].k0Indexes[numK0].k1TimingInfo.numK1 = numK1;
1119                k0K1InfoTbl->k0k1TimingInfo[slotIdx].k0Indexes[numK0].k0Index = k0Index;
1120                numK0++;
1121             }
1122          }
1123          if(numK0)
1124          {
1125             k0K1InfoTbl->k0k1TimingInfo[slotIdx].numK0 = numK0;
1126          }
1127       }
1128 #endif
1129    }
1130 }
1131
1132 /*******************************************************************
1133 *
1134 * @brief Fills K2 information table for FDD
1135 *
1136 * @details
1137 *
1138 *    Function : BuildK2InfoTableForFdd
1139 *
1140 *    Functionality:
1141 *       Fills K2 information table for FDD
1142 *
1143 * @params[in] SchCellCb *cell,SchPuschTimeDomRsrcAlloc timeDomRsrcAllocList[],
1144 * uint16_t puschSymTblSize,SchK2TimingInfoTbl *k2InfoTbl
1145 * @return ROK     - success
1146 *         RFAILED - failure
1147 *
1148 * ****************************************************************/
1149 void BuildK2InfoTableForFdd(SchCellCb *cell, SchPuschTimeDomRsrcAlloc timeDomRsrcAllocList[], uint16_t puschSymTblSize,\
1150 SchK2TimingInfoTbl *msg3K2InfoTbl, SchK2TimingInfoTbl *k2InfoTbl)
1151 {
1152    uint16_t slotIdx=0, k2Index=0, k2TmpIdx=0, msg3K2TmpIdx=0;
1153
1154    /* Initialization the structure and storing the total slot values. */
1155    memset(k2InfoTbl, 0, sizeof(SchK2TimingInfoTbl));
1156    k2InfoTbl->tblSize = cell->numSlots;
1157    if(msg3K2InfoTbl)
1158       msg3K2InfoTbl->tblSize = cell->numSlots;
1159
1160    /* Checking all possible indexes for K2. */
1161    for(slotIdx = 0; slotIdx < cell->numSlots; slotIdx++)
1162    {
1163       /* Storing K2 values. */
1164       for(k2Index = 0; ((k2Index < puschSymTblSize) && (k2Index < MAX_NUM_K2_IDX)); k2Index++)
1165       {
1166          k2TmpIdx= k2InfoTbl->k2TimingInfo[slotIdx].numK2;
1167          k2InfoTbl->k2TimingInfo[slotIdx].k2Indexes[k2TmpIdx] = k2Index;
1168          k2InfoTbl->k2TimingInfo[slotIdx].numK2++;
1169
1170          /* Updating K2 values for MSG3 */
1171          if(msg3K2InfoTbl)
1172          {
1173             msg3K2TmpIdx = msg3K2InfoTbl->k2TimingInfo[slotIdx].numK2;
1174             msg3K2InfoTbl->k2TimingInfo[slotIdx].k2Indexes[msg3K2TmpIdx] = k2Index;
1175             msg3K2InfoTbl->k2TimingInfo[slotIdx].numK2++;
1176          }
1177       }
1178    }
1179 }
1180
1181 /*******************************************************************
1182  *
1183  * @brief Fills K2 information table
1184  *
1185  * @details
1186  *
1187  *    Function : BuildK2InfoTable
1188  *
1189  *    Functionality:
1190  *       Fills K2 information table
1191  *
1192  * @params[in] SchCellCb *cell,SchPuschTimeDomRsrcAlloc timeDomRsrcAllocList[],
1193  * uint16_t puschSymTblSize, SchK2TimingInfoTbl *k2InfoTbl
1194  * @return ROK     - success
1195  *         RFAILED - failure
1196  *
1197  * ****************************************************************/
1198 void BuildK2InfoTable(SchCellCb *cell, SchPuschTimeDomRsrcAlloc timeDomRsrcAllocList[], uint16_t puschSymTblSize,\
1199 SchK2TimingInfoTbl *msg3K2InfoTbl, SchK2TimingInfoTbl *k2InfoTbl)
1200 {
1201
1202 #ifdef NR_TDD
1203    bool dlSymbolPresent = false;
1204    uint8_t slotIdx=0, k2Index=0, k2Val=0, k2TmpVal=0, msg3K2TmpVal=0, msg3Delta=0, numK2 =0, currentSymbol =0;
1205    uint8_t startSymbol =0, endSymbol =0, checkSymbol=0, totalCfgSlot=0, slotCfg=0;
1206    SlotConfig currentSlot;
1207 #endif
1208
1209    if(cell->cellCfg.dupMode == DUPLEX_MODE_FDD)
1210    {
1211       BuildK2InfoTableForFdd(cell, timeDomRsrcAllocList, puschSymTblSize, msg3K2InfoTbl, k2InfoTbl);
1212    }
1213    else
1214    {
1215 #ifdef NR_TDD
1216
1217       /* Initialization the structure and storing the total slot values. */
1218       memset(k2InfoTbl, 0, sizeof(SchK2TimingInfoTbl));
1219       k2InfoTbl->tblSize = cell->numSlots;
1220       if(msg3K2InfoTbl)
1221          msg3K2InfoTbl->tblSize = cell->numSlots;
1222       totalCfgSlot = calculateSlotPatternLength(cell->cellCfg.ssbSchCfg.scsCommon, cell->cellCfg.tddCfg.tddPeriod);
1223
1224       /* Checking all possible indexes for K2. */
1225       for(slotIdx = 0; slotIdx < cell->numSlots; slotIdx++)
1226       {
1227          currentSlot = schGetSlotSymbFrmt(slotIdx % totalCfgSlot, cell->slotFrmtBitMap);
1228
1229          /* If current slot is UL then skip because PDCCH is sent only in DL slots */
1230          if(currentSlot != UL_SLOT)
1231          {
1232             for(k2Index = 0; ((k2Index < puschSymTblSize) && (k2Index < MAX_NUM_K2_IDX)); k2Index++)
1233             {
1234                /* Storing k2, startSymbol, endSymbol information for further processing.
1235                 * If k2 is absent then fill the default values given in spec 38.331
1236                 * PUSCH-TimeDomainResourceAllocationList field descriptions */
1237                k2Val = timeDomRsrcAllocList[k2Index].k2;
1238                if(!k2Val)
1239                {
1240                   switch(cell->cellCfg.ssbSchCfg.scsCommon)
1241                   {
1242                      case SCS_15KHZ:
1243                         k2Val = DEFAULT_K2_VALUE_FOR_SCS15;
1244                         break;
1245                      case SCS_30KHZ:
1246                         k2Val = DEFAULT_K2_VALUE_FOR_SCS30;
1247                         break;
1248                      case SCS_60KHZ:
1249                         k2Val = DEFAULT_K2_VALUE_FOR_SCS60;
1250                         break;
1251                      case SCS_120KHZ:
1252                         k2Val = DEFAULT_K2_VALUE_FOR_SCS120;
1253                         break;
1254                   }
1255                }
1256
1257                /* Current slot + k2 should be either UL or FLEXI slot.
1258                 * If slot is FLEXI then check all the symbols of that slot,
1259                 * it should not contain any DL or FLEXI slot */
1260                k2TmpVal = (slotIdx + k2Val) % totalCfgSlot;
1261                slotCfg = schGetSlotSymbFrmt(k2TmpVal, cell->slotFrmtBitMap);
1262                if(slotCfg != DL_SLOT)
1263                {
1264                   if(slotCfg == FLEXI_SLOT)
1265                   {
1266                      startSymbol =  timeDomRsrcAllocList[k2Index].startSymbol;
1267                      endSymbol   =  startSymbol+ timeDomRsrcAllocList[k2Index].symbolLength;
1268                      dlSymbolPresent = false;
1269                      for(checkSymbol= startSymbol; checkSymbol<endSymbol; checkSymbol++)
1270                      {
1271                         currentSymbol = cell->cellCfg.tddCfg.slotCfg[k2TmpVal][checkSymbol];
1272                         if(currentSymbol == DL_SLOT || currentSymbol == FLEXI_SLOT)
1273                         {
1274                            dlSymbolPresent = true;
1275                            break;
1276                         }
1277                      }
1278                   }
1279                   /* Store all the values if all condition satisfies. */
1280                   if(dlSymbolPresent != true || slotCfg == UL_SLOT)
1281                   {
1282                      numK2 = k2InfoTbl->k2TimingInfo[slotIdx].numK2;
1283                      k2InfoTbl->k2TimingInfo[slotIdx].k2Indexes[numK2] = k2Index;
1284                      k2InfoTbl->k2TimingInfo[slotIdx].numK2++;
1285                   }
1286                }
1287
1288                if(msg3K2InfoTbl)
1289                {
1290                    msg3Delta = puschDeltaTable[cell->cellCfg.numerology];
1291
1292                   /* Check for K2 for MSG3 */
1293                   /* Current slot + k2 should be either UL or FLEXI slot.
1294                    * If slot is FLEXI then check all the symbols of that slot,
1295                    * it should not contain any DL or FLEXI slot */
1296                   msg3K2TmpVal = (slotIdx + k2Val + msg3Delta) % totalCfgSlot;
1297                   slotCfg = schGetSlotSymbFrmt(msg3K2TmpVal, cell->slotFrmtBitMap);
1298                   if(slotCfg != DL_SLOT)
1299                   {
1300                      if(slotCfg == FLEXI_SLOT)
1301                      {
1302                         startSymbol =  timeDomRsrcAllocList[k2Index].startSymbol;
1303                         endSymbol   =  startSymbol+ timeDomRsrcAllocList[k2Index].symbolLength;
1304                         dlSymbolPresent = false;
1305                         for(checkSymbol= startSymbol; checkSymbol<endSymbol; checkSymbol++)
1306                         {
1307                            currentSymbol = cell->cellCfg.tddCfg.slotCfg[msg3K2TmpVal][checkSymbol];
1308                            if(currentSymbol == DL_SLOT || currentSymbol == FLEXI_SLOT)
1309                            {
1310                               dlSymbolPresent = true;
1311                               break;
1312                            }
1313                         }
1314                      }
1315                      /* Store all the values if all condition satisfies. */
1316                      if(dlSymbolPresent != true || slotCfg == UL_SLOT)
1317                      {
1318                         numK2 = msg3K2InfoTbl->k2TimingInfo[slotIdx].numK2;
1319                         msg3K2InfoTbl->k2TimingInfo[slotIdx].k2Indexes[numK2] = k2Index;
1320                         msg3K2InfoTbl->k2TimingInfo[slotIdx].numK2++;
1321                      }
1322                   }
1323                }
1324             }
1325          }
1326       }
1327 #endif
1328    }
1329 }
1330
1331 /*******************************************************************************************
1332  *
1333  * @brief Allocate the PRB using RRM policy
1334  *
1335  * @details
1336  *
1337  *    Function : prbAllocUsingRRMPolicy
1338  *
1339  *    Functionality:
1340  *      [Step1]: Traverse each Node in the LC list
1341  *      [Step2]: Check whether the LC has ZERO requirement then clean this LC
1342  *      [Step3]: Calcualte the maxPRB for this LC.
1343  *              a. For Dedicated LC, maxPRB = sum of remainingReservedPRB and
1344  *              sharedPRB
1345  *              b. For Default, just SharedPRB count
1346  *      [Step4]: If the LC is the First one to be allocated for this UE then add
1347  *      TX_PAYLODN_LEN to reqBO
1348  *      [Step5]: Calculate the estimate PRB and estimate BO to be allocated
1349  *               based on reqBO and maxPRB left.
1350  *      [Step6]: Based on calculated PRB, Update Reserved PRB and Shared PRB counts
1351  *      [Step7]: Deduce the reqBO based on allocBO and move the LC node to last.
1352  *      [Step8]: Continue the next loop from List->head
1353  *
1354  *      [Loop Exit]:
1355  *        [Exit1]: If all the LCs are allocated in list
1356  *        [Exit2]: If PRBs are exhausted
1357  *
1358  * @params[in] I/P > lcLinkList pointer (LcInfo list)
1359  *             I/P > IsDedicatedPRB (Flag to indicate that RESERVED PRB to use
1360  *             I/P > mcsIdx and PDSCH symbols count
1361  *             I/P & O/P > Shared PRB , reserved PRB Count
1362  *             I/P & O/P > Total TBS size accumulated
1363  *             I/P & O/P > isTxPayloadLenAdded : Decision flag to add the TX_PAYLOAD_HDR_LEN
1364  *
1365  * @return void
1366  *
1367  * *******************************************************************************************/
1368 void prbAllocUsingRRMPolicy(CmLListCp *lcLL, bool isDedicatedPRB, uint16_t mcsIdx,uint8_t numSymbols,\
1369                               uint16_t *sharedPRB, uint16_t *reservedPRB, bool *isTxPayloadLenAdded)
1370 {
1371    CmLList *node = NULLP;
1372    LcInfo *lcNode = NULLP;
1373    uint16_t remReservedPRB = 0, estPrb = 0, maxPRB = 0;
1374
1375    if(lcLL == NULLP)
1376    {
1377       DU_LOG("\nERROR --> SCH: LcList not present");
1378       return;
1379    }
1380    node = lcLL->first;
1381
1382    /*Only for Dedicated LcList, Valid value will be assigned to remReservedPRB
1383     * For Other LcList, remReservedPRB = 0*/
1384    if(reservedPRB != NULLP && isDedicatedPRB == TRUE)
1385    {
1386       remReservedPRB = *reservedPRB;
1387    }
1388
1389    /*[Step1]*/
1390    while(node)
1391    {
1392 #if 0
1393       /*For Debugging purpose*/
1394       printLcLL(lcLL);
1395 #endif
1396       lcNode = (LcInfo *)node->node;
1397
1398       /* [Step2]: Below condition will hit in rare case as it has been taken care during the cleaning
1399        * process of LCID which was fully allocated. Check is just for safety purpose*/
1400       if(lcNode->reqBO == 0 && lcNode->allocBO == 0)
1401       {
1402          DU_LOG("\nERROR --> SCH: LCID:%d has no requirement, clearing this node",\
1403                lcNode->lcId);
1404          deleteNodeFromLList(lcLL, node);
1405          SCH_FREE(lcNode, sizeof(LcInfo));
1406          node = lcLL->first;
1407          continue;
1408       }
1409
1410       /*[Exit1]: All LCs are allocated(allocBO = 0 for fully unallocated LC)*/
1411       if(lcNode->allocBO != 0)
1412       {
1413          DU_LOG("\nWARNING --> SCH: All LC are allocated [SharedPRB:%d]",*sharedPRB);
1414          return;
1415       }
1416
1417       /*[Exit2]: If PRBs are exhausted*/
1418       if(isDedicatedPRB)
1419       {
1420          /*Loop Exit: All resources exhausted*/
1421          if(remReservedPRB == 0 && *sharedPRB == 0)
1422          {
1423             DU_LOG("\nWARNING --> SCH: Dedicated resources exhausted for LC:%d",lcNode->lcId);
1424             return;
1425          }
1426       }
1427       else
1428       {
1429          /*Loop Exit: All resources exhausted*/
1430          if(*sharedPRB == 0)
1431          {
1432             DU_LOG("\nWARNING --> SCH: Default resources exhausted for LC:%d",lcNode->lcId);
1433             return;
1434          }
1435       }
1436
1437       /*[Step3]*/
1438       maxPRB = remReservedPRB + *sharedPRB;
1439
1440       /*[Step4]*/
1441       if(!(*isTxPayloadLenAdded))
1442       {
1443          DU_LOG("\nINFO --> SCH: LC:%d is the First node to be allocated which includes TX_PAYLOAD_HDR_LEN",\
1444                lcNode->lcId);
1445          *isTxPayloadLenAdded = TRUE;
1446          lcNode->allocBO = calculateEstimateTBSize((lcNode->reqBO + TX_PAYLOAD_HDR_LEN),\
1447                mcsIdx, numSymbols, maxPRB, &estPrb);
1448          lcNode->allocBO -=TX_PAYLOAD_HDR_LEN;
1449       }
1450       else
1451       {
1452          /*[Step4]*/
1453          lcNode->allocBO = calculateEstimateTBSize(lcNode->reqBO,\
1454                mcsIdx, numSymbols, maxPRB, &estPrb);
1455       }
1456
1457       /*[Step6]:Re-adjust the reservedPRB pool count and *SharedPRB Count based on
1458        * estimated PRB allocated*/
1459       if((isDedicatedPRB == TRUE) && (estPrb <= remReservedPRB))
1460       {
1461          remReservedPRB = remReservedPRB - estPrb;
1462       }
1463       else   /*LC requirement need PRB share from SharedPRB*/
1464       {
1465          if(*sharedPRB <=  (estPrb - remReservedPRB))
1466          {
1467             DU_LOG("\nINFO --> SCH: SharedPRB is less");
1468             *sharedPRB = 0;
1469          }
1470          else
1471          {
1472             *sharedPRB = *sharedPRB - (estPrb - remReservedPRB);
1473          }
1474          remReservedPRB = 0;
1475       }
1476
1477       /*[Step7]*/
1478       lcNode->reqBO -= lcNode->allocBO;  /*Update the reqBO with remaining bytes unallocated*/
1479       lcNode->allocPRB = estPrb;
1480       cmLListAdd2Tail(lcLL, cmLListDelFrm(lcLL, node));
1481
1482       /*[Step8]:Next loop: First LC to be picked from the list
1483        * because Allocated Nodes are moved to the last*/
1484       node = lcLL->first;
1485
1486    }
1487    return;
1488 }
1489
1490 /*******************************************************************************************
1491  *
1492  * @brief Check the LC List and fill the LC and GrantSize to be sent to MAC as
1493  * BO Report
1494  *
1495  * @details
1496  *
1497  *    Function : updateGrantSizeForBoRpt
1498  *
1499  *    Functionality:
1500  *             Check the LC List and fill the LC and GrantSize to be sent to MAC as
1501  *             BO Report in dlMsgAlloc Pointer
1502  *
1503  * @params[in] I/P > lcLinkList pointer (LcInfo list)
1504  *             I/P & O/P > dlMsgAlloc(Pending LC to be added in this context)
1505  *             I/P & O/P > accumalatedBOSize
1506  * @return void
1507  *
1508  * *******************************************************************************************/
1509 void updateGrantSizeForBoRpt(CmLListCp *lcLL, DlMsgAlloc *dlMsgAlloc, uint32_t *accumalatedBOSize)
1510 {
1511    CmLList *node = NULLP, *next = NULLP;
1512    LcInfo *lcNode = NULLP;
1513
1514    if(lcLL == NULLP)
1515    {
1516       DU_LOG("\nERROR --> SCH: LcList not present");
1517       return;
1518    }
1519
1520    if(lcLL->count)
1521    {
1522       node = lcLL->first;
1523    }
1524    else
1525    {
1526       /*lcLL is empty*/
1527       return;
1528    }
1529
1530    /*Traverse List*/
1531    while(node)
1532    {
1533       next = node->next;
1534       lcNode = (LcInfo *)node->node;
1535       if(lcNode != NULLP)
1536       {
1537          DU_LOG("\nINFO  --> SCH : LcID:%d, [reqBO, allocBO, allocPRB]:[%d,%d,%d]",\
1538                lcNode->lcId, lcNode->reqBO, lcNode->allocBO, lcNode->allocPRB);
1539
1540          /*Add this LC to dlMsgAlloc so that if this LC gets allocated, BO
1541           * report for allocation can be sent to MAC*/
1542          dlMsgAlloc->lcSchInfo[dlMsgAlloc->numLc].lcId = lcNode->lcId;
1543          dlMsgAlloc->lcSchInfo[dlMsgAlloc->numLc].schBytes = lcNode->allocBO;
1544
1545          /*Calculate the Total Payload/BO size allocated*/
1546          *accumalatedBOSize += dlMsgAlloc->lcSchInfo[dlMsgAlloc->numLc].schBytes;
1547
1548          DU_LOG("\nINFO --> SCH: Added in MAC BO report: LCID:%d,reqBO:%d,Idx:%d, TotalBO Size:%d",\
1549                lcNode->lcId,lcNode->reqBO, dlMsgAlloc->numLc, *accumalatedBOSize);
1550
1551          dlMsgAlloc->numLc++;
1552          /*The LC has been fully allocated, clean it*/
1553          if(lcNode->reqBO == 0)
1554          {
1555             handleLcLList(lcLL, lcNode->lcId, DELETE);
1556          }
1557       }
1558       node = next;
1559    }/*End of while*/
1560    return;
1561 }
1562
1563 /**********************************************************************
1564   End of file
1565  **********************************************************************/
1566