src/5gnrsch/sch_ue_mgr.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 /* This file contains UE management handling functionality for SCH */
  19
  20 #include "common_def.h"
  21 #include "tfu.h"
  22 #include "lrg.h"
  23
  24 #include "tfu.x"
  25 #include "lrg.x"
  26 #include "du_log.h"
  27 #include "du_app_mac_inf.h"
  28 #include "mac_sch_interface.h"
  29 #include "sch.h"
  30 #include "sch_utils.h"
  31
  32 /* local defines */
  33 SchUeCfgRspFunc SchUeCfgRspOpts[] =
  34 {
  35    packSchUeCfgRsp,      /* LC */
  36    MacProcSchUeCfgRsp,   /* TC */
  37    packSchUeCfgRsp       /* LWLC */
  38 };
  39
  40 SchUeDeleteRspFunc SchUeDeleteRspOpts[] =
  41 {
  42    packSchUeDeleteRsp,      /* LC */
  43    MacProcSchUeDeleteRsp,   /* TC */
  44    packSchUeDeleteRsp       /* LWLC */
  45 };
  46
  47 SchCellDeleteRspFunc SchCellDeleteRspOpts[]=
  48 {
  49    packSchCellDeleteRsp,      /* LC */
  50    MacProcSchCellDeleteRsp,   /* TC */
  51    packSchCellDeleteRsp       /* LWLC */
  52 };
  53
  54 /*******************************************************************
  55  *
  56  * @brief Fill and send UE cfg response to MAC
  57  *
  58  * @details
  59  *
  60  *    Function : SchSendUeCfgRspToMac
  61  *
  62  *    Functionality: Fill and send UE cfg response to MAC
  63  *
  64  * @params[in]
  65  * @return ROK     - success
  66  *         RFAILED - failure
  67  *
  68  * ****************************************************************/
  69 void SchSendUeCfgRspToMac(uint16_t event, SchUeCfg *ueCfg, Inst inst,\
  70       SchMacRsp result, SchUeCfgRsp *cfgRsp)
  71 {
  72    Pst rspPst;
  73
  74    cfgRsp->cellId = ueCfg->cellId;
  75    cfgRsp->crnti = ueCfg->crnti;
  76    GET_UE_IDX(ueCfg->crnti, cfgRsp->ueIdx);
  77    cfgRsp->rsp = result;
  78
  79    /* Filling response post */
  80    memset(&rspPst, 0, sizeof(Pst));
  81    FILL_PST_SCH_TO_MAC(rspPst, inst);
  82    if(event == EVENT_ADD_UE_CONFIG_REQ_TO_SCH)
  83    {
  84       rspPst.event = EVENT_UE_CONFIG_RSP_TO_MAC;
  85       DU_LOG("\nINFO  -->  SCH :  Sending UE Config response to MAC");
  86    }
  87    else if(event == EVENT_MODIFY_UE_CONFIG_REQ_TO_SCH)
  88    {
  89       rspPst.event = EVENT_UE_RECONFIG_RSP_TO_MAC;
  90       DU_LOG("\nINFO  -->  SCH :  Sending UE Reconfig response to MAC");
  91    }
  92    SchUeCfgRspOpts[rspPst.selector](&rspPst, cfgRsp);
  93 }
  94
  95 /*******************************************************************
  96
  97  *
  98  * @brief Function to fill Dl Lc Context in SCH Ue Cb
  99  *
 100  * @details
 101  *
 102  *    Function : fillSchDlLcCtxt
 103  *
 104  *    Functionality: Function to fill Dl Lc Context in SCH Ue Cb
 105  *
 106  * @params[in] SchDlLcCtxt pointer,
 107  *             SchLcCfg pointer
 108  * @return void
 109  *
 110  * ****************************************************************/
 111
 112 void fillSchDlLcCtxt(SchDlLcCtxt *ueCbLcCfg, SchLcCfg *lcCfg)
 113 {
 114    ueCbLcCfg->lcId = lcCfg->lcId;
 115    ueCbLcCfg->lcp = lcCfg->dlLcCfg.lcp;
 116    ueCbLcCfg->lcState = SCH_LC_STATE_ACTIVE;
 117    ueCbLcCfg->bo = 0;
 118    if(lcCfg->drbQos)
 119    {
 120      ueCbLcCfg->pduSessionId = lcCfg->drbQos->pduSessionId;
 121    }
 122    if(lcCfg->snssai)
 123    {
 124      if(ueCbLcCfg->snssai == NULLP)/*In CONFIG_MOD case, no need to allocate SNSSAI memory*/
 125      {
 126         SCH_ALLOC(ueCbLcCfg->snssai, sizeof(Snssai));
 127      }
 128      memcpy(ueCbLcCfg->snssai, lcCfg->snssai,sizeof(Snssai));
 129    }
 130 }
 131
 132 /*******************************************************************
 133  *
 134  * @brief Function to fill Ul Lc Context in SCH Ue Cb
 135  *
 136  * @details
 137  *
 138  *    Function : fillSchUlLcCtxt
 139  *
 140  *    Functionality: Function to fill Ul Lc Context in SCH Ue Cb
 141  *
 142  * @params[in] SchUlLcCtxt pointer,
 143  *             SchLcCfg pointer
 144  * @return void
 145  *
 146  * ****************************************************************/
 147
 148 void fillSchUlLcCtxt(SchUlLcCtxt *ueCbLcCfg, SchLcCfg *lcCfg)
 149 {
 150    ueCbLcCfg->lcId = lcCfg->lcId;
 151    ueCbLcCfg->lcState = SCH_LC_STATE_ACTIVE;
 152    ueCbLcCfg->priority = lcCfg->ulLcCfg.priority;
 153    ueCbLcCfg->lcGroup = lcCfg->ulLcCfg.lcGroup;
 154    ueCbLcCfg->schReqId = lcCfg->ulLcCfg.schReqId;
 155    ueCbLcCfg->pbr     = lcCfg->ulLcCfg.pbr;
 156    ueCbLcCfg->bsd     = lcCfg->ulLcCfg.bsd;
 157
 158    if(lcCfg->drbQos)
 159    {
 160       ueCbLcCfg->pduSessionId = lcCfg->drbQos->pduSessionId;
 161    }
 162    if(lcCfg->snssai)
 163    {
 164      /*In CONFIG_MOD case, no need to allocate SNSSAI memory again*/
 165      if(ueCbLcCfg->snssai == NULLP)
 166      {
 167         SCH_ALLOC(ueCbLcCfg->snssai, sizeof(Snssai));
 168      }
 169      memcpy(ueCbLcCfg->snssai, lcCfg->snssai,sizeof(Snssai));
 170    }
 171 }
 172
 173 /*******************************************************************
 174  *
 175  * @brief Function to update/allocate dedLC Info
 176  *
 177  * @details
 178  *
 179  *    Function : updateDedLcInfo
 180  *
 181  *    Functionality: Function to fill DLDedLcInfo
 182  *
 183  * @params[arg] snssai pointer,
 184  *              SchRrmPolicy pointer,
 185  *              SchLcPrbEstimate pointer , It will be filled
 186  *              isDedicated pointer,(Address of isDedicated flag in LC Context)
 187  *
 188  * @return ROK      >> This LC is part of RRM MemberList.
 189  *         RFAILED  >> FATAL Error
 190  *         ROKIGNORE >> This LC is not part of this RRM MemberList
 191  *
 192  * ****************************************************************/
 193
 194 uint8_t updateDedLcInfo(Snssai *snssai, SchRrmPolicy *rrmPolicy, SchLcPrbEstimate *lcPrbEst,\
 195                          bool *isDedicated)
 196 {
 197    if(memcmp(snssai, &(rrmPolicy->memberList.snssai), sizeof(Snssai)) == 0)
 198    {
 199       if(lcPrbEst->dedLcInfo == NULLP)
 200       {
 201          SCH_ALLOC(lcPrbEst->dedLcInfo, sizeof(DedicatedLCInfo));
 202          if(lcPrbEst->dedLcInfo == NULLP)
 203          {
 204             DU_LOG("\nINFO  -->  SCH : Memory Allocation Failed");
 205             return RFAILED;
 206          }
 207       }
 208       /*Updating latest RrmPolicy*/
 209       lcPrbEst->dedLcInfo->rsvdDedicatedPRB = \
 210                                               (uint16_t)(((rrmPolicy->policyDedicatedRatio)*(MAX_NUM_RB))/100);
 211       *isDedicated = TRUE;
 212       DU_LOG("\nINFO  -->  SCH : Updated RRM policy, reservedPOOL:%d",lcPrbEst->dedLcInfo->rsvdDedicatedPRB);
 213    }
 214    /*else case: This LcCtxt  is either a Default LC or this LC is part of someother RRM_MemberList*/
 215    else
 216    {
 217       DU_LOG("\nINFO  -->  SCH : This SNSSAI is not a part of this RRMPolicy");
 218    }
 219    return ROK;
 220 }
 221
 222 /*******************************************************************
 223  *
 224  * @brief Function to fill SchUeCb
 225  *
 226  * @details
 227  *
 228  *    Function : fillSchUeCb
 229  *
 230  *    Functionality: Function to fill SchUeCb
 231  *
 232  * @params[in] SchUeCb pointer,
 233  *             SchUeCfg pointer
 234  * @return ROK/RFAILED
 235  *
 236  * ****************************************************************/
 237
 238 uint8_t fillSchUeCb(SchUeCb *ueCb, SchUeCfg *ueCfg)
 239 {
 240    uint8_t   lcIdx, ueLcIdx;
 241    uint8_t   freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
 242    SchPdschCfgCmn pdschCfg;
 243    SchPucchDlDataToUlAck *dlDataToUlAck;
 244    CmLListCp *lcLL = NULLP;
 245    uint8_t retDL = ROK, retUL = ROK;
 246    bool isLcIdValid = FALSE;
 247
 248    ueCb->ueCfg.cellId = ueCfg->cellId;
 249    ueCb->ueCfg.crnti = ueCfg->crnti;
 250    if(ueCfg->macCellGrpCfgPres == true)
 251    {
 252       memcpy(&ueCb->ueCfg.macCellGrpCfg , &ueCfg->macCellGrpCfg, sizeof(SchMacCellGrpCfg));
 253       ueCb->ueCfg.macCellGrpCfgPres = true;
 254    }
 255
 256    if(ueCfg->phyCellGrpCfgPres == true)
 257    {
 258       memcpy(&ueCb->ueCfg.phyCellGrpCfg ,  &ueCfg->phyCellGrpCfg, sizeof(SchPhyCellGrpCfg));
 259       ueCb->ueCfg.phyCellGrpCfgPres = true;
 260    }
 261
 262    if(ueCfg->spCellCfgPres == true)
 263    {
 264       memcpy(&ueCb->ueCfg.spCellCfg , &ueCfg->spCellCfg, sizeof(SchSpCellCfg));
 265
 266       covertFreqDomRsrcMapToIAPIFormat(ueCb->ueCfg.spCellCfg.servCellCfg.initDlBwp.pdcchCfg.cRSetToAddModList[0].freqDomainRsrc,\
 267             freqDomainResource);
 268       memset(ueCb->ueCfg.spCellCfg.servCellCfg.initDlBwp.pdcchCfg.cRSetToAddModList[0].freqDomainRsrc, 0, FREQ_DOM_RSRC_SIZE);
 269       memcpy(ueCb->ueCfg.spCellCfg.servCellCfg.initDlBwp.pdcchCfg.cRSetToAddModList[0].freqDomainRsrc, freqDomainResource, FREQ_DOM_RSRC_SIZE);
 270
 271       ueCb->ueCfg.spCellCfgPres = true;
 272       dlDataToUlAck = ueCfg->spCellCfg.servCellCfg.initUlBwp.pucchCfg.dlDataToUlAck;
 273       if(ueCb->cellCb)
 274       {
 275          if(dlDataToUlAck)
 276          {
 277             BuildK0K1Table(ueCb->cellCb, &ueCb->ueCfg.spCellCfg.servCellCfg.initDlBwp.k0K1InfoTbl, false, pdschCfg,\
 278                   ueCfg->spCellCfg.servCellCfg.initDlBwp.pdschCfg, dlDataToUlAck->dlDataToUlAckListCount,\
 279                   dlDataToUlAck->dlDataToUlAckList);
 280             ueCb->ueCfg.spCellCfg.servCellCfg.initDlBwp.k0K1TblPrsnt = true;
 281             BuildK2InfoTable(ueCb->cellCb, ueCfg->spCellCfg.servCellCfg.initUlBwp.puschCfg.timeDomRsrcAllocList,\
 282                   ueCfg->spCellCfg.servCellCfg.initUlBwp.puschCfg.numTimeDomRsrcAlloc,\
 283                   NULLP, &ueCb->ueCfg.spCellCfg.servCellCfg.initUlBwp.k2InfoTbl);
 284                   ueCb->ueCfg.spCellCfg.servCellCfg.initUlBwp.k2TblPrsnt = true;
 285          }
 286       }
 287    }
 288
 289    ueCb->state = SCH_UE_STATE_ACTIVE;
 290    if(ueCfg->ambrCfg)
 291    {
 292       SCH_FREE(ueCb->ueCfg.ambrCfg, sizeof(SchAmbrCfg));
 293       ueCb->ueCfg.ambrCfg =  ueCfg->ambrCfg;
 294    }
 295    memcpy(&ueCb->ueCfg.dlModInfo,  &ueCfg->dlModInfo , sizeof(SchModulationInfo));
 296    memcpy(&ueCb->ueCfg.ulModInfo,  &ueCfg->ulModInfo , sizeof(SchModulationInfo));
 297
 298    //Updating SchUlCb and SchDlCb DB in SchUeCb
 299    for(lcIdx = 0; lcIdx < ueCfg->numLcs; lcIdx++)
 300    {
 301       isLcIdValid = FALSE; /*Re-Initializing*/
 302
 303       ueLcIdx = ueCfg->schLcCfg[lcIdx].lcId;
 304       CHECK_LCID(ueLcIdx, isLcIdValid);
 305       if(isLcIdValid == FALSE)
 306       {
 307          DU_LOG("ERROR --> SCH: LCID:%d is not Valid",ueLcIdx);
 308          continue;
 309       }
 310       if(ueCfg->schLcCfg[lcIdx].configType == CONFIG_ADD)
 311       {
 312          fillSchUlLcCtxt(&ueCb->ulInfo.ulLcCtxt[ueLcIdx], &ueCfg->schLcCfg[lcIdx]);
 313          fillSchDlLcCtxt(&ueCb->dlInfo.dlLcCtxt[ueLcIdx], &ueCfg->schLcCfg[lcIdx]);
 314
 315          /*Checking whether this LC belong to Dedicated S-NSSAI
 316           * and Create the Dedicated LC List & Update the Reserve PRB number*/
 317          if(ueCb->dlInfo.dlLcCtxt[ueLcIdx].snssai != NULLP)
 318          {
 319             retDL = updateDedLcInfo(ueCb->dlInfo.dlLcCtxt[ueLcIdx].snssai,  \
 320                   ueCb->cellCb->cellCfg.rrmPolicy, &(ueCb->dlLcPrbEst),\
 321                   &(ueCb->dlInfo.dlLcCtxt[ueLcIdx].isDedicated));
 322          }
 323          if(ueCb->ulInfo.ulLcCtxt[ueLcIdx].snssai != NULLP)
 324          {
 325             retUL =  updateDedLcInfo(ueCb->ulInfo.ulLcCtxt[ueLcIdx].snssai,  \
 326                   ueCb->cellCb->cellCfg.rrmPolicy, &(ueCb->ulLcPrbEst),\
 327                   &(ueCb->ulInfo.ulLcCtxt[ueLcIdx].isDedicated));
 328          }
 329
 330          if(retUL == RFAILED  || retDL == RFAILED)/*FATAL error*/
 331          {
 332             DU_LOG("\nERROR  -->  SCH : Failure in updateDedLcInfo");
 333             return RFAILED;
 334          }
 335       }
 336       else
 337       {
 338          if(ueCb->ulInfo.ulLcCtxt[ueLcIdx].lcId == ueCfg->schLcCfg[lcIdx].lcId)
 339          {
 340             if(ueCfg->schLcCfg[lcIdx].configType == CONFIG_MOD)
 341             {
 342                fillSchUlLcCtxt(&ueCb->ulInfo.ulLcCtxt[ueLcIdx], &ueCfg->schLcCfg[lcIdx]);
 343                /*Updating the RRM reserved pool PRB count*/
 344                if(ueCb->ulInfo.ulLcCtxt[ueLcIdx].snssai != NULLP)
 345                {
 346                   retUL =  updateDedLcInfo(ueCb->ulInfo.ulLcCtxt[ueLcIdx].snssai,  \
 347                         ueCb->cellCb->cellCfg.rrmPolicy, &(ueCb->ulLcPrbEst),\
 348                         &(ueCb->ulInfo.ulLcCtxt[ueLcIdx].isDedicated));
 349                }
 350                if(retUL == RFAILED)
 351                {
 352                   DU_LOG("\nERROR  -->  SCH : Failed in updating Ded Lc info");
 353                   return RFAILED;
 354                }
 355             }
 356             if(ueCfg->schLcCfg[lcIdx].configType == CONFIG_DEL)
 357             {
 358                /*Delete the LC node from the UL LC List*/
 359                if(ueCb->ulInfo.ulLcCtxt[ueLcIdx].isDedicated)
 360                {
 361                   if(ueCb->ulLcPrbEst.dedLcInfo != NULLP)
 362                   {
 363                      lcLL = &(ueCb->ulLcPrbEst.dedLcInfo->dedLcList);
 364                      handleLcLList(lcLL, ueCfg->schLcCfg[lcIdx].lcId, DELETE);
 365                      if(lcLL->count == 0)/*IF No Node in DedicateLCList to be deleted*/
 366                      {
 367                         /*Free the Dedicated LC Info structure*/
 368                         SCH_FREE(ueCb->ulLcPrbEst.dedLcInfo, sizeof(DedicatedLCInfo));
 369                      }
 370                   }
 371                }
 372                else/*Default LC list*/
 373                {
 374                   lcLL = &(ueCb->ulLcPrbEst.defLcList);
 375                   handleLcLList(lcLL, ueCfg->schLcCfg[lcIdx].lcId, DELETE);
 376                }
 377                SCH_FREE(ueCb->ulInfo.ulLcCtxt[ueLcIdx].snssai, sizeof(Snssai));
 378                memset(&ueCb->ulInfo.ulLcCtxt[ueLcIdx], 0, sizeof(SchUlLcCtxt));
 379             }
 380          }/*End of UL LC Ctxt*/
 381
 382          if(ueCb->dlInfo.dlLcCtxt[ueLcIdx].lcId == ueCfg->schLcCfg[lcIdx].lcId)
 383          {
 384             if(ueCfg->schLcCfg[lcIdx].configType == CONFIG_MOD)
 385             {
 386                fillSchDlLcCtxt(&ueCb->dlInfo.dlLcCtxt[ueLcIdx], &ueCfg->schLcCfg[lcIdx]);
 387                /*Updating the RRM policy*/
 388                if(ueCb->dlInfo.dlLcCtxt[ueLcIdx].snssai != NULLP)
 389                {
 390                   retDL = updateDedLcInfo(ueCb->dlInfo.dlLcCtxt[ueLcIdx].snssai,  \
 391                         ueCb->cellCb->cellCfg.rrmPolicy, &(ueCb->dlLcPrbEst), \
 392                         &(ueCb->dlInfo.dlLcCtxt[ueLcIdx].isDedicated));
 393                }
 394                if(retDL == RFAILED)
 395                {
 396                   DU_LOG("\nERROR  -->  SCH : Failed in updating Ded Lc info");
 397                   return RFAILED;
 398                }
 399             }
 400             if(ueCfg->schLcCfg[lcIdx].configType == CONFIG_DEL)
 401             {
 402                /*Delete the LC node from the DL LC List*/
 403                if(ueCb->dlInfo.dlLcCtxt[ueLcIdx].isDedicated)
 404                {
 405                   if(ueCb->dlLcPrbEst.dedLcInfo != NULLP)
 406                   {
 407                      lcLL = &(ueCb->dlLcPrbEst.dedLcInfo->dedLcList);
 408                      handleLcLList(lcLL, ueCfg->schLcCfg[lcIdx].lcId, DELETE);
 409                      if(lcLL->count == 0)/*Last Node in DedicateLCList to be deleted*/
 410                      {
 411                         /*Free the Dedicated LC Info structure*/
 412                         SCH_FREE(ueCb->dlLcPrbEst.dedLcInfo, sizeof(DedicatedLCInfo));
 413                      }
 414                   }
 415                }
 416                else
 417                {
 418                   lcLL = &(ueCb->dlLcPrbEst.defLcList);
 419                   handleLcLList(lcLL, ueCfg->schLcCfg[lcIdx].lcId, DELETE);
 420                }
 421                SCH_FREE(ueCb->dlInfo.dlLcCtxt[ueLcIdx].snssai, sizeof(Snssai));
 422                memset(&ueCb->dlInfo.dlLcCtxt[ueLcIdx], 0, sizeof(SchDlLcCtxt));
 423             }
 424          }/*End of DL LC ctxt*/
 425       }
 426
 427       SCH_FREE(ueCfg->schLcCfg[lcIdx].drbQos, sizeof(SchDrbQosInfo));
 428       SCH_FREE(ueCfg->schLcCfg[lcIdx].snssai, sizeof(Snssai));
 429
 430    }/* End of outer for loop */
 431    return ROK;
 432 }
 433
 434 /*******************************************************************
 435  *
 436  * @brief Function to get SCH Cell Cb
 437  *
 438  * @details
 439  *
 440  *    Function : getSchCellCb
 441  *
 442  *    Functionality: Function to get SCH Cell Cb
 443  *
 444  * @params[in] event, SchUeCfg pointer
 445  * @return schUeCb pointer  - success
 446  *         NULLP - failure
 447  *
 448  * ****************************************************************/
 449
 450 SchCellCb *getSchCellCb(uint16_t srcEvent, Inst inst, SchUeCfg *ueCfg)
 451 {
 452    uint8_t      idx;
 453    SchCellCb    *cellCb = NULLP;
 454    SchUeCfgRsp  cfgRsp;
 455    memset(&cfgRsp, 0, sizeof(SchUeCfgRsp));
 456
 457    /* Search of cell cb */
 458    for(idx = 0; idx < MAX_NUM_CELL; idx++)
 459    {
 460       cellCb = schCb[inst].cells[idx];
 461       if(cellCb->cellId == ueCfg->cellId)
 462          break;
 463    }
 464    if(idx == MAX_NUM_CELL)
 465    {
 466       DU_LOG("\nERROR  -->  SCH : Ue create request failed. Invalid cell id %d", ueCfg->cellId);
 467       SchSendUeCfgRspToMac(srcEvent, ueCfg, inst, RSP_NOK, &cfgRsp);
 468       return NULLP;
 469    }
 470
 471    /* Check if max number of UE configured */
 472    if(cellCb->numActvUe > MAX_NUM_UE)
 473    {
 474       DU_LOG("\nERROR  -->  SCH :  Max number of UE [%d] already configured", MAX_NUM_UE);
 475       SchSendUeCfgRspToMac(srcEvent, ueCfg, inst, RSP_NOK, &cfgRsp);
 476       return NULLP;
 477    }
 478    return cellCb;
 479 }
 480
 481
 482 /*******************************************************************
 483  *
 484  * @brief Function to Add Ue Config Request from MAC
 485  *
 486  * @details
 487  *
 488  *    Function : MacSchAddUeConfigReq
 489  *
 490  *    Functionality: Function to Add Ue config request from MAC
 491  *
 492  * @params[in]
 493  * @return ROK     - success
 494  *         RFAILED - failure
 495  *
 496  * ****************************************************************/
 497 uint8_t MacSchAddUeConfigReq(Pst *pst, SchUeCfg *ueCfg)
 498 {
 499    uint8_t ueIdx, lcIdx, ret = ROK;
 500    SchCellCb    *cellCb = NULLP;
 501    SchUeCb      *ueCb = NULLP;
 502    SchUeCfgRsp  cfgRsp;
 503    Inst         inst = pst->dstInst - 1;
 504    memset(&cfgRsp, 0, sizeof(SchUeCfgRsp));
 505
 506 #ifdef CALL_FLOW_DEBUG_LOG
 507    DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_ADD_UE_CONFIG_REQ_TO_SCH\n");
 508 #endif
 509
 510    if(!ueCfg)
 511    {
 512       DU_LOG("\nERROR  -->  SCH :  Adding UE Config Request failed at MacSchAddUeConfigReq()");
 513       return RFAILED;
 514    }
 515    DU_LOG("\nDEBUG  -->  SCH :  Adding UE Config Request for CRNTI[%d]", ueCfg->crnti);
 516    cellCb = getSchCellCb(pst->event, inst, ueCfg);
 517
 518    /* Search if UE already configured */
 519    GET_UE_IDX(ueCfg->crnti, ueIdx);
 520    ueCb = &cellCb->ueCb[ueIdx -1];
 521    if(ueCb)
 522    {
 523       if((ueCb->crnti == ueCfg->crnti) && (ueCb->state == SCH_UE_STATE_ACTIVE))
 524       {
 525          DU_LOG("\nDEBUG  -->  SCH : CRNTI %d already configured ", ueCfg->crnti);
 526          SchSendUeCfgRspToMac(pst->event, ueCfg, inst, RSP_OK, &cfgRsp);
 527          return ROK;
 528       }
 529    }
 530    else
 531    {
 532       DU_LOG("\nERROR  -->  SCH : SchUeCb not found at MacSchAddUeConfigReq() ");
 533       SchSendUeCfgRspToMac(pst->event, ueCfg, inst, RSP_NOK, &cfgRsp);
 534       return RFAILED;
 535    }
 536
 537    /* Fill received Ue Configuration in UeCb */
 538    memset(ueCb, 0, sizeof(SchUeCb));
 539    GET_UE_IDX(ueCfg->crnti, ueIdx);
 540    ueCb->ueIdx = ueIdx;
 541    ueCb->crnti = ueCfg->crnti;
 542    ueCb->state = SCH_UE_STATE_ACTIVE;
 543    ret = fillSchUeCb(ueCb, ueCfg);
 544    if(ret == ROK)
 545    {
 546       cellCb->numActvUe++;
 547       SET_ONE_BIT(ueCb->ueIdx, cellCb->actvUeBitMap);
 548       ueCb->cellCb = cellCb;
 549       ueCb->srRcvd = false;
 550       ueCb->bsrRcvd = false;
 551       for(lcIdx=0; lcIdx<MAX_NUM_LOGICAL_CHANNEL_GROUPS; lcIdx++)
 552          ueCb->bsrInfo[lcIdx].dataVol = 0;
 553
 554       SchSendUeCfgRspToMac(pst->event, ueCfg, inst, RSP_OK, &cfgRsp);
 555    }
 556    return ret;
 557 }
 558
 559 /*******************************************************************
 560 *
 561 * @brief Fills PUSCH UL allocation
 562 *
 563 * @details
 564 *
 565 *    Function : schFillPuschAlloc
 566 *
 567 *    Functionality: fills PUSCH info
 568 *
 569 * @params[in]
 570 * @return ROK     - success
 571 *         RFAILED - failure
 572 *
 573 * ****************************************************************/
 574 uint8_t schFillPuschAlloc(SchUeCb *ueCb, SlotTimingInfo puschTime, uint32_t dataVol, uint8_t k2, uint8_t startSymb, uint8_t symbLen)
 575 {
 576   uint16_t startRb        = 0;
 577   uint8_t  numRb          = 0;
 578   uint16_t tbSize         = 0;
 579   uint8_t  buffer         = 5;
 580   SchCellCb *cellCb       = ueCb->cellCb;
 581   SchUlSlotInfo *schUlSlotInfo = NULLP;
 582   SchPuschInfo puschInfo;
 583
 584   startRb = MAX_NUM_RB;
 585   tbSize  = schCalcTbSize(dataVol + buffer); /*  2 bytes header + some buffer */
 586   numRb   = schCalcNumPrb(tbSize, ueCb->ueCfg.ulModInfo.mcsIndex, symbLen);
 587   allocatePrbUl(cellCb, puschTime, startSymb, symbLen, &startRb, numRb);
 588
 589   puschInfo.crnti             = ueCb->crnti;
 590   puschInfo.harqProcId        = SCH_HARQ_PROC_ID;
 591   puschInfo.resAllocType      = SCH_ALLOC_TYPE_1;
 592   puschInfo.fdAlloc.startPrb  = startRb;
 593   puschInfo.fdAlloc.numPrb    = numRb;
 594   puschInfo.tdAlloc.startSymb = startSymb;
 595   puschInfo.tdAlloc.numSymb   = symbLen;
 596   puschInfo.tbInfo.qamOrder   = ueCb->ueCfg.ulModInfo.modOrder;
 597   puschInfo.tbInfo.mcs        = ueCb->ueCfg.ulModInfo.mcsIndex;
 598   puschInfo.tbInfo.mcsTable   = ueCb->ueCfg.ulModInfo.mcsTable;
 599   puschInfo.tbInfo.ndi        = 1; /* new transmission */
 600   puschInfo.tbInfo.rv         = 0;
 601   puschInfo.tbInfo.tbSize     = tbSize;
 602   puschInfo.dmrsMappingType   = DMRS_MAP_TYPE_A;  /* Setting Type-A */
 603   puschInfo.nrOfDmrsSymbols   = NUM_DMRS_SYMBOLS;
 604   puschInfo.dmrsAddPos        = DMRS_ADDITIONAL_POS;
 605
 606   schUlSlotInfo = cellCb->schUlSlotInfo[puschTime.slot];
 607   SCH_ALLOC(schUlSlotInfo->schPuschInfo, sizeof(SchPuschInfo));
 608   if(!schUlSlotInfo->schPuschInfo)
 609   {
 610      DU_LOG("\nERROR  -->  SCH: Memory allocation failed in schAllocMsg3Pusch");
 611      return RFAILED;
 612   }
 613   memcpy(schUlSlotInfo->schPuschInfo, &puschInfo, sizeof(SchPuschInfo));
 614
 615   return ROK;
 616 }
 617
 618 /*******************************************************************
 619  *
 620  * @brief Fills DCI for UL grant
 621  *
 622  * @details
 623  *
 624  *    Function : schFillUlDci
 625  *
 626  *    Functionality: fills DCI for UL grant in response to BSR
 627  *
 628  * @params[in]
 629  * @return ROK     - success
 630  *         RFAILED - failure
 631  *
 632  * ****************************************************************/
 633 uint8_t schFillUlDci(SchUeCb *ueCb, SchPuschInfo *puschInfo, DciInfo *dciInfo)
 634 {
 635    SchCellCb         *cellCb  = ueCb->cellCb;
 636    SchControlRsrcSet coreset1 ;
 637
 638    memset(&coreset1, 0, sizeof(SchControlRsrcSet));
 639    if(ueCb->ueCfg.spCellCfgPres == true)
 640    {
 641      coreset1 = ueCb->ueCfg.spCellCfg.servCellCfg.initDlBwp.pdcchCfg.cRSetToAddModList[0];
 642    }
 643
 644    dciInfo->cellId = cellCb->cellId;
 645    dciInfo->crnti  = ueCb->crnti;
 646
 647    /* fill bwp cfg */
 648    dciInfo->bwpCfg.subcarrierSpacing  = cellCb->cellCfg.sib1SchCfg.bwp.subcarrierSpacing;
 649    dciInfo->bwpCfg.cyclicPrefix       = cellCb->cellCfg.sib1SchCfg.bwp.cyclicPrefix;
 650    dciInfo->bwpCfg.freqAlloc.startPrb = cellCb->cellCfg.schInitialDlBwp.bwp.freqAlloc.startPrb;
 651    dciInfo->bwpCfg.freqAlloc.numPrb   = cellCb->cellCfg.schInitialDlBwp.bwp.freqAlloc.numPrb;
 652
 653    /*fill coreset cfg */
 654    //Considering number of RBs in coreset1 is same as coreset0
 655    dciInfo->coresetCfg.coreSetSize      = coresetIdxTable[0][1];
 656    //Considering coreset1 also starts from same symbol as coreset0
 657    dciInfo->coresetCfg.startSymbolIndex = searchSpaceIdxTable[0][3];
 658    dciInfo->coresetCfg.durationSymbols  = coreset1.duration;
 659    memcpy(dciInfo->coresetCfg.freqDomainResource, coreset1.freqDomainRsrc, FREQ_DOM_RSRC_SIZE);
 660
 661    dciInfo->coresetCfg.cceRegMappingType   = coreset1.cceRegMappingType; /* non-interleaved */
 662    dciInfo->coresetCfg.regBundleSize       = 6; /* must be 6 for non-interleaved */
 663    dciInfo->coresetCfg.interleaverSize     = 0; /* NA for non-interleaved */
 664    dciInfo->coresetCfg.coreSetType         = 1; /* non PBCH coreset */
 665    dciInfo->coresetCfg.shiftIndex          = cellCb->cellCfg.phyCellId;
 666    dciInfo->coresetCfg.precoderGranularity = coreset1.precoderGranularity;
 667    dciInfo->coresetCfg.cceIndex            = 0; /* 0-3 for UL and 4-7 for DL */
 668    dciInfo->coresetCfg.aggregationLevel    = 4; /* same as for sib1 */
 669
 670    dciInfo->formatType = FORMAT0_0;
 671
 672    /* fill UL grant */
 673    dciInfo->format.format0_0.resourceAllocType   = puschInfo->resAllocType;
 674    dciInfo->format.format0_0.freqAlloc.startPrb  = puschInfo->fdAlloc.startPrb;
 675    dciInfo->format.format0_0.freqAlloc.numPrb    = puschInfo->fdAlloc.numPrb;
 676    dciInfo->format.format0_0.timeAlloc.startSymb = puschInfo->tdAlloc.startSymb;
 677    dciInfo->format.format0_0.timeAlloc.numSymb   = puschInfo->tdAlloc.numSymb;
 678    dciInfo->format.format0_0.rowIndex            = 0; /* row Index */
 679    dciInfo->format.format0_0.mcs                 = puschInfo->tbInfo.mcs;
 680    dciInfo->format.format0_0.harqProcId          = puschInfo->harqProcId;
 681    dciInfo->format.format0_0.puschHopFlag        = FALSE; /* disabled */
 682    dciInfo->format.format0_0.freqHopFlag         = FALSE; /* disabled */
 683    dciInfo->format.format0_0.ndi                 = puschInfo->tbInfo.ndi; /* new transmission */
 684    dciInfo->format.format0_0.rv                  = puschInfo->tbInfo.rv;
 685    dciInfo->format.format0_0.tpcCmd              = 0; //Sphoorthi TODO: check
 686    dciInfo->format.format0_0.sUlCfgd             = FALSE; /* SUL not configured */
 687
 688    /* Fill DCI Structure */
 689    dciInfo->dciInfo.rnti                              = ueCb->crnti;
 690    dciInfo->dciInfo.scramblingId                      = cellCb->cellCfg.phyCellId;
 691    dciInfo->dciInfo.scramblingRnti                    = 0;
 692    dciInfo->dciInfo.cceIndex                          = 0; /* 0-3 for UL and 4-7 for DL */
 693    dciInfo->dciInfo.aggregLevel                       = 4;
 694    dciInfo->dciInfo.beamPdcchInfo.numPrgs             = 1;
 695    dciInfo->dciInfo.beamPdcchInfo.prgSize             = 1;
 696    dciInfo->dciInfo.beamPdcchInfo.digBfInterfaces     = 0;
 697    dciInfo->dciInfo.beamPdcchInfo.prg[0].pmIdx        = 0;
 698    dciInfo->dciInfo.beamPdcchInfo.prg[0].beamIdx[0]   = 0;
 699    dciInfo->dciInfo.txPdcchPower.powerValue           = 0;
 700    dciInfo->dciInfo.txPdcchPower.powerControlOffsetSS = 0;
 701    dciInfo->dciInfo.pdschCfg                          = NULL; /* No DL data being sent */
 702
 703    return ROK;
 704 }
 705
 706 /*******************************************************************
 707  *
 708  * @brief Function to Modify Ue Config request from MAC
 709  *
 710  * @details
 711  *
 712  *    Function : MacSchModUeConfigReq
 713  *
 714  *    Functionality: Function to modify Ue Config request from MAC
 715  *
 716  * @params[in]
 717  * @return ROK     - success
 718  *         RFAILED - failure
 719  *
 720  * ****************************************************************/
 721 uint8_t MacSchModUeConfigReq(Pst *pst, SchUeCfg *ueCfg)
 722 {
 723    uint8_t ueIdx, lcIdx, ret = ROK;
 724    SchCellCb    *cellCb = NULLP;
 725    SchUeCb      *ueCb = NULLP;
 726    SchUeCfgRsp  cfgRsp;
 727    Inst         inst = pst->dstInst - 1;
 728    memset(&cfgRsp, 0, sizeof(SchUeCfgRsp));
 729
 730 #ifdef CALL_FLOW_DEBUG_LOG
 731    DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_MODIFY_UE_CONFIG_REQ_TO_SCH\n");
 732 #endif
 733
 734    if(!ueCfg)
 735    {
 736       DU_LOG("\nERROR  -->  SCH : Modifying Ue Config request failed at MacSchModUeConfigReq()");
 737       return RFAILED;
 738    }
 739    DU_LOG("\nDEBUG  -->  SCH : Modifying Ue Config Request for CRNTI[%d]", ueCfg->crnti);
 740    cellCb = getSchCellCb(pst->event, inst, ueCfg);
 741
 742    /* Search if UE already configured */
 743    GET_UE_IDX(ueCfg->crnti, ueIdx);
 744    ueCb = &cellCb->ueCb[ueIdx -1];
 745
 746    if(!ueCb)
 747    {
 748       DU_LOG("\nERROR  -->  SCH : SchUeCb not found at MacSchModUeConfigReq() ");
 749       SchSendUeCfgRspToMac(pst->event, ueCfg, inst, RSP_NOK, &cfgRsp);
 750       return RFAILED;
 751    }
 752    if((ueCb->crnti == ueCfg->crnti) && (ueCb->state == SCH_UE_STATE_ACTIVE))
 753    {
 754       /* Found the UeCb to Reconfig */
 755       ret = fillSchUeCb(ueCb, ueCfg);
 756       if(ret == ROK)
 757       {
 758          ueCb->cellCb = cellCb;
 759          ueCb->srRcvd = false;
 760          ueCb->bsrRcvd = false;
 761          for(lcIdx=0; lcIdx<MAX_NUM_LOGICAL_CHANNEL_GROUPS; lcIdx++)
 762             ueCb->bsrInfo[lcIdx].dataVol = 0;
 763
 764          SchSendUeCfgRspToMac(pst->event, ueCfg, inst, RSP_OK, &cfgRsp);
 765       }
 766    }
 767    return ret;
 768 }
 769
 770 /*******************************************************************
 771 *
 772 * @brief Fill and send UE delete response to MAC
 773 *
 774 * @details
 775 *
 776 *    Function :  SchSendUeDeleteRspToMac
 777 *
 778 *    Functionality: Fill and send UE delete response to MAC
 779 *
 780 * @params[in] Inst inst, SchUeDelete  *ueDelete, SchMacRsp result,
 781 *              ErrorCause cause
 782 * @return ROK     - success
 783 *         RFAILED - failure
 784 *
 785 * ****************************************************************/
 786 void SchSendUeDeleteRspToMac(Inst inst, SchUeDelete  *ueDelete, SchMacRsp result, ErrorCause cause)
 787 {
 788     Pst rspPst;
 789     SchUeDeleteRsp  delRsp;
 790
 791     memset(&delRsp, 0, sizeof(SchUeDeleteRsp));
 792     delRsp.cellId = ueDelete->cellId;
 793     delRsp.crnti = ueDelete->crnti;
 794     delRsp.rsp = result;
 795     delRsp.cause = cause;
 796
 797     /* Filling response post */
 798     memset(&rspPst, 0, sizeof(Pst));
 799     FILL_PST_SCH_TO_MAC(rspPst, inst);
 800     rspPst.event = EVENT_UE_DELETE_RSP_TO_MAC;
 801     SchUeDeleteRspOpts[rspPst.selector](&rspPst, &delRsp);
 802 }
 803
 804 /*******************************************************************
 805 *
 806 * @brief Function to delete Sch Pucch ResrcCfg
 807 *
 808 * @details
 809 *
 810 *    Function : deleteSchPucchResrcCfg
 811 *
 812 *    Functionality: Function to delete Sch Pucch ResrcCfg
 813 *
 814 * @params[in] SchPucchResrcCfg *resrc
 815 * @return void
 816 *
 817 * ****************************************************************/
 818
 819 void deleteSchPucchResrcCfg(SchPucchResrcCfg *resrc)
 820 {
 821    uint8_t rsrcIdx=0;
 822    for(rsrcIdx=0; rsrcIdx < resrc->resrcToAddModListCount; rsrcIdx++)
 823    {
 824       switch(resrc->resrcToAddModList[rsrcIdx].pucchFormat)
 825       {
 826          case PUCCH_FORMAT_0:
 827          {
 828             SCH_FREE(resrc->resrcToAddModList[rsrcIdx].SchPucchFormat.format0,\
 829             sizeof(SchPucchFormat0));
 830             break;
 831          }
 832          case PUCCH_FORMAT_1:
 833          {
 834             SCH_FREE(resrc->resrcToAddModList[rsrcIdx].SchPucchFormat.format1,\
 835             sizeof(SchPucchFormat1));
 836             break;
 837          }
 838          case PUCCH_FORMAT_2:
 839          {
 840             SCH_FREE(resrc->resrcToAddModList[rsrcIdx].SchPucchFormat.format2,\
 841             sizeof(SchPucchFormat2_3));
 842             break;
 843          }
 844          case PUCCH_FORMAT_3:
 845          {
 846             SCH_FREE(resrc->resrcToAddModList[rsrcIdx].SchPucchFormat.format3,\
 847             sizeof(SchPucchFormat2_3));
 848             break;
 849          }
 850          case PUCCH_FORMAT_4:
 851          {
 852             SCH_FREE(resrc->resrcToAddModList[rsrcIdx].SchPucchFormat.format4,\
 853             sizeof(SchPucchFormat4));
 854             break;
 855          }
 856       }
 857    }
 858 }
 859
 860 /*******************************************************************
 861 *
 862 * @brief Function to delete SCH Pdsch ServCellCfg
 863 *
 864 * @details
 865 *
 866 *    Function : deleteSchPdschServCellCfg
 867 *
 868 *    Functionality: Function to delete SCH Pdsch ServCellCfg
 869 *
 870 * @params[in] SchPdschServCellCfg *pdschServCellCfg
 871 * @return void
 872 *
 873 * ****************************************************************/
 874
 875 void deleteSchPdschServCellCfg(SchPdschServCellCfg *pdschServCellCfg)
 876 {
 877    SCH_FREE(pdschServCellCfg->maxMimoLayers, sizeof(uint8_t));
 878    SCH_FREE(pdschServCellCfg->maxCodeBlkGrpPerTb, sizeof(SchMaxCodeBlkGrpPerTB));
 879    SCH_FREE(pdschServCellCfg->codeBlkGrpFlushInd, sizeof(bool));
 880    SCH_FREE(pdschServCellCfg->xOverhead, sizeof(SchPdschXOverhead));
 881 }
 882
 883 /*******************************************************************
 884 *
 885 * @brief Function to  delete SCH UeCb
 886 *
 887 * @details
 888 *
 889 *    Function : deleteSchUeCb
 890 *
 891 *    Functionality: Function to delete SCH UeCb
 892 *
 893 * @params[in]
 894 * @return ROK     - success
 895 *         RFAILED - failure
 896 *
 897 * ****************************************************************/
 898 void deleteSchUeCb(SchUeCb *ueCb)
 899 {
 900    uint8_t timeDomRsrcIdx = 0, ueLcIdx = 0;
 901    SchPucchCfg *pucchCfg = NULLP;
 902    SchPdschConfig *pdschCfg = NULLP;
 903    CmLListCp *lcLL  = NULLP;
 904
 905    if(ueCb)
 906    {
 907       SCH_FREE(ueCb->ueCfg.ambrCfg, sizeof(SchAmbrCfg));
 908       if(ueCb->ueCfg.spCellCfgPres)
 909       {
 910          if(ueCb->ueCfg.spCellCfg.servCellCfg.initDlBwp.pdschCfgPres == true)
 911          {
 912             pdschCfg = &ueCb->ueCfg.spCellCfg.servCellCfg.initDlBwp.pdschCfg;
 913             for(timeDomRsrcIdx = 0; timeDomRsrcIdx < pdschCfg->numTimeDomRsrcAlloc; timeDomRsrcIdx++)
 914                SCH_FREE(pdschCfg->timeDomRsrcAllociList[timeDomRsrcIdx].k0, sizeof(uint8_t));
 915          }
 916
 917          if(ueCb->ueCfg.spCellCfg.servCellCfg.initUlBwp.pucchCfgPres == true)
 918          {
 919             pucchCfg = &ueCb->ueCfg.spCellCfg.servCellCfg.initUlBwp.pucchCfg;
 920             SCH_FREE(pucchCfg->resrcSet,sizeof(SchPucchResrcSetCfg));
 921             if(pucchCfg->resrc)
 922             {
 923                deleteSchPucchResrcCfg(pucchCfg->resrc);
 924                SCH_FREE(pucchCfg->resrc, sizeof(SchPucchResrcCfg));
 925             }
 926             SCH_FREE(pucchCfg->format1, sizeof(SchPucchFormatCfg));
 927             SCH_FREE(pucchCfg->format2, sizeof(SchPucchFormatCfg));
 928             SCH_FREE(pucchCfg->format3, sizeof(SchPucchFormatCfg));
 929             SCH_FREE(pucchCfg->format4, sizeof(SchPucchFormatCfg));
 930             SCH_FREE(pucchCfg->schedReq, sizeof(SchPucchSchedReqCfg));
 931             SCH_FREE(pucchCfg->multiCsiCfg, sizeof(SchPucchMultiCsiCfg));
 932             SCH_FREE(pucchCfg->spatialInfo, sizeof(SchPucchSpatialCfg));
 933             SCH_FREE(pucchCfg->dlDataToUlAck, sizeof(SchPucchDlDataToUlAck));
 934             SCH_FREE(pucchCfg->powerControl,sizeof(SchPucchPowerControl));
 935          }
 936          SCH_FREE(ueCb->ueCfg.spCellCfg.servCellCfg.bwpInactivityTmr, sizeof(uint8_t));
 937          deleteSchPdschServCellCfg(&ueCb->ueCfg.spCellCfg.servCellCfg.pdschServCellCfg);
 938       }
 939       /*Need to Free the memory allocated for S-NSSAI*/
 940       for(ueLcIdx = 0; ueLcIdx < MAX_NUM_LC; ueLcIdx++)
 941       {
 942          SCH_FREE(ueCb->ulInfo.ulLcCtxt[ueLcIdx].snssai, sizeof(Snssai));
 943          SCH_FREE(ueCb->dlInfo.dlLcCtxt[ueLcIdx].snssai, sizeof(Snssai));
 944       }
 945
 946       /*Clearing out Dedicated LC list*/
 947       if(ueCb->dlLcPrbEst.dedLcInfo != NULLP)
 948       {
 949          lcLL = &(ueCb->dlLcPrbEst.dedLcInfo->dedLcList);
 950          deleteLcLL(lcLL);
 951          SCH_FREE(ueCb->dlLcPrbEst.dedLcInfo, sizeof(DedicatedLCInfo));
 952       }
 953       if(ueCb->ulLcPrbEst.dedLcInfo != NULLP)
 954       {
 955          lcLL = &(ueCb->ulLcPrbEst.dedLcInfo->dedLcList);
 956          deleteLcLL(lcLL);
 957          SCH_FREE(ueCb->ulLcPrbEst.dedLcInfo, sizeof(DedicatedLCInfo));
 958       }
 959       /*Deleteing the Default LC list*/
 960       lcLL = &(ueCb->dlLcPrbEst.defLcList);
 961       deleteLcLL(lcLL);
 962
 963       lcLL = &(ueCb->ulLcPrbEst.defLcList);
 964       deleteLcLL(lcLL);
 965
 966       memset(ueCb, 0, sizeof(SchUeCb));
 967    }
 968 }
 969
 970 /*******************************************************************
 971 *
 972 * @brief Function for Ue Delete request from MAC to SCH
 973 *
 974 * @details
 975 *
 976 *    Function : MacSchUeDeleteReq
 977 *
 978 *    Functionality: Function for Ue Delete request from MAC to SCH
 979 *
 980 * @params[in] Pst *pst, SchUeDelete  *ueDelete
 981 * @return ROK     - success
 982 *         RFAILED - failure
 983 *
 984 * ****************************************************************/
 985 uint8_t MacSchUeDeleteReq(Pst *pst, SchUeDelete  *ueDelete)
 986 {
 987     uint8_t      idx=0, ueId=0, ueIdToDel=0, ret=ROK;
 988     ErrorCause   result;
 989     SchCellCb    *cellCb = NULLP;
 990     Inst         inst = pst->dstInst - 1;
 991     CmLList      *node = NULL, *next = NULL;
 992
 993 #ifdef CALL_FLOW_DEBUG_LOG
 994     DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_UE_DELETE_REQ_TO_SCH\n");
 995 #endif
 996
 997     if(!ueDelete)
 998     {
 999        DU_LOG("\nERROR  -->  SCH : MacSchUeDeleteReq(): Ue Delete request failed");
1000        ret = RFAILED;
1001     }
1002     DU_LOG("\nDEBUG  -->  SCH : Ue Delete request received for crnti[%d]", ueDelete->crnti);
1003
1004     cellCb = schCb[inst].cells[idx];
1005
1006     if(cellCb->cellId != ueDelete->cellId)
1007     {
1008        DU_LOG("\nERROR  -->  SCH : MacSchUeDeleteReq(): cell Id is not available");
1009        result =  INVALID_CELLID;
1010     }
1011     else
1012     {
1013        GET_UE_IDX(ueDelete->crnti, ueId);
1014        if(( cellCb->ueCb[ueId-1].crnti == ueDelete->crnti) && ( cellCb->ueCb[ueId-1].state == SCH_UE_STATE_ACTIVE))
1015        {
1016           deleteSchUeCb(&cellCb->ueCb[ueId-1]);
1017
1018           /* Remove UE from ueToBeScheduled list */
1019           node = cellCb->ueToBeScheduled.first;
1020           while(node)
1021           {
1022              next = node->next;
1023              ueId = *(uint8_t *)node->node;
1024              if(ueId == ueIdToDel)
1025              {
1026                 SCH_FREE(node->node, sizeof(uint8_t));
1027                 cmLListDelFrm(&cellCb->ueToBeScheduled, node);
1028                 break;
1029              }
1030              node = next;
1031           }
1032           cellCb->numActvUe--;
1033           result = NOT_APPLICABLE;
1034        }
1035        else
1036        {
1037           DU_LOG("\nERROR  -->  SCH : MacSchUeDeleteReq(): SchUeCb not found");
1038           result =  INVALID_UEIDX;
1039        }
1040     }
1041
1042     if(result == NOT_APPLICABLE)
1043     {
1044        SchSendUeDeleteRspToMac(inst, ueDelete, RSP_OK, result);
1045     }
1046     else
1047     {
1048        SchSendUeDeleteRspToMac(inst, ueDelete, RSP_NOK, result);
1049        ret = RFAILED;
1050     }
1051     return ret;
1052 }
1053
1054 /*******************************************************************
1055  *
1056  * @brief Fill and send Cell delete response to MAC
1057  *
1058  * @details
1059  *
1060  *    Function :  SchSendCellDeleteRspToMac
1061  *
1062  *    Functionality: Fill and send Cell delete response to MAC
1063  *
1064  * @params[in] SchCellDelete  *ueDelete, Inst inst, SchMacRsp result
1065  * @return ROK     - success
1066  *         RFAILED - failure
1067  *
1068  * ****************************************************************/
1069 uint8_t SchSendCellDeleteRspToMac(SchCellDelete  *ueDelete, Inst inst, SchMacRsp result)
1070 {
1071    Pst rspPst;
1072    uint8_t ret=0;
1073
1074    SchCellDeleteRsp  delRsp;
1075
1076    DU_LOG("\nINFO   --> SCH : Filling Cell Delete response");
1077    memset(&delRsp, 0, sizeof(SchCellDeleteRsp));
1078    delRsp.cellId = ueDelete->cellId;
1079    delRsp.rsp = result;
1080
1081    /* Filling response post */
1082    memset(&rspPst, 0, sizeof(Pst));
1083    FILL_PST_SCH_TO_MAC(rspPst, inst);
1084    rspPst.event = EVENT_CELL_DELETE_RSP_TO_MAC;
1085    ret =  SchCellDeleteRspOpts[rspPst.selector](&rspPst, &delRsp);
1086    if(ret == RFAILED)
1087    {
1088       DU_LOG("\nERROR  -->  SCH : SchSendCellDeleteRspToMac(): failed to send the Cell Delete response");
1089       return ret;
1090    }
1091    return ret;
1092 }
1093
1094 /*******************************************************************
1095  *
1096  * @brief Function for cellCb Deletion
1097  *
1098  * @details
1099  *
1100  *    Function : deleteSchCellCb
1101  *
1102  *    Functionality: Function for cellCb Deletion
1103  *
1104  * @params[in] SchCellDelete  *cellDelete
1105  * @return ROK     - success
1106  *         RFAILED - failure
1107  *
1108  * ****************************************************************/
1109 void deleteSchCellCb(SchCellCb *cellCb)
1110 {
1111    uint8_t sliceIdx=0, slotIdx=0;
1112    CmLListCp *list=NULL;
1113    CmLList *node=NULL, *next=NULL;
1114
1115    if(cellCb->schDlSlotInfo)
1116    {
1117       for(slotIdx=0; slotIdx<cellCb->numSlots; slotIdx++)
1118       {
1119          list = &cellCb->schDlSlotInfo[slotIdx]->prbAlloc.freePrbBlockList;
1120          node = list->first;
1121          while(node)
1122          {
1123             next = node->next;
1124             SCH_FREE(node->node, sizeof(FreePrbBlock));
1125             deleteNodeFromLList(list, node);
1126             node = next;
1127          }
1128          SCH_FREE(cellCb->schDlSlotInfo[slotIdx], sizeof(SchDlSlotInfo));
1129       }
1130       SCH_FREE(cellCb->schDlSlotInfo, cellCb->numSlots *sizeof(SchDlSlotInfo*));
1131    }
1132
1133    if(cellCb->schUlSlotInfo)
1134    {
1135       for(slotIdx=0; slotIdx<cellCb->numSlots; slotIdx++)
1136       {
1137          list = &cellCb->schUlSlotInfo[slotIdx]->prbAlloc.freePrbBlockList;
1138          node = list->first;
1139          while(node)
1140          {
1141             next = node->next;
1142             SCH_FREE(node->node, sizeof(FreePrbBlock));
1143             deleteNodeFromLList(list, node);
1144             node = next;
1145          }
1146          SCH_FREE(cellCb->schUlSlotInfo[slotIdx], sizeof(SchUlSlotInfo));
1147       }
1148       SCH_FREE(cellCb->schUlSlotInfo,  cellCb->numSlots * sizeof(SchUlSlotInfo*));
1149    }
1150
1151    if(cellCb->cellCfg.snssai)
1152    {
1153       for(sliceIdx=0; sliceIdx<cellCb->cellCfg.numSliceSupport; sliceIdx++)
1154       {
1155          SCH_FREE(cellCb->cellCfg.snssai[sliceIdx], sizeof(Snssai));
1156       }
1157       SCH_FREE(cellCb->cellCfg.snssai, cellCb->cellCfg.numSliceSupport*sizeof(Snssai*));
1158    }
1159    SCH_FREE(cellCb->cellCfg.rrmPolicy, sizeof(SchRrmPolicy));
1160
1161    /* Remove all UE from ueToBeScheduled list and deallocate */
1162    node = cellCb->ueToBeScheduled.first;
1163    while(node)
1164    {
1165       next = node->next;
1166       SCH_FREE(node->node, sizeof(uint8_t));
1167       cmLListDelFrm(&cellCb->ueToBeScheduled, node);
1168       node = next;
1169    }
1170
1171    memset(cellCb, 0, sizeof(SchCellCb));
1172
1173 }
1174
1175 /*******************************************************************
1176  *
1177  * @brief Function for cell Delete request from MAC to SCH
1178  *
1179  * @details
1180  *
1181  *    Function : MacSchCellDeleteReq
1182  *
1183  *    Functionality: Function for cell Delete request from MAC to SCH
1184  *
1185  * @params[in] Pst *pst, SchCellDelete  *cellDelete
1186  * @return ROK     - success
1187  *         RFAILED - failure
1188  *
1189  * ****************************************************************/
1190
1191 uint8_t MacSchCellDeleteReq(Pst *pst, SchCellDelete  *cellDelete)
1192 {
1193    uint8_t   cellIdx=0, ret = RFAILED;
1194    Inst      inst = pst->dstInst - 1;
1195    SchMacRsp result= RSP_OK;
1196
1197 #ifdef CALL_FLOW_DEBUG_LOG
1198    DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_CELL_DELETE_REQ_TO_SCH\n");
1199 #endif
1200
1201    if(!cellDelete)
1202    {
1203       DU_LOG("\nERROR  -->  SCH : MacSchCellDeleteReq(): Ue Delete request failed");
1204    }
1205    else
1206    {
1207       GET_CELL_IDX(cellDelete->cellId, cellIdx);
1208       if(schCb[inst].cells[cellIdx] == NULLP)
1209       {
1210          DU_LOG("\nERROR  -->  SCH : MacSchCellDeleteReq(): cell Id[%d] is not available", cellDelete->cellId);
1211          result = RSP_NOK;
1212       }
1213       else
1214       {
1215          if(schCb[inst].cells[cellIdx]->cellId == cellDelete->cellId)
1216          {
1217             deleteSchCellCb(schCb[inst].cells[cellIdx]);
1218             result = RSP_OK;
1219             ret = ROK;
1220             SCH_FREE(schCb[inst].cells[cellIdx], sizeof(SchCellCb));
1221             DU_LOG("\nINFO   -->  SCH : Sending Cell Delete response to MAC");
1222          }
1223          else
1224          {
1225             DU_LOG("\nERROR  -->  SCH : MacSchCellDeleteReq(): cell Id[%d] is not available",cellDelete->cellId);
1226             result = RSP_NOK;
1227          }
1228       }
1229
1230       if(SchSendCellDeleteRspToMac(cellDelete, inst, result)!=ROK)
1231       {
1232          DU_LOG("\nERROR  -->  SCH : MacSchCellDeleteReq(): failed to send Cell Delete response");
1233          ret =  RFAILED;
1234       }
1235
1236    }
1237    return ret;
1238 }
1239
1240 /**********************************************************************
1241   End of file
1242  **********************************************************************/