src/5gnrsch/sch.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:     sch.c
  22
  23      Type:     C source file
  24
  25      Desc:     C source code for scheduler fucntions
  26
  27      File:     sch.c
  28
  29 **********************************************************************/
  30
  31 /** @file sch.c
  32 @brief This file implements the schedulers main access to MAC layer code.
  33 */
  34 #include "common_def.h"
  35 #include "du_app_mac_inf.h"
  36 #include "lrg.h"
  37 #include "tfu.h"
  38 #include "du_log.h"
  39 #include "rgr.h"
  40 #include "rg_sch_inf.h"
  41 #include "rg_sch.h"
  42
  43 #include "tfu.x"           /* TFU types */
  44 #include "lrg.x"           /* layer management typedefs for MAC */
  45 #include "rgr.x"           /* layer management typedefs for MAC */
  46 #include "rg_sch_inf.x"         /* typedefs for Scheduler */
  47 #include "mac_sch_interface.h"
  48 #include "sch.h"
  49 #include "sch_utils.h"
  50 #include "sch_fcfs.h"
  51 #include "sch_slice_based.h"
  52
  53 /**
  54  * @brief Task Initiation function.
  55  *
  56  * @details
  57  *
  58  *     Function : schActvInit
  59  *
  60  *     This function is supplied as one of parameters during MAC's
  61  *     task registration. MAC will invoke this function once, after
  62  *     it creates and attaches this TAPA Task to a system task.
  63  *
  64  *  @param[in]  Ent Entity, the entity ID of this task.
  65  *  @param[in]  Inst Inst, the instance ID of this task.
  66  *  @param[in]  Region Region, the region ID registered for memory
  67  *              usage of this task.
  68  *  @param[in]  Reason Reason.
  69  *  @return  int
  70  *      -# ROK
  71  **/
  72 uint8_t schActvInit(Ent entity, Inst instId, Region region, Reason reason)
  73 {
  74    Inst inst = (instId  - SCH_INST_START);
  75
  76    /* Initialize the MAC TskInit structure to zero */
  77    memset ((uint8_t *)&schCb[inst], 0, sizeof(schCb));
  78
  79    /* Initialize the MAC TskInit with received values */
  80    schCb[inst].schInit.ent = entity;
  81    schCb[inst].schInit.inst = inst;
  82    schCb[inst].schInit.region = region;
  83    schCb[inst].schInit.pool = 0;
  84    schCb[inst].schInit.reason = reason;
  85    schCb[inst].schInit.cfgDone = FALSE;
  86    schCb[inst].schInit.acnt = FALSE;
  87    schCb[inst].schInit.usta = FALSE;
  88    schCb[inst].schInit.trc = FALSE;
  89    schCb[inst].schInit.procId = ODU_GET_PROCID();
  90
  91    return ROK;
  92 } /* schActvInit */
  93
  94 /**
  95  * @brief Scheduler All Apis initialized.
  96  *
  97  * @details
  98  *
  99  *     Function : schAllApisInit
 100  *
 101  *     This function initializes all Scheduler APIs/functionality for each kind
 102  *     of scheduler type.
 103  *
 104  *  @param[in]  Inst inst, the Scheduler instance
 105  *  @return  void
 106  **/
 107 void schAllApisInit(Inst inst)
 108 {
 109     schFcfsAllApisInit(&schCb[inst].allApis[SCH_FCFS]);
 110     schSliceBasedAllApisInit(&schCb[inst].allApis[SCH_SLICE_BASED]);
 111 }
 112
 113 /**
 114  * @brief Scheduler instance Configuration Handler.
 115  *
 116  * @details
 117  *
 118  *     Function : SchInstCfg
 119  *
 120  *     This function in called by SchProcGenCfgReq(). It handles the
 121  *     general configurations of the scheduler instance. Returns
 122  *     reason for success/failure of this function.
 123  *
 124  *  @param[in]  RgCfg *cfg, the Configuaration information
 125  *  @return  uint16_t
 126  *      -# LCM_REASON_NOT_APPL
 127  *      -# LCM_REASON_INVALID_MSGTYPE
 128  *      -# LCM_REASON_MEM_NOAVAIL
 129  **/
 130 uint8_t SchInstCfg(RgCfg *cfg, Inst  dInst)
 131 {
 132    uint16_t ret = LCM_REASON_NOT_APPL;
 133    Inst     inst = (dInst - SCH_INST_START);
 134
 135    DU_LOG("\nDEBUG  -->  SCH : Entered SchInstCfg()");
 136    /* Check if Instance Configuration is done already */
 137    if (schCb[inst].schInit.cfgDone == TRUE)
 138    {
 139       return LCM_REASON_INVALID_MSGTYPE;
 140    }
 141    /* Update the Pst structure for LM interface */
 142    memcpy(&schCb[inst].schInit.lmPst, &cfg->s.schInstCfg.genCfg.lmPst, sizeof(Pst));
 143
 144    schCb[inst].schInit.inst = inst;
 145    schCb[inst].schInit.lmPst.srcProcId = schCb[inst].schInit.procId;
 146    schCb[inst].schInit.lmPst.srcEnt = schCb[inst].schInit.ent;
 147    schCb[inst].schInit.lmPst.srcInst = schCb[inst].schInit.inst +
 148       SCH_INST_START;
 149    schCb[inst].schInit.lmPst.event = EVTNONE;
 150
 151    schCb[inst].schInit.region = cfg->s.schInstCfg.genCfg.mem.region;
 152    schCb[inst].schInit.pool = cfg->s.schInstCfg.genCfg.mem.pool;
 153    schCb[inst].genCfg.tmrRes = cfg->s.schInstCfg.genCfg.tmrRes;
 154 #ifdef LTE_ADV
 155    schCb[inst].genCfg.forceCntrlSrbBoOnPCel =  cfg->s.schInstCfg.genCfg.forceCntrlSrbBoOnPCel;
 156    schCb[inst].genCfg.isSCellActDeactAlgoEnable =  cfg->s.schInstCfg.genCfg.isSCellActDeactAlgoEnable;
 157 #endif
 158    schCb[inst].genCfg.startCellId    = cfg->s.schInstCfg.genCfg.startCellId;
 159
 160    /* Initialzie the timer queue */
 161    memset(&schCb[inst].tmrTq, 0, sizeof(CmTqType) * SCH_TQ_SIZE);
 162    /* Initialize the timer control point */
 163    memset(&schCb[inst].tmrTqCp, 0, sizeof(CmTqCp));
 164    schCb[inst].tmrTqCp.tmrLen = RGSCH_TQ_SIZE;
 165
 166    /* SS_MT_TMR needs to be enabled as schActvTmr needs instance information */
 167    /* Timer Registration request to system services */
 168    if (ODU_REG_TMR_MT(schCb[inst].schInit.ent, dInst, (int)schCb[inst].genCfg.tmrRes, schActvTmr) != ROK)
 169    {
 170       DU_LOG("\nERROR  -->  SCH : SchInstCfg(): Failed to "
 171             "register timer.");
 172       return (LCM_REASON_MEM_NOAVAIL);
 173    }
 174
 175    /* Set Config done in TskInit */
 176    schCb[inst].schInit.cfgDone = TRUE;
 177    DU_LOG("\nINFO   -->  SCH : Scheduler gen config done");
 178
 179    schAllApisInit(inst);
 180    return ret;
 181 }
 182
 183 /**
 184  * @brief Layer Manager Configuration request handler.
 185  *
 186  * @details
 187  *
 188  *     Function : SchProcGenCfgReq
 189  *
 190  *     This function handles the configuration
 191  *     request received at scheduler instance from the Layer Manager.
 192  *     -# Based on the cfg->hdr.elmId.elmnt value it invokes one of the
 193  *        functions rgHdlGenCfg() or rgHdlSapCfg().
 194  *     -# Invokes RgMiLrgSchCfgCfm() to send back the confirmation to the LM.
 195  *
 196  *  @param[in]  Pst *pst, the post structure
 197  *  @param[in]  RgMngmt *cfg, the configuration parameter's structure
 198  *  @return  S16
 199  *      -# ROK
 200  **/
 201 uint8_t SchProcGenCfgReq(Pst *pst, RgMngmt *cfg)
 202 {
 203    uint8_t   ret = LCM_PRIM_OK;
 204    uint16_t  reason = LCM_REASON_NOT_APPL;
 205    RgMngmt   cfm;
 206    Pst       cfmPst;
 207
 208    if(pst->dstInst < SCH_INST_START)
 209    {
 210       DU_LOG("\nERROR  -->  SCH : Invalid inst ID");
 211       DU_LOG("\nERROR  -->  SCH : SchProcGenCfgReq(): "
 212             "pst->dstInst=%d SCH_INST_START=%d", pst->dstInst,SCH_INST_START);
 213       return ROK;
 214    }
 215    DU_LOG("\nINFO   -->  SCH : Received scheduler gen config");
 216    /* Fill the post structure for sending the confirmation */
 217    memset(&cfmPst, 0 , sizeof(Pst));
 218    SchFillCfmPst(pst, &cfmPst, cfg);
 219
 220    memset(&cfm, 0, sizeof(RgMngmt));
 221
 222 #ifdef LMINT3
 223    cfm.hdr.transId =
 224       cfg->hdr.transId;
 225 #endif
 226
 227    cfm.hdr.elmId.elmnt = cfg->hdr.elmId.elmnt;
 228    switch(cfg->hdr.elmId.elmnt)
 229    {
 230       case STSCHINST:
 231          reason = SchInstCfg(&cfg->t.cfg,pst->dstInst );
 232          break;
 233       default:
 234          ret = LCM_PRIM_NOK;
 235          reason = LCM_REASON_INVALID_ELMNT;
 236          DU_LOG("\nERROR  -->  SCH : Invalid Elmnt=%d", cfg->hdr.elmId.elmnt);
 237          break;
 238    }
 239
 240    if (reason != LCM_REASON_NOT_APPL)
 241    {
 242       ret = LCM_PRIM_NOK;
 243    }
 244
 245    cfm.cfm.status = ret;
 246    cfm.cfm.reason = reason;
 247
 248    SchSendCfgCfm(&cfmPst, &cfm);
 249    /*   SCH_FREE(pst->region, pst->pool, (Data *)cfg, sizeof(RgMngmt)); */
 250
 251    return ROK;
 252 }/*-- SchProcGenCfgReq --*/
 253
 254 #ifdef NR_TDD
 255 /**
 256  *@brief Returns TDD periodicity in micro seconds
 257  *
 258  * @details
 259  *
 260  * Function : schGetPeriodicityInMsec
 261  *
 262  * This API retunrs TDD periodicity in micro seconds
 263  *
 264  * @param[in] DlUlTxPeriodicity
 265  * @return  periodicityInMsec
 266  * **/
 267
 268 uint16_t schGetPeriodicityInMsec(DlUlTxPeriodicity tddPeriod)
 269 {
 270    uint16_t  periodicityInMsec = 0;
 271    switch(tddPeriod)
 272    {
 273       case TX_PRDCTY_MS_0P5:
 274       {
 275          periodicityInMsec = 500;
 276          break;
 277       }
 278       case TX_PRDCTY_MS_0P625:
 279       {
 280          periodicityInMsec = 625;
 281          break;
 282       }
 283       case TX_PRDCTY_MS_1:
 284       {
 285          periodicityInMsec = 1000;
 286          break;
 287       }
 288       case TX_PRDCTY_MS_1P25:
 289       {
 290          periodicityInMsec = 1250;
 291          break;
 292       }
 293       case TX_PRDCTY_MS_2:
 294       {
 295          periodicityInMsec = 2000;
 296          break;
 297       }
 298       case TX_PRDCTY_MS_2P5:
 299       {
 300          periodicityInMsec = 2500;
 301          break;
 302       }
 303       case TX_PRDCTY_MS_5:
 304       {
 305          periodicityInMsec = 5000;
 306          break;
 307       }
 308       case TX_PRDCTY_MS_10:
 309       {
 310          periodicityInMsec = 10000;
 311          break;
 312       }
 313       default:
 314       {
 315          DU_LOG("\nERROR  -->  SCH : Invalid DlUlTxPeriodicity:%d", tddPeriod);
 316       }
 317    }
 318
 319    return periodicityInMsec;
 320 }
 321
 322 /**
 323  *@brief Fills the slotCfg from CellCfg
 324  *
 325  * @details
 326  *
 327  * Function : schFillSlotConfig
 328  *
 329  * This API Fills the slotCfg from CellCfg
 330  *
 331  * @param[in] SchCellCb *cell, TDDCfg tddCfg
 332  * @return  void
 333  * **/
 334 void schFillSlotConfig(SchCellCb *cell, TDDCfg tddCfg)
 335 {
 336    uint8_t slotIdx = 0, symbolIdx = 0;
 337
 338    for(slotIdx =0 ;slotIdx < MAX_TDD_PERIODICITY_SLOTS; slotIdx++)
 339    {
 340       for(symbolIdx = 0; symbolIdx < MAX_SYMB_PER_SLOT; symbolIdx++)
 341       {
 342          /*Fill Full-DL Slots as well as DL symbols ini 1st Flexi Slo*/
 343          if(slotIdx < tddCfg.nrOfDlSlots || \
 344                (slotIdx == tddCfg.nrOfDlSlots && symbolIdx < tddCfg.nrOfDlSymbols))
 345          {
 346               cell->slotCfg[slotIdx][symbolIdx] = DL_SYMBOL;
 347          }
 348
 349          /*Fill Full-FLEXI SLOT and as well as Flexi Symbols in 1 slot preceding FULL-UL slot*/
 350          else if(slotIdx < (MAX_TDD_PERIODICITY_SLOTS - tddCfg.nrOfUlSlots -1) ||  \
 351                (slotIdx == (MAX_TDD_PERIODICITY_SLOTS - tddCfg.nrOfUlSlots -1) && \
 352                 symbolIdx < (MAX_SYMB_PER_SLOT - tddCfg.nrOfUlSymbols)))
 353          {
 354               cell->slotCfg[slotIdx][symbolIdx] = FLEXI_SYMBOL;
 355          }
 356          /*Fill Partial UL symbols and Full-UL slot*/
 357          else
 358          {
 359               cell->slotCfg[slotIdx][symbolIdx] = UL_SYMBOL;
 360          }
 361       }
 362    }
 363 }
 364
 365 /**
 366  * @brief init TDD slot config
 367  *
 368  * @details
 369  *
 370  *     Function : schInitTddSlotCfg
 371  *
 372  *      This API is invoked after receiving schCellCfg
 373  *
 374  *  @param[in]  schCellCb *cell
 375  *  @param[in]  SchCellCfg *schCellCfg
 376  *  @return  void
 377  **/
 378 void schInitTddSlotCfg(SchCellCb *cell, SchCellCfg *schCellCfg)
 379 {
 380    uint16_t periodicityInMicroSec = 0;
 381    int8_t slotIdx, symbIdx;
 382
 383    periodicityInMicroSec = schGetPeriodicityInMsec(schCellCfg->tddCfg.tddPeriod);
 384    cell->numSlotsInPeriodicity = (periodicityInMicroSec * pow(2, schCellCfg->numerology))/1000;
 385    cell->slotFrmtBitMap = 0;
 386    schFillSlotConfig(cell, schCellCfg->tddCfg);
 387    for(slotIdx = cell->numSlotsInPeriodicity-1; slotIdx >= 0; slotIdx--)
 388    {
 389       symbIdx = 0;
 390       /* If the first and last symbol are the same, the entire slot is the same type */
 391       if((cell->slotCfg[slotIdx][symbIdx] == cell->slotCfg[slotIdx][MAX_SYMB_PER_SLOT-1]) &&
 392               cell->slotCfg[slotIdx][symbIdx] != FLEXI_SYMBOL)
 393       {
 394          switch(cell->slotCfg[slotIdx][symbIdx])
 395          {
 396             case DL_SLOT:
 397             {
 398                /*BitMap to be set to 00 */
 399                cell->slotFrmtBitMap = (cell->slotFrmtBitMap<<2);
 400                break;
 401             }
 402             case UL_SLOT:
 403             {
 404                /*BitMap to be set to 01 */
 405                cell->slotFrmtBitMap = ((cell->slotFrmtBitMap<<2) | (UL_SLOT));
 406                break;
 407             }
 408             default:
 409                DU_LOG("\nERROR  -->  SCH : Invalid slot Config in schInitTddSlotCfg");
 410            }
 411          continue;
 412       }
 413       /* slot config is flexible. First set slotBitMap to 10 */
 414       cell->slotFrmtBitMap = ((cell->slotFrmtBitMap<<2) | (FLEXI_SLOT));
 415    }
 416 }
 417 #endif
 418
 419 /**
 420  * @brief Fill SSB start symbol
 421  *
 422  * @details
 423  *
 424  *     Function : fillSsbStartSymb
 425  *
 426  *      This API stores SSB start index per beam
 427  *
 428  *  @param[in]  SchCellCb     *cellCb
 429  *  @return  int
 430  *      -# ROK
 431  *      -# RFAILED
 432  **/
 433 void fillSsbStartSymb(SchCellCb *cellCb)
 434 {
 435    uint8_t cnt, scs, symbIdx, ssbStartSymbArr[SCH_MAX_SSB_BEAM];
 436
 437    scs = cellCb->cellCfg.scsCommon;
 438
 439    memset(ssbStartSymbArr, 0, sizeof(SCH_MAX_SSB_BEAM));
 440    symbIdx = 0;
 441    /* Determine value of "n" based on Section 4.1 of 3GPP TS 38.213 */
 442    switch(scs)
 443    {
 444       case SCS_15KHZ:
 445          {
 446             if(cellCb->cellCfg.ssbFrequency <= 300000)
 447                cnt = 2;/* n = 0, 1 */
 448             else
 449                cnt = 4; /* n = 0, 1, 2, 3 */
 450             for(uint8_t idx=0; idx<cnt; idx++)
 451             {
 452                /* start symbol determined using {2, 8} + 14n */
 453                ssbStartSymbArr[symbIdx++] = 2 +  MAX_SYMB_PER_SLOT*idx;
 454                ssbStartSymbArr[symbIdx++] = 8 +  MAX_SYMB_PER_SLOT*idx;
 455             }
 456          }
 457          break;
 458       case SCS_30KHZ:
 459          {
 460             if(cellCb->cellCfg.ssbFrequency <= 300000)
 461                cnt = 1;/* n = 0 */
 462             else
 463                cnt = 2; /* n = 0, 1 */
 464             for(uint8_t idx=0; idx<cnt; idx++)
 465             {
 466                /* start symbol determined using {4, 8, 16, 20} + 28n */
 467                ssbStartSymbArr[symbIdx++] = 4 +  MAX_SYMB_PER_SLOT*idx;
 468                ssbStartSymbArr[symbIdx++] = 8 +  MAX_SYMB_PER_SLOT*idx;
 469                ssbStartSymbArr[symbIdx++] = 16 +  MAX_SYMB_PER_SLOT*idx;
 470                ssbStartSymbArr[symbIdx++] = 20 +  MAX_SYMB_PER_SLOT*idx;
 471             }
 472          }
 473          break;
 474       default:
 475          DU_LOG("\nERROR  -->  SCH : SCS %d is currently not supported", scs);
 476    }
 477    memset(cellCb->ssbStartSymbArr, 0, sizeof(SCH_MAX_SSB_BEAM));
 478    memcpy(cellCb->ssbStartSymbArr, ssbStartSymbArr, SCH_MAX_SSB_BEAM);
 479 }
 480
 481
 482 /**
 483  * @brief init cellCb based on cellCfg
 484  *
 485  * @details
 486  *
 487  *     Function : schInitCellCb
 488  *
 489  *      This API is invoked after receiving schCellCfg
 490  *
 491  *  @param[in]  schCellCb *cell
 492  *  @param[in]  SchCellCfg *schCellCfg
 493  *  @return  int
 494  *      -# ROK
 495  *      -# RFAILED
 496  **/
 497 uint8_t schInitCellCb(Inst inst, SchCellCfg *schCellCfg)
 498 {
 499    SchCellCb *cell= NULLP;
 500    SCH_ALLOC(cell, sizeof(SchCellCb));
 501    if(!cell)
 502    {
 503       DU_LOG("\nERROR  -->  SCH : Memory allocation failed in schInitCellCb");
 504       return RFAILED;
 505    }
 506
 507    cell->cellId = schCellCfg->cellId;
 508    cell->instIdx = inst;
 509    switch(schCellCfg->numerology)
 510    {
 511       case SCH_NUMEROLOGY_0:
 512          {
 513             cell->numSlots = SCH_MU0_NUM_SLOTS;
 514          }
 515          break;
 516       case SCH_NUMEROLOGY_1:
 517          {
 518             cell->numSlots = SCH_MU1_NUM_SLOTS;
 519          }
 520          break;
 521       case SCH_NUMEROLOGY_2:
 522          {
 523             cell->numSlots = SCH_MU2_NUM_SLOTS;
 524          }
 525          break;
 526       case SCH_NUMEROLOGY_3:
 527          {
 528             cell->numSlots = SCH_MU3_NUM_SLOTS;
 529          }
 530          break;
 531       case SCH_NUMEROLOGY_4:
 532          {
 533             cell->numSlots = SCH_MU4_NUM_SLOTS;
 534          }
 535          break;
 536       default:
 537          DU_LOG("\nERROR  -->  SCH : Numerology %d not supported", schCellCfg->numerology);
 538    }
 539 #ifdef NR_TDD
 540    schInitTddSlotCfg(cell, schCellCfg);
 541 #endif
 542
 543    SCH_ALLOC(cell->schDlSlotInfo, cell->numSlots * sizeof(SchDlSlotInfo*));
 544    if(!cell->schDlSlotInfo)
 545    {
 546       DU_LOG("\nERROR  -->  SCH : Memory allocation failed in schInitCellCb for schDlSlotInfo");
 547       return RFAILED;
 548    }
 549
 550    SCH_ALLOC(cell->schUlSlotInfo, cell->numSlots * sizeof(SchUlSlotInfo*));
 551    if(!cell->schUlSlotInfo)
 552    {
 553       DU_LOG("\nERROR  -->  SCH : Memory allocation failed in schInitCellCb for schUlSlotInfo");
 554       return RFAILED;
 555    }
 556
 557    for(uint8_t idx=0; idx<cell->numSlots; idx++)
 558    {
 559       SchDlSlotInfo *schDlSlotInfo;
 560       SchUlSlotInfo *schUlSlotInfo;
 561
 562       /* DL Alloc */
 563       SCH_ALLOC(schDlSlotInfo, sizeof(SchDlSlotInfo));
 564       if(!schDlSlotInfo)
 565       {
 566          DU_LOG("\nERROR  -->  SCH : Memory allocation failed in schInitCellCb");
 567          return RFAILED;
 568       }
 569
 570       /* UL Alloc */
 571       SCH_ALLOC(schUlSlotInfo, sizeof(SchUlSlotInfo));
 572       if(!schUlSlotInfo)
 573       {
 574          DU_LOG("\nERROR  -->  SCH : Memory allocation failed in schInitCellCb");
 575          return RFAILED;
 576       }
 577
 578       schInitDlSlot(schDlSlotInfo);
 579       schInitUlSlot(schUlSlotInfo);
 580
 581       cell->schDlSlotInfo[idx] = schDlSlotInfo;
 582       cell->schUlSlotInfo[idx] = schUlSlotInfo;
 583
 584    }
 585    cell->firstSsbTransmitted = false;
 586    cell->firstSib1Transmitted = false;
 587    fillSsbStartSymb(cell);
 588
 589 #ifdef NR_DRX
 590    memset(cell->drxCb, 0, MAX_DRX_SIZE*sizeof(SchDrxCb));
 591 #endif
 592    schCb[inst].cells[inst] = cell;
 593
 594    DU_LOG("\nINFO  -->  SCH : Cell init completed for cellId:%d", cell->cellId);
 595
 596    return ROK;
 597 }
 598
 599 /**
 600  * @brief Fill SIB1 configuration
 601  *
 602  * @details
 603  *
 604  *     Function : fillSchSib1Cfg
 605  *
 606  *     Fill SIB1 configuration
 607  *
 608  *  @param[in]  uint8_t bandwidth : total available bandwidth
 609  *              uint8_t numSlots : total slots per SFN
 610  *              SchSib1Cfg *sib1SchCfg : cfg to be filled
 611  *              uint16_t pci : physical cell Id
 612  *              uint8_t offsetPointA : offset
 613  *  @return  void
 614  **/
 615 uint8_t fillSchSib1Cfg(uint8_t mu, uint8_t bandwidth, uint8_t numSlots,SchPdcchConfigSib1 *pdcchCfgSib1,\
 616                SchSib1Cfg *sib1SchCfg, uint16_t pci, uint8_t offsetPointA, uint16_t sib1PduLen)
 617 {
 618    uint8_t coreset0Idx = 0;
 619    uint8_t searchSpace0Idx = 0;
 620    //uint8_t ssbMuxPattern = 0;
 621    uint8_t numRbs = 0;
 622    uint8_t numSymbols = 0;
 623    uint8_t offset = 0;
 624    uint8_t oValue = 0;
 625    //uint8_t numSearchSpacePerSlot = 0;
 626    uint8_t mValue = 0;
 627    uint8_t firstSymbol = 0; /* need to calculate using formula mentioned in 38.213 */
 628    uint8_t slotIndex = 0;
 629    uint8_t FreqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
 630    uint16_t tbSize = 0;
 631    uint8_t ssbIdx = 0;
 632    PdcchCfg *pdcch;
 633    PdschCfg *pdsch;
 634    BwpCfg *bwp;
 635
 636    pdcch = &(sib1SchCfg->sib1PdcchCfg);
 637    bwp = &(sib1SchCfg->bwp);
 638
 639    coreset0Idx     = pdcchCfgSib1->coresetZeroIndex;
 640    searchSpace0Idx = pdcchCfgSib1->searchSpaceZeroIndex;
 641
 642    /* derive the sib1 coreset0 params from table 13-1 spec 38.213 */
 643    //ssbMuxPattern = coresetIdxTable[coreset0Idx][0];
 644    numRbs        = coresetIdxTable[coreset0Idx][1];
 645    numSymbols    = coresetIdxTable[coreset0Idx][2];
 646    offset        = coresetIdxTable[coreset0Idx][3];
 647
 648    /* derive the search space params from table 13-11 spec 38.213 */
 649    oValue                = searchSpaceIdxTable[searchSpace0Idx][0];
 650    //numSearchSpacePerSlot = searchSpaceIdxTable[searchSpace0Idx][1];
 651    mValue                = searchSpaceIdxTable[searchSpace0Idx][2];
 652    firstSymbol           = searchSpaceIdxTable[searchSpace0Idx][3];
 653
 654    /* calculate the n0, need to add the formulae, as of now the value is 0
 655     * Need to add the even and odd values of i during configuration
 656     * [(O . 2^u + i . M )  ] mod numSlotsPerSubframe
 657     * assuming u = 0, i = 0, numSlotsPerSubframe = 10
 658     * Also, from this configuration, coreset0 is only on even subframe */
 659    slotIndex = (int)((oValue*pow(2, mu)) + floor(ssbIdx*mValue))%numSlots;
 660    sib1SchCfg->n0 = slotIndex;
 661
 662    /* fill BWP */
 663    switch(bandwidth)
 664    {
 665       case BANDWIDTH_20MHZ:
 666          {
 667             bwp->freqAlloc.numPrb = TOTAL_PRB_20MHZ_MU0;
 668          }
 669          break;
 670       case BANDWIDTH_100MHZ:
 671          {
 672             bwp->freqAlloc.numPrb = TOTAL_PRB_100MHZ_MU1;
 673          }
 674          break;
 675       default:
 676          DU_LOG("\nERROR  -->  SCH : Bandwidth %d not supported", bandwidth);
 677
 678    }
 679    bwp->freqAlloc.startPrb = 0;
 680    bwp->subcarrierSpacing  = 0;         /* 15Khz */
 681    bwp->cyclicPrefix       = 0;              /* normal */
 682
 683    /* fill the PDCCH PDU */
 684    pdcch->coresetCfg.coreSetSize = numRbs;
 685    pdcch->coresetCfg.startSymbolIndex = firstSymbol;
 686    pdcch->coresetCfg.durationSymbols = numSymbols;
 687
 688    /* Fill Bitmap for PRBs in coreset */
 689    fillCoresetFeqDomAllocMap(((offsetPointA-offset)/6), (numRbs/6), FreqDomainResource);
 690    covertFreqDomRsrcMapToIAPIFormat(FreqDomainResource, pdcch->coresetCfg.freqDomainResource);
 691
 692    pdcch->coresetCfg.cceRegMappingType = 1; /* coreset0 is always interleaved */
 693    pdcch->coresetCfg.regBundleSize = 6;    /* spec-38.211 sec 7.3.2.2 */
 694    pdcch->coresetCfg.interleaverSize = 2;  /* spec-38.211 sec 7.3.2.2 */
 695    pdcch->coresetCfg.coreSetType = 0;
 696    pdcch->coresetCfg.shiftIndex = pci;
 697    pdcch->coresetCfg.precoderGranularity = 0; /* sameAsRegBundle */
 698    pdcch->numDlDci = 1;
 699    pdcch->dci.rnti = SI_RNTI;
 700    pdcch->dci.scramblingId = pci;
 701    pdcch->dci.scramblingRnti = 0;
 702    pdcch->dci.cceIndex = 0;
 703    pdcch->dci.aggregLevel = 4;
 704    pdcch->dci.beamPdcchInfo.numPrgs = 1;
 705    pdcch->dci.beamPdcchInfo.prgSize = 1;
 706    pdcch->dci.beamPdcchInfo.digBfInterfaces = 0;
 707    pdcch->dci.beamPdcchInfo.prg[0].pmIdx = 0;
 708    pdcch->dci.beamPdcchInfo.prg[0].beamIdx[0] = 0;
 709    pdcch->dci.txPdcchPower.beta_pdcch_1_0= 0;
 710    pdcch->dci.txPdcchPower.powerControlOffsetSS = 0;
 711    /* Storing pdschCfg pointer here. Required to access pdsch config while
 712       fillig up pdcch pdu */
 713    SCH_ALLOC(pdcch->dci.pdschCfg, sizeof(PdschCfg));
 714    if(pdcch->dci.pdschCfg == NULLP)
 715    {
 716       DU_LOG("\nERROR  -->  SCH : Memory allocation failed in %s ", __func__);
 717       return RFAILED;
 718    }
 719    pdsch = pdcch->dci.pdschCfg;
 720
 721    /* fill the PDSCH PDU */
 722    uint8_t cwCount = 0;
 723    pdsch->pduBitmap = 0; /* PTRS and CBG params are excluded */
 724    pdsch->rnti = 0xFFFF; /* SI-RNTI */
 725    pdsch->pduIndex = 0;
 726    pdsch->numCodewords = 1;
 727    for(cwCount = 0; cwCount < pdsch->numCodewords; cwCount++)
 728    {
 729       pdsch->codeword[cwCount].targetCodeRate = 308;
 730       pdsch->codeword[cwCount].qamModOrder = 2;
 731       pdsch->codeword[cwCount].mcsIndex = DEFAULT_MCS;
 732       pdsch->codeword[cwCount].mcsTable = 0; /* notqam256 */
 733       pdsch->codeword[cwCount].rvIndex = 0;
 734       tbSize = schCalcTbSize(sib1PduLen + TX_PAYLOAD_HDR_LEN);
 735       pdsch->codeword[cwCount].tbSize = tbSize;
 736    }
 737    pdsch->dataScramblingId                   = pci;
 738    pdsch->numLayers                          = 1;
 739    pdsch->transmissionScheme                 = 0;
 740    pdsch->refPoint                           = 0;
 741    pdsch->dmrs.dlDmrsSymbPos                 = 4; /* Bitmap value 00000000000100 i.e. using 3rd symbol for PDSCH DMRS */
 742    pdsch->dmrs.dmrsConfigType                = 0; /* type-1 */
 743    pdsch->dmrs.dlDmrsScramblingId            = pci;
 744    pdsch->dmrs.scid                          = 0;
 745    pdsch->dmrs.numDmrsCdmGrpsNoData          = 1;
 746    pdsch->dmrs.dmrsPorts                     = 0x0001;
 747    pdsch->dmrs.mappingType                   = DMRS_MAP_TYPE_A; /* Type-A */
 748    pdsch->dmrs.nrOfDmrsSymbols               = NUM_DMRS_SYMBOLS;
 749    pdsch->dmrs.dmrsAddPos                    = DMRS_ADDITIONAL_POS;
 750
 751    pdsch->pdschFreqAlloc.resourceAllocType   = 1; /* RAT type-1 RIV format */
 752    /* the RB numbering starts from coreset0, and PDSCH is always above SSB */
 753    pdsch->pdschFreqAlloc.startPrb  = offsetPointA + SCH_SSB_NUM_PRB;
 754    pdsch->pdschFreqAlloc.numPrb    = schCalcNumPrb(tbSize, DEFAULT_MCS, NUM_PDSCH_SYMBOL);
 755    pdsch->pdschFreqAlloc.vrbPrbMapping       = 0; /* non-interleaved */
 756    pdsch->pdschTimeAlloc.rowIndex            = 1;
 757    /* This is Intel's requirement. PDSCH should start after PDSCH DRMS symbol */
 758    pdsch->pdschTimeAlloc.startSymb = 3; /* spec-38.214, Table 5.1.2.1-1 */
 759    pdsch->pdschTimeAlloc.numSymb   = NUM_PDSCH_SYMBOL;
 760    pdsch->beamPdschInfo.numPrgs              = 1;
 761    pdsch->beamPdschInfo.prgSize              = 1;
 762    pdsch->beamPdschInfo.digBfInterfaces      = 0;
 763    pdsch->beamPdschInfo.prg[0].pmIdx         = 0;
 764    pdsch->beamPdschInfo.prg[0].beamIdx[0]    = 0;
 765    pdsch->txPdschPower.powerControlOffset    = 0;
 766    pdsch->txPdschPower.powerControlOffsetSS  = 0;
 767
 768    return ROK;
 769 }
 770
 771 /**
 772  * @brief cell config from MAC to SCH.
 773  *
 774  * @details
 775  *
 776  *     Function : macSchCellCfgReq
 777  *
 778  *      This API is invoked by MAC to send cell config to SCH
 779  *
 780  *  @param[in]  Pst            *pst
 781  *  @param[in]  SchCellCfg     *schCellCfg
 782  *  @return  int
 783  *      -# ROK
 784  *      -# RFAILED
 785  **/
 786 uint8_t SchProcCellCfgReq(Pst *pst, SchCellCfg *schCellCfg)
 787 {
 788    uint8_t ret = ROK;
 789    SchCellCb *cellCb;
 790    SchCellCfgCfm schCellCfgCfm;
 791    Pst rspPst;
 792    Inst inst = pst->dstInst - SCH_INST_START;
 793    uint8_t coreset0Idx = 0;
 794    uint8_t numRbs = 0;
 795    uint8_t offset = 0;
 796    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
 797    SchPdschConfig pdschCfg;
 798
 799    schInitCellCb(inst, schCellCfg);
 800    cellCb = schCb[inst].cells[inst]; //cells is of MAX_CELLS, why inst
 801    cellCb->macInst = pst->srcInst;
 802
 803    /* derive the SIB1 config parameters */
 804    ret = fillSchSib1Cfg(schCellCfg->numerology, schCellCfg->dlBandwidth, cellCb->numSlots,
 805          &(schCellCfg->pdcchCfgSib1), &(cellCb->sib1SchCfg), schCellCfg->phyCellId,
 806          schCellCfg->dlCfgCommon.schFreqInfoDlSib.offsetToPointA, schCellCfg->sib1PduLen);
 807
 808    if(ret != ROK)
 809    {
 810       DU_LOG("\nERROR --> SCH : Failed to fill sib1 configuration");
 811       return RFAILED;
 812    }
 813    memcpy(&cellCb->cellCfg, schCellCfg, sizeof(SchCellCfg));
 814    schProcPagingCfg(cellCb);
 815
 816    /* Fill coreset frequencyDomainResource bitmap */
 817    coreset0Idx = cellCb->cellCfg.dlCfgCommon.schInitialDlBwp.pdcchCommon.commonSearchSpace.coresetId;
 818    numRbs = coresetIdxTable[coreset0Idx][1];
 819    offset = coresetIdxTable[coreset0Idx][3];
 820    fillCoresetFeqDomAllocMap(((cellCb->cellCfg.dlCfgCommon.schFreqInfoDlSib.offsetToPointA - offset)/6), \
 821                                   (numRbs/6), freqDomainResource);
 822    covertFreqDomRsrcMapToIAPIFormat(freqDomainResource, \
 823       cellCb->cellCfg.dlCfgCommon.schInitialDlBwp.pdcchCommon.commonSearchSpace.freqDomainRsrc);
 824
 825    /* Fill K0 - K1 table for common cfg*/
 826    BuildK0K1Table(cellCb, &cellCb->k0K1InfoTbl, true, cellCb->cellCfg.dlCfgCommon.schInitialDlBwp.pdschCommon,
 827                    pdschCfg, DEFAULT_UL_ACK_LIST_COUNT, defaultUlAckTbl);
 828
 829    BuildK2InfoTable(cellCb, cellCb->cellCfg.ulCfgCommon.schInitialUlBwp.puschCommon.timeDomRsrcAllocList,\
 830    cellCb->cellCfg.ulCfgCommon.schInitialUlBwp.puschCommon.numTimeDomRsrcAlloc, &cellCb->msg3K2InfoTbl, \
 831    &cellCb->k2InfoTbl);
 832
 833    /*As per Spec 38.211, Sec 6.3.3.2; RootSeq Len(Lra) where Lra=839 or Lra=139,
 834     *depending on the PRACH preamble format as given by Tables 6.3.3.1-1 and 6.3.3.1-2.*/
 835    if(prachCfgIdxTable[cellCb->cellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.prachCfgGeneric.prachCfgIdx][0] <= 3)
 836    {
 837       cellCb->cellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.rootSeqLen = ROOT_SEQ_LEN_1;
 838    }
 839    else
 840    {
 841       cellCb->cellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.rootSeqLen = ROOT_SEQ_LEN_2;
 842    }
 843    /* Initializing global variables */
 844    cellCb->actvUeBitMap = 0;
 845    cellCb->boIndBitMap = 0;
 846
 847    cellCb->schHqCfg.maxDlDataHqTx = SCH_MAX_NUM_DL_HQ_TX;
 848    cellCb->schHqCfg.maxMsg4HqTx = SCH_MAX_NUM_MSG4_TX;
 849    cellCb->schHqCfg.maxUlDataHqTx = SCH_MAX_NUM_UL_HQ_TX;
 850    cellCb->maxMsg3Tx = SCH_MAX_NUM_MSG3_TX;
 851
 852    cellCb->schAlgoType = SCH_FCFS;
 853    cellCb->api = &schCb[inst].allApis[cellCb->schAlgoType]; /* For FCFS */
 854    cellCb->api->SchCellCfgReq(cellCb);
 855
 856    /* Fill and send Cell config confirm */
 857    memset(&rspPst, 0, sizeof(Pst));
 858    FILL_PST_SCH_TO_MAC(rspPst, pst->dstInst);
 859    rspPst.event = EVENT_SCH_CELL_CFG_CFM;
 860
 861    schCellCfgCfm.cellId = schCellCfg->cellId;
 862    schCellCfgCfm.rsp = RSP_OK;
 863
 864    ret = MacMessageRouter(&rspPst, (void *)&schCellCfgCfm);
 865    return ret;
 866
 867 }
 868
 869 /*******************************************************************
 870  *
 871  * @brief Fill and send Cell delete response to MAC
 872  *
 873  * @details
 874  *
 875  *    Function :  SchSendCellDeleteRspToMac
 876  *
 877  *    Functionality: Fill and send Cell delete response to MAC
 878  *
 879  * @params[in] SchCellDelete  *ueDelete, Inst inst, SchMacRsp result
 880  * @return ROK     - success
 881  *         RFAILED - failure
 882  *
 883  * ****************************************************************/
 884 uint8_t SchSendCellDeleteRspToMac(SchCellDeleteReq  *ueDelete, Inst inst, SchMacRsp result)
 885 {
 886    Pst rspPst;
 887    uint8_t ret=0;
 888
 889    SchCellDeleteRsp  delRsp;
 890
 891    DU_LOG("\nINFO   --> SCH : Filling Cell Delete response");
 892    memset(&delRsp, 0, sizeof(SchCellDeleteRsp));
 893    delRsp.cellId = ueDelete->cellId;
 894    delRsp.rsp = result;
 895
 896    /* Filling response post */
 897    memset(&rspPst, 0, sizeof(Pst));
 898    FILL_PST_SCH_TO_MAC(rspPst, inst);
 899    rspPst.event = EVENT_CELL_DELETE_RSP_TO_MAC;
 900    ret = MacMessageRouter(&rspPst, (void *)&delRsp);
 901    if(ret == RFAILED)
 902    {
 903       DU_LOG("\nERROR  -->  SCH : SchSendCellDeleteRspToMac(): failed to send the Cell Delete response");
 904       return ret;
 905    }
 906    return ret;
 907 }
 908
 909 /*******************************************************************
 910  *
 911  * @brief Function for cellCb Deletion
 912  *
 913  * @details
 914  *
 915  *    Function : deleteSchCellCb
 916  *
 917  *    Functionality: Function for cellCb Deletion
 918  *
 919  * @params[in] SchCellDelete  *cellDelete
 920  * @return ROK     - success
 921  *         RFAILED - failure
 922  *
 923  * ****************************************************************/
 924 void deleteSchCellCb(SchCellCb *cellCb)
 925 {
 926    uint8_t sliceIdx=0, slotIdx=0, plmnIdx = 0;
 927    CmLListCp *list=NULL;
 928    CmLList *node=NULL, *next=NULL;
 929    SchPageInfo *tempNode = NULLP;
 930
 931    if(cellCb->schDlSlotInfo)
 932    {
 933       for(slotIdx=0; slotIdx<cellCb->numSlots; slotIdx++)
 934       {
 935          list = &cellCb->schDlSlotInfo[slotIdx]->prbAlloc.freePrbBlockList;
 936          node = list->first;
 937          while(node)
 938          {
 939             next = node->next;
 940             SCH_FREE(node->node, sizeof(FreePrbBlock));
 941             deleteNodeFromLList(list, node);
 942             node = next;
 943          }
 944          SCH_FREE(cellCb->schDlSlotInfo[slotIdx], sizeof(SchDlSlotInfo));
 945       }
 946       SCH_FREE(cellCb->schDlSlotInfo, cellCb->numSlots *sizeof(SchDlSlotInfo*));
 947    }
 948
 949    if(cellCb->schUlSlotInfo)
 950    {
 951       for(slotIdx=0; slotIdx<cellCb->numSlots; slotIdx++)
 952       {
 953          list = &cellCb->schUlSlotInfo[slotIdx]->prbAlloc.freePrbBlockList;
 954          node = list->first;
 955          while(node)
 956          {
 957             next = node->next;
 958             SCH_FREE(node->node, sizeof(FreePrbBlock));
 959             deleteNodeFromLList(list, node);
 960             node = next;
 961          }
 962          SCH_FREE(cellCb->schUlSlotInfo[slotIdx], sizeof(SchUlSlotInfo));
 963       }
 964       SCH_FREE(cellCb->schUlSlotInfo,  cellCb->numSlots * sizeof(SchUlSlotInfo*));
 965    }
 966
 967    for(plmnIdx = 0; plmnIdx < MAX_PLMN; plmnIdx++)
 968    {
 969       if(cellCb->cellCfg.plmnInfoList[plmnIdx].snssai)
 970       {
 971          for(sliceIdx=0; sliceIdx<cellCb->cellCfg.plmnInfoList[plmnIdx].numSliceSupport; sliceIdx++)
 972          {
 973             SCH_FREE(cellCb->cellCfg.plmnInfoList[plmnIdx].snssai[sliceIdx], sizeof(Snssai));
 974          }
 975          SCH_FREE(cellCb->cellCfg.plmnInfoList[plmnIdx].snssai, cellCb->cellCfg.plmnInfoList[plmnIdx].numSliceSupport*sizeof(Snssai*));
 976       }
 977    }
 978    SCH_FREE(cellCb->sib1SchCfg.sib1PdcchCfg.dci.pdschCfg, sizeof(PdschCfg));
 979
 980    for(uint16_t idx =0; idx<MAX_SFN; idx++)
 981    {
 982       list = &cellCb->pageCb.pageIndInfoRecord[idx];
 983       node = list->first;
 984       while(node)
 985       {
 986          next = node->next;
 987          if(node->node)
 988          {
 989             tempNode = (SchPageInfo*)(node->node);
 990             SCH_FREE(tempNode->pagePdu, tempNode->msgLen);
 991             SCH_FREE(node->node,  sizeof(SchPageInfo));
 992          }
 993          deleteNodeFromLList(list, node);
 994          node = next;
 995       }
 996    }
 997
 998    cellCb->api->SchCellDeleteReq(cellCb);
 999
1000    memset(cellCb, 0, sizeof(SchCellCb));
1001 }
1002
1003 /*******************************************************************
1004  *
1005  * @brief Function for cell Delete request from MAC to SCH
1006  *
1007  * @details
1008  *
1009  *    Function : SchProcCellDeleteReq
1010  *
1011  *    Functionality: Function for cell Delete request from MAC to SCH
1012  *
1013  * @params[in] Pst *pst, SchCellDelete  *cellDelete
1014  * @return ROK     - success
1015  *         RFAILED - failure
1016  *
1017  * ****************************************************************/
1018 uint8_t SchProcCellDeleteReq(Pst *pst, SchCellDeleteReq  *cellDelete)
1019 {
1020    uint8_t   cellIdx=0, ret = RFAILED;
1021    Inst      inst = pst->dstInst - SCH_INST_START;
1022    SchMacRsp result= RSP_OK;
1023
1024    if(!cellDelete)
1025    {
1026       DU_LOG("\nERROR  -->  SCH : SchProcCellDeleteReq(): Ue Delete request failed");
1027    }
1028    else
1029    {
1030       GET_CELL_IDX(cellDelete->cellId, cellIdx);
1031       if(schCb[inst].cells[cellIdx] == NULLP)
1032       {
1033          DU_LOG("\nERROR  -->  SCH : SchProcCellDeleteReq(): cell Id[%d] is not available", cellDelete->cellId);
1034          result = RSP_NOK;
1035       }
1036       else
1037       {
1038          if(schCb[inst].cells[cellIdx]->cellId == cellDelete->cellId)
1039          {
1040             deleteSchCellCb(schCb[inst].cells[cellIdx]);
1041             result = RSP_OK;
1042             ret = ROK;
1043             SCH_FREE(schCb[inst].cells[cellIdx], sizeof(SchCellCb));
1044             DU_LOG("\nINFO   -->  SCH : Sending Cell Delete response to MAC");
1045          }
1046          else
1047          {
1048             DU_LOG("\nERROR  -->  SCH : SchProcCellDeleteReq(): cell Id[%d] is not available",cellDelete->cellId);
1049             result = RSP_NOK;
1050          }
1051       }
1052
1053       if(SchSendCellDeleteRspToMac(cellDelete, inst, result)!=ROK)
1054       {
1055          DU_LOG("\nERROR  -->  SCH : SchProcCellDeleteReq(): failed to send Cell Delete response");
1056          ret =  RFAILED;
1057       }
1058    }
1059    return ret;
1060 }
1061
1062 /*******************************************************************
1063  *
1064  * @brief Processes DL RLC BO info from MAC
1065  *
1066  * @details
1067  *
1068  *    Function : SchProcDlRlcBoInfo
1069  *
1070  *    Functionality:
1071  *       Processes DL RLC BO info from MAC
1072  *
1073  * @params[in]
1074  * @return ROK     - success
1075  *         RFAILED - failure
1076  *
1077  * ****************************************************************/
1078 uint8_t SchProcDlRlcBoInfo(Pst *pst, DlRlcBoInfo *dlBoInfo)
1079 {
1080    uint8_t  lcId = 0;
1081    uint16_t ueId = 0;
1082    bool isLcIdValid = false;
1083    SchUeCb *ueCb = NULLP;
1084    SchCellCb *cell = NULLP;
1085    Inst  inst = pst->dstInst-SCH_INST_START;
1086
1087    DU_LOG("\nDEBUG  -->  SCH : Received RLC BO Status indication LCId [%d] BO [%d]", dlBoInfo->lcId, dlBoInfo->dataVolume);
1088    cell = schCb[inst].cells[inst];
1089
1090    if(cell == NULLP)
1091    {
1092       DU_LOG("\nERROR  -->  SCH : SchProcDlRlcBoInfo(): Cell does not exists");
1093       return RFAILED;
1094    }
1095
1096    GET_UE_ID(dlBoInfo->crnti, ueId);
1097    ueCb = &cell->ueCb[ueId-1];
1098    if(ueCb->ueCfg.dataTransmissionAction == STOP_DATA_TRANSMISSION)
1099    {
1100       DU_LOG("INFO  --> SCH : DL Data transmission not allowed for UE %d", ueCb->ueCfg.ueId);
1101       return ROK;
1102    }
1103
1104    lcId  = dlBoInfo->lcId;
1105    CHECK_LCID(lcId, isLcIdValid);
1106    if(isLcIdValid == FALSE)
1107    {
1108       DU_LOG("ERROR --> SCH: LCID:%d is not valid", lcId);
1109       return RFAILED;
1110    }
1111
1112    /*Expected when theres a case of Retransmission Failure or Resetablishment
1113     *By Zero BO, the RLC is informing that previous data can be cleared out
1114     *Thus clearing out the LC from the Lc priority list*/
1115    if(dlBoInfo->dataVolume == 0)
1116    {
1117       /* TODO : Check the LC is Dedicated or default and accordingly LCList
1118        * will be used*/
1119       return ROK;
1120    }
1121
1122    if(lcId == SRB0_LCID)
1123    {
1124       cell->raCb[ueId -1].msg4recvd = true;
1125       cell->raCb[ueId -1].dlMsgPduLen = dlBoInfo->dataVolume;
1126    }
1127    else
1128    {
1129       /* TODO : These part of changes will be corrected during DL scheduling as
1130        * per K0 - K1 -K2 */
1131       SET_ONE_BIT(ueId, cell->boIndBitMap);
1132       if(ueCb->dlInfo.dlLcCtxt[lcId].lcId == lcId)
1133       {
1134          ueCb->dlInfo.dlLcCtxt[lcId].bo = dlBoInfo->dataVolume;
1135       }
1136       else
1137       {
1138          DU_LOG("ERROR --> SCH: LCID:%d is not configured in SCH Cb",lcId);
1139          return RFAILED;
1140       }
1141    }
1142    /* Adding UE Id to list of pending UEs to be scheduled */
1143    cell->api->SchDlRlcBoInfo(cell, ueId);
1144    return ROK;
1145 }
1146
1147 /*******************************************************************
1148  *
1149  * @brief Processes BSR indiation from MAC
1150  *
1151  * @details
1152  *
1153  *    Function : SchProcBsr
1154  *
1155  *    Functionality:
1156  *       Processes DL BSR from MAC
1157  *
1158  * @params[in]    Pst pst
1159  *                UlBufferStatusRptInd bsrInd
1160  * @return ROK     - success
1161  *         RFAILED - failure
1162  *
1163  * ****************************************************************/
1164 uint8_t SchProcBsr(Pst *pst, UlBufferStatusRptInd *bsrInd)
1165 {
1166    Inst           schInst       = pst->dstInst-SCH_INST_START;
1167    SchCellCb      *cellCb       = NULLP;
1168    SchUeCb        *ueCb         = NULLP;
1169    uint8_t        lcgIdx = 0;
1170
1171    DU_LOG("\nDEBUG  -->  SCH : Received BSR");
1172    if(bsrInd == NULLP)
1173    {
1174       DU_LOG("\nERROR  -->  SCH : BSR Ind is empty");
1175       return RFAILED;
1176    }
1177    cellCb = schCb[schInst].cells[schInst];
1178    if(cellCb == NULLP)
1179    {
1180       DU_LOG("\nERROR  -->  SCH : CellCb is empty");
1181       return RFAILED;
1182    }
1183    ueCb = schGetUeCb(cellCb, bsrInd->crnti);
1184
1185    if(ueCb == NULLP)
1186    {
1187       DU_LOG("\nERROR  -->  SCH : UeCB is empty");
1188       return RFAILED;
1189    }
1190
1191    if(ueCb->ueCfg.dataTransmissionAction == STOP_DATA_TRANSMISSION)
1192    {
1193       DU_LOG("\nINFO --> SCH: UL Data transmission not allowed for UE %d", ueCb->ueCfg.ueId);
1194       return ROK;
1195    }
1196
1197    ueCb->bsrRcvd = true;
1198    /* store dataVolume per lcg in uecb */
1199    for(lcgIdx = 0; lcgIdx < bsrInd->numLcg; lcgIdx++)
1200    {
1201       ueCb->bsrInfo[bsrInd->dataVolInfo[lcgIdx].lcgId].priority = 1; //TODO: determining LCG priority?
1202       ueCb->bsrInfo[bsrInd->dataVolInfo[lcgIdx].lcgId].dataVol = bsrInd->dataVolInfo[lcgIdx].dataVol;
1203    }
1204
1205    /* Adding UE Id to list of pending UEs to be scheduled */
1206    cellCb->api->SchBsr(cellCb, ueCb->ueId);
1207    return ROK;
1208 }
1209
1210 /*******************************************************************
1211  *
1212  * @brief Processes SR UCI indication from MAC
1213  *
1214  * @details
1215  *
1216  *    Function : SchProcSrUciInd
1217  *
1218  *    Functionality:
1219  *      Processes SR UCI indication from MAC
1220  *
1221  * @params[in] Post structure
1222  *             UCI Indication
1223  * @return ROK     - success
1224  *         RFAILED - failure
1225  *
1226  * ****************************************************************/
1227 uint8_t SchProcSrUciInd(Pst *pst, SrUciIndInfo *uciInd)
1228 {
1229    Inst  inst = pst->dstInst-SCH_INST_START;
1230
1231    SchUeCb   *ueCb;
1232    SchCellCb *cellCb = schCb[inst].cells[inst];
1233
1234    DU_LOG("\nDEBUG  -->  SCH : Received SR");
1235
1236    ueCb = schGetUeCb(cellCb, uciInd->crnti);
1237
1238    if(ueCb->state == SCH_UE_STATE_INACTIVE)
1239    {
1240       DU_LOG("\nERROR  -->  SCH : Crnti %d is inactive", uciInd->crnti);
1241       return ROK;
1242    }
1243    if(ueCb->ueCfg.dataTransmissionAction == STOP_DATA_TRANSMISSION)
1244    {
1245       DU_LOG("\nINFO --> SCH: UL Data transmission not allowed for UE %d", ueCb->ueCfg.ueId);
1246       return ROK;
1247    }
1248    if(uciInd->numSrBits)
1249    {
1250       ueCb->srRcvd = true;
1251       /* Adding UE Id to list of pending UEs to be scheduled */
1252       cellCb->api->SchSrUciInd(cellCb, ueCb->ueId);
1253    }
1254    return ROK;
1255 }
1256
1257 /*******************************************************************
1258  *
1259  * @brief Processes DL HARQ indication from MAC
1260  *
1261  * @details
1262  *
1263  *    Function : SchProcDlHarqInd
1264  *
1265  *    Functionality:
1266  *      Processes DL HARQ indication from MAC
1267  *
1268  * @params[in] Post structure
1269  *             DL HARQ Indication
1270  * @return ROK     - success
1271  *         RFAILED - failure
1272  *
1273  * ****************************************************************/
1274 uint8_t SchProcDlHarqInd(Pst *pst, DlHarqInd *dlHarqInd)
1275 {
1276    Inst  inst = pst->dstInst-SCH_INST_START;
1277    SchUeCb   *ueCb;
1278    SchCellCb *cellCb = schCb[inst].cells[inst];
1279
1280    DU_LOG("\nDEBUG  -->  SCH : Received HARQ");
1281
1282    ueCb = schGetUeCb(cellCb, dlHarqInd->crnti);
1283
1284    if(ueCb->state == SCH_UE_STATE_INACTIVE)
1285    {
1286       DU_LOG("\nERROR  -->  SCH : Crnti %d is inactive", dlHarqInd->crnti);
1287       return ROK;
1288    }
1289
1290    schUpdateHarqFdbk(ueCb, dlHarqInd->numHarq, dlHarqInd->harqPayload, &dlHarqInd->slotInd);
1291
1292    return ROK;
1293 }
1294
1295 /*******************************************************************
1296  *
1297  * @brief Allocates requested PRBs for DL
1298  *
1299  * @details
1300  *
1301  *    Function : allocatePrbDl
1302  *
1303  *    Functionality:
1304  *      Allocates requested PRBs in DL
1305  *      Keeps track of allocated PRB (using bitmap) and remaining PRBs
1306  *
1307  * @params[in] prbAlloc table
1308  *             Start symbol
1309  *             Number of symbols
1310  *             Start PRB
1311  *             Number of PRBs
1312  *
1313  * @return ROK     - success
1314  *         RFAILED - failure
1315  *
1316  * ****************************************************************/
1317 uint8_t allocatePrbDl(SchCellCb *cell, SlotTimingInfo slotTime, \
1318    uint8_t startSymbol, uint8_t symbolLength, uint16_t *startPrb, uint16_t numPrb)
1319 {
1320    uint8_t        symbol = 0;
1321    uint16_t       broadcastPrbStart=0, broadcastPrbEnd=0;
1322    FreePrbBlock   *freePrbBlock = NULLP;
1323    CmLList        *freePrbNode = NULLP;
1324    PduTxOccsaion  ssbOccasion=0, sib1Occasion=0;
1325    SchDlSlotInfo  *schDlSlotInfo = cell->schDlSlotInfo[slotTime.slot];
1326    SchPrbAlloc    *prbAlloc = &schDlSlotInfo->prbAlloc;
1327
1328    /* If startPrb is set to MAX_NUM_RB, it means startPrb is not known currently.
1329     * Search for an appropriate location in PRB grid and allocate requested resources */
1330    if(*startPrb == MAX_NUM_RB)
1331    {
1332       /* Check if SSB/SIB1 is also scheduled in this slot  */
1333       ssbOccasion = schCheckSsbOcc(cell, slotTime);
1334       sib1Occasion = schCheckSib1Occ(cell, slotTime);
1335
1336       if(ssbOccasion && sib1Occasion)
1337       {
1338          broadcastPrbStart = cell->cellCfg.dlCfgCommon.schFreqInfoDlSib.offsetToPointA;
1339          broadcastPrbEnd = broadcastPrbStart + SCH_SSB_NUM_PRB + cell->sib1SchCfg.sib1PdcchCfg.dci.pdschCfg->pdschFreqAlloc.numPrb -1;
1340       }
1341       else if(ssbOccasion)
1342       {
1343          broadcastPrbStart = cell->cellCfg.dlCfgCommon.schFreqInfoDlSib.offsetToPointA;
1344          broadcastPrbEnd = broadcastPrbStart + SCH_SSB_NUM_PRB -1;
1345       }
1346       else if(sib1Occasion)
1347       {
1348          broadcastPrbStart = cell->sib1SchCfg.sib1PdcchCfg.dci.pdschCfg->pdschFreqAlloc.startPrb;
1349          broadcastPrbEnd = broadcastPrbStart + cell->sib1SchCfg.sib1PdcchCfg.dci.pdschCfg->pdschFreqAlloc.numPrb -1;
1350       }
1351
1352       /* Iterate through all free PRB blocks */
1353       freePrbNode = prbAlloc->freePrbBlockList.first;
1354       while(freePrbNode)
1355       {
1356          freePrbBlock = (FreePrbBlock *)freePrbNode->node;
1357
1358          /* If broadcast message is scheduled in this slot, then check if its PRBs belong to the current free block.
1359           * Since SSB/SIB1 PRB location is fixed, these PRBs cannot be allocated to other message in same slot */
1360          if((ssbOccasion || sib1Occasion) &&
1361             ((broadcastPrbStart >= freePrbBlock->startPrb) && (broadcastPrbStart <= freePrbBlock->endPrb)) && \
1362             ((broadcastPrbEnd >= freePrbBlock->startPrb) && (broadcastPrbEnd <= freePrbBlock->endPrb)))
1363          {
1364             /* Implmentation is done such that highest-numbered free-RB is allocated first */
1365             if((freePrbBlock->endPrb > broadcastPrbEnd) && ((freePrbBlock->endPrb - broadcastPrbEnd) >= numPrb))
1366             {
1367                /* If sufficient free PRBs are available above bradcast message then,
1368                 * endPrb = freePrbBlock->endPrb
1369                 * startPrb = endPrb - numPrb +1;
1370                 */
1371                *startPrb = freePrbBlock->endPrb - numPrb +1;
1372                break;
1373             }
1374             else if((broadcastPrbStart > freePrbBlock->startPrb) && ((broadcastPrbStart - freePrbBlock->startPrb) >= numPrb))
1375             {
1376                /* If free PRBs are available below broadcast message then,
1377                 * endPrb = broadcastPrbStart - 1
1378                 * startPrb = endPrb - numPrb +1
1379                 */
1380                *startPrb = broadcastPrbStart - numPrb;
1381                break;
1382             }
1383             else
1384             {
1385                freePrbNode = freePrbNode->next;
1386                continue;
1387             }
1388          }
1389          else
1390          {
1391             /* Check if requested number of blocks can be allocated from the current block */
1392             if (freePrbBlock->numFreePrb < numPrb)
1393             {
1394                freePrbNode = freePrbNode->next;
1395                continue;
1396             }
1397             *startPrb = freePrbBlock->endPrb - numPrb +1;
1398             break;
1399          }
1400       }
1401
1402       /* If no free block can be used to allocated request number of RBs */
1403       if(*startPrb == MAX_NUM_RB)
1404          return RFAILED;
1405    }
1406
1407    /* If startPrb is known already, check if requested PRBs are available for allocation */
1408    else
1409    {
1410       freePrbNode = isPrbAvailable(&prbAlloc->freePrbBlockList, *startPrb, numPrb);
1411       if(!freePrbNode)
1412       {
1413          DU_LOG("\nERROR  -->  SCH: Requested DL PRB unavailable");
1414          return RFAILED;
1415       }
1416    }
1417
1418    /* Update bitmap to allocate PRBs */
1419    for(symbol=startSymbol; symbol < (startSymbol+symbolLength); symbol++)
1420    {
1421       if(fillPrbBitmap(prbAlloc->prbBitMap[symbol], *startPrb, numPrb) != ROK)
1422       {
1423          DU_LOG("\nERROR  -->  SCH: fillPrbBitmap() failed for symbol [%d] in DL", symbol);
1424          return RFAILED;
1425       }
1426    }
1427
1428    /* Update the remaining number for free PRBs */
1429    removeAllocatedPrbFromFreePrbList(&prbAlloc->freePrbBlockList, freePrbNode, *startPrb, numPrb);
1430
1431    return ROK;
1432 }
1433
1434 /*******************************************************************
1435  *
1436  * @brief Allocates requested PRBs for UL
1437  *
1438  * @details
1439  *
1440  *    Function : allocatePrbUl
1441  *
1442  *    Functionality:
1443  *      Allocates requested PRBs in UL
1444  *      Keeps track of allocated PRB (using bitmap) and remaining PRBs
1445  *
1446  * @params[in] prbAlloc table
1447  *             Start symbol
1448  *             Number of symbols
1449  *             Start PRB
1450  *             Number of PRBs
1451  *
1452  * @return ROK     - success
1453  *         RFAILED - failure
1454  *
1455  * ****************************************************************/
1456 uint8_t allocatePrbUl(SchCellCb *cell, SlotTimingInfo slotTime, \
1457    uint8_t startSymbol, uint8_t symbolLength, uint16_t *startPrb, uint16_t numPrb)
1458 {
1459    uint8_t        symbol = 0;
1460    uint16_t       prachStartPrb, prachNumPrb, prachEndPrb;
1461    bool           isPrachOccasion;
1462    FreePrbBlock   *freePrbBlock = NULLP;
1463    CmLList        *freePrbNode = NULLP;
1464    SchPrbAlloc    *prbAlloc = NULLP;
1465
1466    if(cell == NULLP)
1467    {
1468       DU_LOG("\nERROR  --> SCH : allocatePrbUl(): Received cellCb is null");
1469       return RFAILED;
1470    }
1471
1472    prbAlloc =   &cell->schUlSlotInfo[slotTime.slot]->prbAlloc;
1473    /* If startPrb is set to MAX_NUM_RB, it means startPrb is not known currently.
1474     * Search for an appropriate location in PRB grid and allocate requested resources */
1475    if(*startPrb == MAX_NUM_RB)
1476    {
1477       /* Check if PRACH is also scheduled in this slot */
1478       isPrachOccasion = schCheckPrachOcc(cell, slotTime);
1479       if(isPrachOccasion)
1480       {
1481          prachStartPrb =  cell->cellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.prachCfgGeneric.msg1FreqStart;
1482          prachNumPrb = schCalcPrachNumRb(cell);
1483          prachEndPrb = prachStartPrb + prachNumPrb -1;
1484       }
1485
1486       /* Iterate through all free PRB blocks */
1487       freePrbNode = prbAlloc->freePrbBlockList.first;
1488       while(freePrbNode)
1489       {
1490          freePrbBlock = (FreePrbBlock *)freePrbNode->node;
1491
1492          /* If PRACH is scheduled in this slot, then check if its PRBs belong to the current free block.
1493           * PRBs required for PRACH cannot be allocated to any other message */
1494          if((isPrachOccasion) &&
1495             ((prachStartPrb >= freePrbBlock->startPrb) && (prachStartPrb <= freePrbBlock->endPrb)) &&
1496             ((prachEndPrb >= freePrbBlock->startPrb) && (prachEndPrb <= freePrbBlock->endPrb)))
1497          {
1498             /* Implmentation is done such that highest-numbered free-RB is allocated first */
1499             if((freePrbBlock->endPrb > prachEndPrb) && ((freePrbBlock->endPrb - prachEndPrb) >= numPrb))
1500             {
1501                /* If sufficient free PRBs are available above PRACH message then,
1502                 * endPrb = freePrbBlock->endPrb
1503                 * startPrb = endPrb - numPrb +1;
1504                 */
1505                *startPrb = freePrbBlock->endPrb - numPrb +1;
1506                break;
1507             }
1508             else if((prachStartPrb > freePrbBlock->startPrb) && ((prachStartPrb - freePrbBlock->startPrb) >= numPrb))
1509             {
1510                /* If free PRBs are available below PRACH message then,
1511                 * endPrb = prachStartPrb - 1
1512                 * startPrb = endPrb - numPrb +1
1513                 */
1514                *startPrb = prachStartPrb - numPrb;
1515                break;
1516             }
1517             else
1518             {
1519                freePrbNode = freePrbNode->next;
1520                continue;
1521             }
1522          }
1523          else
1524          {
1525             /* Check if requested number of PRBs can be allocated from currect block */
1526             if(freePrbBlock->numFreePrb < numPrb)
1527             {
1528                freePrbNode = freePrbNode->next;
1529                continue;
1530             }
1531             *startPrb = freePrbBlock->endPrb - numPrb +1;
1532             break;
1533          }
1534       }
1535
1536       /* If no free block can be used to allocated requested number of RBs */
1537       if(*startPrb == MAX_NUM_RB)
1538          return RFAILED;
1539    }
1540    else
1541    {
1542       /* If startPrb is known already, check if requested PRBs are available for allocation */
1543       freePrbNode = isPrbAvailable(&prbAlloc->freePrbBlockList, *startPrb, numPrb);
1544       if(!freePrbNode)
1545       {
1546          DU_LOG("\nERROR  -->  SCH: Requested UL PRB unavailable");
1547          return RFAILED;
1548       }
1549    }
1550
1551    /* Update bitmap to allocate PRBs */
1552    for(symbol=startSymbol; symbol < (startSymbol+symbolLength); symbol++)
1553    {
1554       if(fillPrbBitmap(prbAlloc->prbBitMap[symbol], *startPrb, numPrb) != ROK)
1555       {
1556          DU_LOG("\nERROR  -->  SCH: fillPrbBitmap() failed for symbol [%d] in UL", symbol);
1557          return RFAILED;
1558       }
1559    }
1560
1561    /* Update the remaining number for free PRBs */
1562    removeAllocatedPrbFromFreePrbList(&prbAlloc->freePrbBlockList, freePrbNode, *startPrb, numPrb);
1563
1564    return ROK;
1565 }
1566
1567 /*******************************************************************************
1568  *
1569  * @brief Try to find Best Free Block with Max Num PRB
1570  *
1571  * @details
1572  *
1573  *    Function : searchLargestFreeBlock
1574  *
1575  *    Functionality:
1576  *     Finds the FreeBlock with MaxNum of FREE PRB considering SSB/SIB1 ocassions.
1577  *
1578  * @params[in] I/P > prbAlloc table (FreeBlock list)
1579  *             I/P > Slot timing Info
1580  *             O/P > Start PRB
1581  *             I/P > Direction (UL/DL)
1582  *
1583  *
1584  * @return Max Number of Free PRB
1585  *         If 0, then no Suitable Free Block
1586  *
1587  * ********************************************************************************/
1588
1589 uint16_t searchLargestFreeBlock(SchCellCb *cell, SlotTimingInfo slotTime,uint16_t *startPrb, Direction dir)
1590 {
1591    uint16_t       reservedPrbStart=0, reservedPrbEnd=0, maxFreePRB = 0;
1592    FreePrbBlock   *freePrbBlock = NULLP;
1593    CmLList        *freePrbNode = NULLP;
1594    SchPrbAlloc    *prbAlloc = NULLP;
1595    bool           checkOccasion = FALSE;
1596
1597    *startPrb = 0; /*Initialize the StartPRB to zero*/
1598
1599    /*Based on Direction, Reserved Messsages will differi.e.
1600     * DL >> SSB and SIB1 ocassions wheres for UL, PRACH ocassions to be checked
1601     * and reserved before allocation for dedicated DL/UL msg*/
1602    if(dir == DIR_DL)
1603    {
1604       SchDlSlotInfo  *schDlSlotInfo = cell->schDlSlotInfo[slotTime.slot];
1605       PduTxOccsaion  ssbOccasion=0, sib1Occasion=0;
1606
1607       prbAlloc = &schDlSlotInfo->prbAlloc;
1608
1609       ssbOccasion = schCheckSsbOcc(cell, slotTime);
1610       sib1Occasion = schCheckSib1Occ(cell, slotTime);
1611
1612       checkOccasion = TRUE;
1613       if(ssbOccasion && sib1Occasion)
1614       {
1615          reservedPrbStart = cell->cellCfg.dlCfgCommon.schFreqInfoDlSib.offsetToPointA;
1616          reservedPrbEnd = reservedPrbStart + SCH_SSB_NUM_PRB + \
1617                           cell->sib1SchCfg.sib1PdcchCfg.dci.pdschCfg->pdschFreqAlloc.numPrb -1;
1618       }
1619       else if(ssbOccasion)
1620       {
1621          reservedPrbStart = cell->cellCfg.dlCfgCommon.schFreqInfoDlSib.offsetToPointA;
1622          reservedPrbEnd = reservedPrbStart + SCH_SSB_NUM_PRB -1;
1623       }
1624       else if(sib1Occasion)
1625       {
1626          reservedPrbStart = cell->sib1SchCfg.sib1PdcchCfg.dci.pdschCfg->pdschFreqAlloc.startPrb;
1627          reservedPrbEnd = reservedPrbStart + cell->sib1SchCfg.sib1PdcchCfg.dci.pdschCfg->pdschFreqAlloc.numPrb -1;
1628       }
1629       else
1630       {
1631          checkOccasion = FALSE;
1632       }
1633    }
1634    else if(dir == DIR_UL)
1635    {
1636       prbAlloc = &cell->schUlSlotInfo[slotTime.slot]->prbAlloc;
1637
1638       /* Check if PRACH is also scheduled in this slot */
1639       checkOccasion = schCheckPrachOcc(cell, slotTime);
1640       if(checkOccasion)
1641       {
1642          reservedPrbStart =  cell->cellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.prachCfgGeneric.msg1FreqStart;
1643          reservedPrbEnd = reservedPrbStart + (schCalcPrachNumRb(cell)) -1;
1644       }
1645    }
1646    else
1647    {
1648       DU_LOG("\nERROR --> SCH: Invalid Direction!");
1649       return (maxFreePRB);
1650    }
1651
1652    freePrbNode = prbAlloc->freePrbBlockList.first;
1653    while(freePrbNode)
1654    {
1655       freePrbBlock = (FreePrbBlock *)freePrbNode->node;
1656
1657       /*For block with same numFreeBlocks, choose the one with HighestPRB range
1658        *Since FreeBLockList are arranged in Descending order of PRB range thus Skipping this block*/
1659       if(maxFreePRB >= freePrbBlock->numFreePrb)
1660       {
1661          //skip this block
1662          freePrbNode = freePrbNode->next;
1663          continue;
1664       }
1665
1666       /* If Broadcast/Prach message is scheduled in this slot, then check if its PRBs belong to the current free block.
1667        * Since SSB/SIB1 PRB location is fixed, these PRBs cannot be allocated to other message in same slot */
1668       if(checkOccasion &&
1669             ((reservedPrbStart >= freePrbBlock->startPrb) && (reservedPrbStart <= freePrbBlock->endPrb)) && \
1670             ((reservedPrbEnd >= freePrbBlock->startPrb) && (reservedPrbEnd <= freePrbBlock->endPrb)))
1671       {
1672
1673          /* Implmentation is done such that highest-numbered free-RB is Checked first
1674             and freePRB in this block is greater than Max till now */
1675          if((freePrbBlock->endPrb > reservedPrbEnd) && ((freePrbBlock->endPrb - reservedPrbEnd) > maxFreePRB))
1676          {
1677             /* If sufficient free PRBs are available above reserved message*/
1678             *startPrb = reservedPrbEnd + 1;
1679             maxFreePRB = (freePrbBlock->endPrb - reservedPrbEnd);
1680          }
1681          /*Also check the other freeBlock (i.e. Above the reserved message) for MAX FREE PRB*/
1682          if((reservedPrbStart > freePrbBlock->startPrb) && ((reservedPrbStart - freePrbBlock->startPrb) > maxFreePRB))
1683          {
1684             /* If free PRBs are available below reserved message*/
1685             *startPrb = freePrbBlock->startPrb;
1686             maxFreePRB = (reservedPrbStart - freePrbBlock->startPrb);
1687          }
1688       }
1689       else  //Best Block
1690       {
1691          if(maxFreePRB < freePrbBlock->numFreePrb)
1692          {
1693             *startPrb = freePrbBlock->startPrb;
1694             maxFreePRB = freePrbBlock->numFreePrb;
1695          }
1696
1697       }
1698       freePrbNode = freePrbNode->next;
1699    }
1700    return(maxFreePRB);
1701 }
1702
1703 /*******************************************************************************
1704  *
1705  * @brief This function is used to send Slice Cfg rsp to MAC
1706  *
1707  * @details
1708  *
1709  *    Function : SchSendSliceCfgRspToMac
1710  *
1711  *    Functionality:
1712  *     function is used to send Slice Cfg rsp to MAC
1713  *
1714  * @params[in] Pst *pst, SchSliceCfgRsp sliceCfgRsp
1715  *
1716  * @return- void
1717  *
1718  * ********************************************************************************/
1719 void SchSendSliceCfgRspToMac(Inst inst, SchSliceCfgRsp sliceCfgRsp)
1720 {
1721    Pst rspPst;
1722
1723    memset(&rspPst, 0, sizeof(Pst));
1724    FILL_PST_SCH_TO_MAC(rspPst, inst);
1725    rspPst.event = EVENT_SLICE_CFG_RSP_TO_MAC;
1726
1727    MacMessageRouter(&rspPst, (void *)&sliceCfgRsp);
1728
1729 }
1730 /*******************************************************************************
1731  *
1732  * @brief fill slice configuration response
1733  *
1734  * @details
1735  *
1736  *    Function : fillSliceCfgRsp
1737  *
1738  *    Functionality:
1739  *     fill slice configuration response
1740  *
1741  * @params[in] SchCellCb, SchSliceCfgReq, SchSliceCfgRsp,uint8_t  count
1742  *
1743  * @return
1744  *        ROK - Success
1745  *        RFAILED - Failure
1746  *
1747  * ********************************************************************************/
1748 uint8_t fillSliceCfgRsp(bool sliceRecfg, SchSliceCfg *storedSliceCfg, SchCellCb *cellCb, SchSliceCfgReq *schSliceCfgReq, SchSliceCfgRsp *schSliceCfgRsp, uint8_t *count)
1749 {
1750    bool sliceFound = false;
1751    uint8_t cfgIdx = 0, sliceIdx = 0, plmnIdx = 0;
1752
1753    schSliceCfgRsp->numSliceCfgRsp  = schSliceCfgReq->numOfConfiguredSlice;
1754    SCH_ALLOC(schSliceCfgRsp->listOfSliceCfgRsp, schSliceCfgRsp->numSliceCfgRsp * sizeof(SliceRsp*));
1755    if(schSliceCfgRsp->listOfSliceCfgRsp == NULLP)
1756    {
1757       DU_LOG("\nERROR  --> SCH : Memory allocation failed at fillSliceCfgRsp");
1758       return RFAILED;
1759    }
1760
1761    for(cfgIdx = 0; cfgIdx<schSliceCfgRsp->numSliceCfgRsp ; cfgIdx++)
1762    {
1763       sliceFound = false;
1764       /* Here comparing the slice cfg request with the slice stored in cellCfg */
1765       if(sliceRecfg != true)
1766       {
1767          for(plmnIdx = 0; plmnIdx < MAX_PLMN; plmnIdx++)
1768          {
1769             for(sliceIdx = 0; sliceIdx<cellCb->cellCfg.plmnInfoList[plmnIdx].numSliceSupport; sliceIdx++)
1770             {
1771                if(!memcmp(&schSliceCfgReq->listOfSlices[cfgIdx]->snssai, cellCb->cellCfg.plmnInfoList[plmnIdx].snssai[sliceIdx], sizeof(Snssai)))
1772                {
1773                   (*count)++;
1774                   sliceFound = true;
1775                   break;
1776                }
1777             }
1778             if(sliceFound == true)
1779             {
1780                break;
1781             }
1782          }
1783       }
1784       else
1785       {
1786          /* Here comparing the slice cfg request with the slice stored in SchDb */
1787          if(storedSliceCfg->listOfSlices)
1788          {
1789             for(sliceIdx = 0; sliceIdx<storedSliceCfg->numOfSliceConfigured; sliceIdx++)
1790             {
1791                if(!memcmp(&schSliceCfgReq->listOfSlices[cfgIdx]->snssai, &storedSliceCfg->listOfSlices[sliceIdx]->snssai,\
1792                         sizeof(Snssai)))
1793                {
1794                   (*count)++;
1795                   sliceFound = true;
1796                   break;
1797                }
1798             }
1799          }
1800       }
1801
1802       SCH_ALLOC(schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx], sizeof(SliceRsp));
1803       if(schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx] == NULLP)
1804       {
1805          DU_LOG("\nERROR  -->  SCH : Failed to allocate memory in fillSliceCfgRsp");
1806          return RFAILED;
1807       }
1808
1809
1810       schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->snssai = schSliceCfgReq->listOfSlices[cfgIdx]->snssai;
1811       if(sliceFound == true)
1812          schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->rsp    = RSP_OK;
1813       else
1814       {
1815          schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->rsp    = RSP_NOK;
1816          schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->cause  = SLICE_NOT_FOUND;
1817       }
1818    }
1819    return ROK;
1820 }
1821
1822 /*******************************************************************************
1823  *
1824  * @brief This function is used to store the slice configuration Sch DB
1825  *
1826  * @details
1827  *
1828  *    Function : addSliceCfgInSchDb
1829  *
1830  *    Functionality:
1831  *     function is used to store the slice configuration Sch DB
1832  *
1833  * @params[in] SchSliceCfg *storeSliceCfg, SchSliceCfgReq *cfgReq,
1834  * SchSliceCfgRsp cfgRsp, uint8_t count
1835  *
1836  * @return
1837  *        ROK - Success
1838  *        RFAILED - Failure
1839  *
1840  * ********************************************************************************/
1841 uint8_t addSliceCfgInSchDb(SchSliceCfg *storeSliceCfg, SchSliceCfgReq *cfgReq, SchSliceCfgRsp cfgRsp, uint8_t count)
1842 {
1843    uint8_t cfgIdx = 0, sliceIdx = 0;
1844
1845    if(count)
1846    {
1847       storeSliceCfg->numOfSliceConfigured = count;
1848       SCH_ALLOC(storeSliceCfg->listOfSlices, storeSliceCfg->numOfSliceConfigured * sizeof(SchRrmPolicyOfSlice*));
1849       if(storeSliceCfg->listOfSlices == NULLP)
1850       {
1851          DU_LOG("\nERROR  -->  SCH : Failed to allocate memory in addSliceCfgInSchDb");
1852          return RFAILED;
1853       }
1854
1855       for(cfgIdx = 0; cfgIdx<storeSliceCfg->numOfSliceConfigured; cfgIdx++)
1856       {
1857          if(cfgRsp.listOfSliceCfgRsp[cfgIdx]->rsp == RSP_OK)
1858          {
1859             SCH_ALLOC(storeSliceCfg->listOfSlices[sliceIdx], sizeof(SchRrmPolicyOfSlice));
1860             if(storeSliceCfg->listOfSlices[sliceIdx] == NULLP)
1861             {
1862                DU_LOG("\nERROR  -->  SCH : Failed to allocate memory in addSliceCfgInSchDb");
1863                return RFAILED;
1864             }
1865
1866             memcpy(&storeSliceCfg->listOfSlices[sliceIdx]->snssai, &cfgReq->listOfSlices[sliceIdx]->snssai, sizeof(Snssai));
1867             memcpy(&storeSliceCfg->listOfSlices[sliceIdx]->rrmPolicyRatioInfo, &cfgReq->listOfSlices[sliceIdx]->rrmPolicyRatioInfo,
1868                       sizeof(SchRrmPolicyRatio));
1869             sliceIdx++;
1870          }
1871       }
1872    }
1873    return ROK;
1874 }
1875
1876 /*******************************************************************************
1877  *
1878  * @brief This function is used to free the slice cfg and re cfg request pointer
1879  *
1880  * @details
1881  *
1882  *    Function : freeSchSliceCfgReq
1883  *
1884  *    Functionality:
1885  *     function is used to free the slice cfg and re cfg request pointer
1886  *
1887  * @params[in] Pst *pst, SchSliceCfgReq *schSliceCfgReq
1888  *
1889  * @return
1890  *        ROK - Success
1891  *        RFAILED - Failure
1892  * ********************************************************************************/
1893 void freeSchSliceCfgReq(SchSliceCfgReq *sliceCfgReq)
1894 {
1895    uint8_t cfgIdx = 0;
1896
1897    if(sliceCfgReq)
1898    {
1899       if(sliceCfgReq->numOfConfiguredSlice)
1900       {
1901          for(cfgIdx = 0; cfgIdx<sliceCfgReq->numOfConfiguredSlice; cfgIdx++)
1902          {
1903             if(sliceCfgReq->listOfSlices[cfgIdx])
1904             {
1905                SCH_FREE(sliceCfgReq->listOfSlices[cfgIdx], sizeof(SchRrmPolicyOfSlice));
1906             }
1907          }
1908          SCH_FREE(sliceCfgReq->listOfSlices, sliceCfgReq->numOfConfiguredSlice * sizeof(SchRrmPolicyOfSlice*));
1909       }
1910       SCH_FREE(sliceCfgReq, sizeof(SchSliceCfgReq));
1911    }
1912 }
1913 /*******************************************************************************
1914  *
1915  * @brief This function is used to store the slice configuration Sch DB
1916  *
1917  * @details
1918  *
1919  *    Function : SchProcSliceCfgReq
1920  *
1921  *    Functionality:
1922  *     function is used to store the slice configuration Sch DB
1923  *
1924  * @params[in] Pst *pst, SchSliceCfgReq *schSliceCfgReq
1925  *
1926  * @return
1927  *        ROK - Success
1928  *        RFAILED - Failure
1929  *
1930  * ********************************************************************************/
1931 uint8_t SchProcSliceCfgReq(Pst *pst, SchSliceCfgReq *schSliceCfgReq)
1932 {
1933    uint8_t count = 0;
1934    Inst   inst = pst->dstInst - SCH_INST_START;
1935    SchSliceCfgRsp sliceCfgRsp;
1936
1937    DU_LOG("\nINFO  -->  SCH : Received Slice Cfg request from MAC");
1938    if(schSliceCfgReq)
1939    {
1940       if(schSliceCfgReq->listOfSlices)
1941       {
1942          /* filling the slice configuration response of each slice */
1943          if(fillSliceCfgRsp(false, NULLP, schCb[inst].cells[0], schSliceCfgReq, &sliceCfgRsp, &count) != ROK)
1944          {
1945             DU_LOG("\nERROR  -->  SCH : Failed to fill the slice cfg rsp");
1946             return RFAILED;
1947          }
1948
1949          if(addSliceCfgInSchDb(&schCb[inst].sliceCfg, schSliceCfgReq, sliceCfgRsp, count) != ROK)
1950          {
1951             DU_LOG("\nERROR  -->  SCH : Failed to add slice cfg in sch database");
1952             return RFAILED;
1953          }
1954          freeSchSliceCfgReq(schSliceCfgReq);
1955          SchSendSliceCfgRspToMac(inst, sliceCfgRsp);
1956       }
1957    }
1958    else
1959    {
1960       DU_LOG("\nERROR  -->  SCH : Received SchSliceCfgReq is NULL");
1961    }
1962    return ROK;
1963 }
1964
1965 /*******************************************************************************
1966  *
1967  * @brief This function is used to store the slice reconfiguration Sch DB
1968  *
1969  * @details
1970  *
1971  *    Function : modifySliceCfgInSchDb
1972  *
1973  *    Functionality:
1974  *     function is used to store the slice re configuration Sch DB
1975  *
1976  * @params[in] Pst *pst, SchSliceCfgReq *schSliceCfgReq
1977  *
1978  * @return
1979  *        ROK - Success
1980  *        RFAILED - Failure
1981  *
1982  * ********************************************************************************/
1983 uint8_t modifySliceCfgInSchDb(SchSliceCfg *storeSliceCfg, SchSliceRecfgReq *recfgReq, SchSliceRecfgRsp recfgRsp, uint8_t count)
1984 {
1985    uint8_t cfgIdx = 0, sliceIdx = 0;
1986
1987    if(count)
1988    {
1989       if(storeSliceCfg->listOfSlices == NULLP)
1990       {
1991          DU_LOG("\nINFO  -->  SCH : Memory allocation failed in modifySliceCfgInSchDb");
1992          return RFAILED;
1993       }
1994
1995       for(cfgIdx = 0; cfgIdx<recfgReq->numOfConfiguredSlice; cfgIdx++)
1996       {
1997          if(recfgRsp.listOfSliceCfgRsp[cfgIdx]->rsp == RSP_OK)
1998          {
1999             for(sliceIdx = 0; sliceIdx<storeSliceCfg->numOfSliceConfigured; sliceIdx++)
2000             {
2001                if(!memcmp(&storeSliceCfg->listOfSlices[sliceIdx]->snssai, &recfgReq->listOfSlices[cfgIdx]->snssai, sizeof(Snssai)))
2002                {
2003                   memcpy(&storeSliceCfg->listOfSlices[sliceIdx]->rrmPolicyRatioInfo, &recfgReq->listOfSlices[cfgIdx]->rrmPolicyRatioInfo,
2004                            sizeof(SchRrmPolicyRatio));
2005                   break;
2006                }
2007             }
2008          }
2009       }
2010    }
2011    freeSchSliceCfgReq(recfgReq);
2012    return ROK;
2013 }
2014 /*******************************************************************************
2015  *
2016  * @brief This function is used to send Slice re Cfg rsp to MAC
2017  *
2018  * @details
2019  *
2020  *    Function : SchSendSliceRecfgRspToMac
2021  *
2022  *    Functionality:
2023  *     function is used to send Slice re Cfg rsp to MAC
2024  *
2025  * @params[in] Pst *pst, SchSliceRecfgRsp schSliceRecfgRsp
2026  *
2027  * @return- void
2028  *
2029  * ********************************************************************************/
2030 void SchSendSliceRecfgRspToMac(Inst inst, SchSliceRecfgRsp schSliceRecfgRsp)
2031 {
2032    Pst rspPst;
2033
2034    memset(&rspPst, 0, sizeof(Pst));
2035    FILL_PST_SCH_TO_MAC(rspPst, inst);
2036    rspPst.event = EVENT_SLICE_RECFG_RSP_TO_MAC;
2037
2038    MacMessageRouter(&rspPst, (void *)&schSliceRecfgRsp);
2039 }
2040 /*******************************************************************************
2041  *
2042  * @brief This function is used to store the slice reconfiguration Sch DB
2043  *
2044  * @details
2045  *
2046  *    Function : SchProcSliceRecfgReq
2047  *
2048  *    Functionality:
2049  *     function is used to store the slice re configuration Sch DB
2050  *
2051  * @params[in] Pst *pst, SchSliceRecfgReq *schSliceRecfgReq
2052  *
2053  * @return
2054  *        ROK - Success
2055  *        RFAILED - Failure
2056  *
2057  * ********************************************************************************/
2058 uint8_t SchProcSliceRecfgReq(Pst *pst, SchSliceRecfgReq *schSliceRecfgReq)
2059 {
2060    uint8_t count = 0;
2061    Inst   inst = pst->dstInst - SCH_INST_START;
2062    SchSliceRecfgRsp schSliceRecfgRsp;
2063
2064    DU_LOG("\nINFO  -->  SCH : Received Slice ReCfg request from MAC");
2065    if(schSliceRecfgReq)
2066    {
2067       if(schSliceRecfgReq->listOfSlices)
2068       {
2069          /* filling the slice configuration response of each slice */
2070          if(fillSliceCfgRsp(true, &schCb[inst].sliceCfg, NULLP, schSliceRecfgReq, &schSliceRecfgRsp, &count) != ROK)
2071          {
2072             DU_LOG("\nERROR  -->  SCH : Failed to fill sch slice cfg response");
2073             return RFAILED;
2074          }
2075
2076          /* Modify the slice configuration stored in schCb */
2077          if(modifySliceCfgInSchDb(&schCb[inst].sliceCfg, schSliceRecfgReq, schSliceRecfgRsp, count) != ROK)
2078          {
2079             DU_LOG("\nERROR  -->  SCH : Failed to modify slice cfg of SchDb");
2080             return RFAILED;
2081          }
2082          SchSendSliceRecfgRspToMac(inst, schSliceRecfgRsp);
2083       }
2084    }
2085    else
2086    {
2087       DU_LOG("\nERROR  -->  SCH : Received SchSliceRecfgReq is NULL");
2088    }
2089    return ROK;
2090 }
2091
2092 /****************************************************************************
2093  *
2094  * @brief Stores the Paging Configuration from DU APP in CellCb
2095  *
2096  * @details
2097  *
2098  *    Function : schProcPagingParam
2099  *
2100  *    Functionality:
2101  *          Process the Paging Configuration when FirstPDCCHMonitoring for
2102  *          Paging Ocassion is not present.
2103  *
2104  *          As per 38.304 Sec 7.1,
2105  *          "When firstPDCCH-MonitoringOccasionOfPO is present, the
2106  *          starting PDCCH monitoring occasion number of (i_s + 1)th PO is the
2107  *          (i_s + 1)th value of the firstPDCCHMonitoringOccasionOfPO
2108  *          parameter; otherwise, it is equal to i_s * S."
2109  *          "S = number of actual transmitted SSBs determined according
2110  *              to ssb-PositionsInBurst in SIB1"
2111  *
2112  * @params[in] SchCellCb *cell
2113  *
2114  * @return void
2115  *
2116  *************************************************************************/
2117 void schProcPagingCfg(SchCellCb *cell)
2118 {
2119    SchPcchCfg *pageCfgRcvd = NULL;
2120    uint8_t i_sIdx = 0;
2121
2122    pageCfgRcvd = &(cell->cellCfg.dlCfgCommon.schPcchCfg);
2123
2124    if(pageCfgRcvd->poPresent == TRUE)
2125    {
2126       /*Fetching first Pdcch Monitoring Occasion for SFN (i_s + 1)th*/
2127       for(i_sIdx = 0; i_sIdx < pageCfgRcvd->numPO; i_sIdx++)
2128       {
2129          cell->pageCb.pagMonOcc[i_sIdx].pagingOccSlot = pageCfgRcvd->pagingOcc[i_sIdx] / MAX_SYMB_PER_SLOT ;
2130          if ((pageCfgRcvd->pagingOcc[i_sIdx] % MAX_SYMB_PER_SLOT) != 0 )
2131          {
2132             cell->pageCb.pagMonOcc[i_sIdx].pagingOccSlot++;
2133          }
2134
2135          cell->pageCb.pagMonOcc[i_sIdx].frameOffset = 0;
2136
2137       }
2138    }
2139    else
2140    {
2141       schCfgPdcchMonOccOfPO(cell);
2142    }
2143 }
2144
2145 /****************************************************************************
2146  *
2147  * @brief Calculate PO if not present in Configuration
2148  *
2149  * @details
2150  *
2151  *    Function : schCfgPdcchMonOccOfPO
2152  *
2153  *    Functionality: In this function, PO are calculated i_s * S because
2154  *    FirstPDCCHMonitoring_ForPO is not present.
2155  *
2156  * @params[in] SchCellCb *cellCb
2157  *
2158  * @return void
2159  *
2160  *************************************************************************/
2161 void schCfgPdcchMonOccOfPO(SchCellCb *cell)
2162 {
2163    uint8_t         cnt = 0, incr = 1, i_sIdx = 0, frameOffSet = 0;
2164    uint8_t         nsValue = cell->cellCfg.dlCfgCommon.schPcchCfg.numPO;
2165    uint8_t         totalNumSsb = countSetBits(cell->cellCfg.ssbPosInBurst[0]);
2166    SlotTimingInfo  tmpTimingInfo, pdcchTime;
2167
2168    /*Starting with First Sfn and slot*/
2169    tmpTimingInfo.sfn = 0;
2170    tmpTimingInfo.slot = 0;
2171
2172    pdcchTime = tmpTimingInfo;
2173
2174    while(i_sIdx < nsValue)
2175    {
2176       /*Increment frame Offset if PO falls on next SFN*/
2177       if(pdcchTime.sfn != tmpTimingInfo.sfn)
2178       {
2179          frameOffSet++;
2180       }
2181       pdcchTime = tmpTimingInfo;
2182       schIncrSlot(&(tmpTimingInfo), incr, cell->numSlots);
2183
2184       if (i_sIdx == 0)
2185       {
2186          cell->pageCb.pagMonOcc[i_sIdx].pagingOccSlot = pdcchTime.slot;
2187          cell->pageCb.pagMonOcc[i_sIdx].frameOffset = frameOffSet;
2188          i_sIdx++;
2189       }
2190       else
2191       {
2192          cnt++;
2193          if((cnt == totalNumSsb) && (i_sIdx < MAX_PO_PER_PF))
2194          {
2195             cell->pageCb.pagMonOcc[i_sIdx].pagingOccSlot = pdcchTime.slot;
2196             cell->pageCb.pagMonOcc[i_sIdx].frameOffset = frameOffSet;
2197             cnt = 0;
2198             i_sIdx++;
2199          }
2200       }
2201    }
2202 }
2203
2204 /****************************************************************************
2205  *
2206  * @brief Storing the paging information in SCH database
2207  *
2208  * @details
2209  *
2210  *    Function : schAddPagingIndtoList
2211  *
2212  *    Functionality: Storing the paging information in SCH database
2213  *
2214  * @params[in] CmLListCp *storedPageList, CmLList *pageIndInfo
2215  *
2216  * @return ROK - sucess
2217  *         RFAILED - failure
2218  *
2219  *************************************************************************/
2220 uint8_t schAddPagingIndtoList(CmLListCp *storedPageList,void * pageIndInfo)
2221 {
2222    CmLList  *firstNodeOfList = NULLP;
2223    CmLList  *currentNodeInfo = NULLP;
2224    SchPageInfo *tempNode = NULLP, *recvdNode = NULLP;
2225
2226    recvdNode = (SchPageInfo*) pageIndInfo;
2227    CM_LLIST_FIRST_NODE(storedPageList,firstNodeOfList);
2228
2229    SCH_ALLOC(currentNodeInfo, sizeof(CmLList));
2230    if(!currentNodeInfo)
2231    {
2232       DU_LOG("\nERROR  --> SCH : schAddPagingIndtoList() : Memory allocation failed");
2233       return RFAILED;
2234    }
2235
2236    currentNodeInfo->node = (PTR)pageIndInfo;
2237    while(firstNodeOfList)
2238    {
2239       tempNode = (SchPageInfo*)(firstNodeOfList->node);
2240       if ((recvdNode->pageTxTime.slot < tempNode->pageTxTime.slot))
2241       {
2242          cmLListInsCrnt(storedPageList, currentNodeInfo);
2243          break;
2244       }
2245       else if ((recvdNode->pageTxTime.slot == tempNode->pageTxTime.slot))
2246       {
2247          DU_LOG("\nERROR  --> SCH : schAddPagingIndtoList() : Slot[%d] is already present in the list", recvdNode->pageTxTime.slot);
2248          return RFAILED;
2249       }
2250       else
2251       {
2252          CM_LLIST_NEXT_NODE(storedPageList, firstNodeOfList);
2253       }
2254    }
2255
2256    if(!firstNodeOfList)
2257    {
2258       cmLListAdd2Tail(storedPageList, currentNodeInfo);
2259    }
2260    DU_LOG("\nDEBUG   -->  SCH : Paging information is stored successfully for PF:%d, Slot:%d",\
2261               recvdNode->pageTxTime.sfn, recvdNode->pageTxTime.slot);
2262    return ROK;
2263 }
2264
2265 /****************************************************************************
2266  *
2267  * @brief Process paging indication at  SCH recevied form MAC
2268  *
2269  * @details
2270  *
2271  *    Function : SchProcPagingInd
2272  *
2273  *    Functionality: Process paging indication at SCH recevied form MAC
2274  *
2275  * @params[in] Pst *pst,  SchPageInd *pageInd
2276  *
2277  * @return void
2278  *
2279  *************************************************************************/
2280 uint8_t SchProcPagingInd(Pst *pst,  SchPageInd *pageInd)
2281 {
2282    uint8_t ret = RFAILED;
2283    uint16_t cellIdx = 0;
2284    Inst  inst = pst->dstInst - SCH_INST_START;
2285    SchCellCb *cellCb = NULLP;
2286    SchPageInfo *pageInfo = NULLP;
2287
2288    if(pageInd)
2289    {
2290       DU_LOG("\nDEBUG   -->  SCH : Received paging indication from MAC for cellId[%d]",\
2291                   pageInd->cellId);
2292
2293       /* Fetch Cell CB */
2294       for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
2295       {
2296          if((schCb[inst].cells[cellIdx]) && (schCb[inst].cells[cellIdx]->cellId == pageInd->cellId))
2297          {
2298             cellCb = schCb[inst].cells[cellIdx];
2299             break;
2300          }
2301       }
2302       if(cellCb)
2303       {
2304          if(pageInd->i_s > cellCb->cellCfg.dlCfgCommon.schPcchCfg.numPO)
2305          {
2306             DU_LOG("\nERROR --> SCH : SchProcPagingInd(): i_s should not be greater than number of paging occasion");
2307          }
2308          else
2309          {
2310             SCH_ALLOC(pageInfo, sizeof(SchPageInfo));
2311             if(pageInfo)
2312             {
2313                pageInfo->pf = pageInd->pf;
2314                pageInfo->i_s = pageInd->i_s;
2315                pageInfo->pageTxTime.cellId = pageInd->cellId;
2316                pageInfo->pageTxTime.sfn = (pageInd->pf +  cellCb->pageCb.pagMonOcc[pageInd->i_s].frameOffset) % MAX_SFN;
2317                pageInfo->pageTxTime.slot = cellCb->pageCb.pagMonOcc[pageInd->i_s].pagingOccSlot;
2318                pageInfo->mcs = DEFAULT_MCS;
2319                pageInfo->msgLen =  pageInd->pduLen;
2320                SCH_ALLOC(pageInfo->pagePdu, pageInfo->msgLen);
2321                if(!pageInfo->pagePdu)
2322                {
2323                   DU_LOG("\nERROR  --> SCH : SchProcPagingInd(): Failed to allocate memory");
2324                }
2325                else
2326                {
2327                   memcpy(pageInfo->pagePdu, pageInd->pagePdu, pageInfo->msgLen);
2328                   ret = schAddPagingIndtoList(&cellCb->pageCb.pageIndInfoRecord[pageInfo->pageTxTime.sfn], pageInfo);
2329                   if(ret != ROK)
2330                   {
2331                      DU_LOG("\nERROR  --> SCH : SchProcPagingInd(): Failed to store paging record");
2332                   }
2333                }
2334             }
2335             else
2336             {
2337                DU_LOG("\nERROR  --> SCH : SchProcPagingInd(): Failed to allocate memory");
2338             }
2339          }
2340       }
2341       else
2342       {
2343          DU_LOG("\nERROR  -->  SCH : Cell ID [%d] not found", pageInd->cellId);
2344       }
2345       SCH_FREE(pageInd->pagePdu, pageInd->pduLen);
2346       SCH_FREE(pageInd, sizeof(SchPageInd));
2347    }
2348    else
2349    {
2350       DU_LOG("\nERROR  --> SCH : SchProcPagingInd(): Received null pointer");
2351    }
2352    return ret;
2353 }
2354
2355 \f
2356 /***********************************************************
2357  *
2358  *     Func : SchFillCfmPst
2359  *
2360  *
2361  *     Desc : Fills the Confirmation Post Structure cfmPst using the reqPst
2362  *            and the cfm->hdr.response.
2363  *
2364  *
2365  *     Ret  : Void
2366  *
2367  *     Notes:
2368  *
2369  *     File : rg_sch_lmm.c
2370  *
2371  **********************************************************/
2372 Void SchFillCfmPst
2373 (
2374 Pst           *reqPst,
2375 Pst           *cfmPst,
2376 RgMngmt       *cfm
2377 )
2378 {
2379    Inst inst;
2380
2381    inst = (reqPst->dstInst - SCH_INST_START);
2382
2383    cfmPst->srcEnt    = ENTMAC;
2384    cfmPst->srcInst   = (Inst) 1;
2385    cfmPst->srcProcId = schCb[inst].schInit.procId;
2386    cfmPst->dstEnt    = ENTMAC;
2387    cfmPst->dstInst   = (Inst) 0;
2388    cfmPst->dstProcId = reqPst->srcProcId;
2389
2390    cfmPst->selector  = cfm->hdr.response.selector;
2391    cfmPst->region    = cfm->hdr.response.mem.region;
2392    cfmPst->pool      = cfm->hdr.response.mem.pool;
2393
2394    return;
2395 }
2396
2397 /**********************************************************************
2398   End of file
2399  **********************************************************************/