src/du_app/du_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 DU APP */
  19 #include "common_def.h"
  20 #include "lrg.h"
  21 #include "lrg.x"
  22 #include "ckw.h"
  23 #include "ckw.x"
  24 #include "kwu.h"
  25 #include "kwu.x"
  26 #include "lkw.h"
  27 #include "lkw.x"
  28 #include "legtp.h"
  29 #include "du_app_mac_inf.h"
  30 #include "du_app_rlc_inf.h"
  31 #include "du_cfg.h"
  32 #include "du_utils.h"
  33 #include "du_mgr.h"
  34 #include "du_f1ap_msg_hdl.h"
  35 #include "du_ue_mgr.h"
  36
  37 #ifdef O1_ENABLE
  38 #include "AlarmInterface.h"
  39 #include "CmInterface.h"
  40 #endif
  41
  42 DuMacDlCcchInd packMacDlCcchIndOpts[] =
  43 {
  44    packMacDlCcchInd,           /* Loose coupling */
  45    MacProcDlCcchInd,           /* TIght coupling */
  46    packMacDlCcchInd            /* Light weight-loose coupling */
  47 };
  48
  49 DuMacUeCreateReq packMacUeCreateReqOpts[] =
  50 {
  51    packDuMacUeCreateReq,       /* Loose coupling */
  52    MacProcUeCreateReq,         /* TIght coupling */
  53    packDuMacUeCreateReq        /* Light weight-loose coupling */
  54 };
  55
  56 DuRlcUeCreateReq packRlcUeCreateReqOpts[] =
  57 {
  58    packDuRlcUeCreateReq,       /* Loose coupling */
  59    RlcProcUeCreateReq,         /* TIght coupling */
  60    packDuRlcUeCreateReq        /* Light weight-loose coupling */
  61 };
  62
  63 DuDlRrcMsgToRlcFunc duSendDlRrcMsgToRlcOpts[] =
  64 {
  65    packDlRrcMsgToRlc,          /* Loose coupling */
  66    RlcProcDlRrcMsgTransfer,    /* Tight coupling */
  67    packDlRrcMsgToRlc           /* Light weight-loose coupling */
  68 };
  69
  70 DuRlcUeReconfigReq packRlcUeReconfigReqOpts[] =
  71 {
  72    packDuRlcUeReconfigReq,     /* Loose coupling */
  73    RlcProcUeReconfigReq,       /* TIght coupling */
  74    packDuRlcUeReconfigReq      /* Light weight-loose coupling */
  75 };
  76
  77 DuMacUeReconfigReq packMacUeReconfigReqOpts[] =
  78 {
  79    packDuMacUeReconfigReq,     /* Loose coupling */
  80    MacProcUeReconfigReq,       /* TIght coupling */
  81    packDuMacUeReconfigReq      /* Light weight-loose coupling */
  82 };
  83
  84 DuRlcDlUserDataToRlcFunc duSendRlcDlUserDataToRlcOpts[] =
  85 {
  86    packRlcDlUserDataToRlc,        /* Loose coupling */
  87    RlcProcDlUserDataTransfer,  /* Tight coupling */
  88    packRlcDlUserDataToRlc         /* Light weight-loose coupling */
  89 };
  90
  91 DuMacUeDeleteReq packMacUeDeleteReqOpts[] =
  92 {
  93    packDuMacUeDeleteReq,       /* Loose coupling */
  94    MacProcUeDeleteReq,         /* TIght coupling */
  95    packDuMacUeDeleteReq        /* Light weight-loose coupling */
  96 };
  97
  98 DuRlcUeDeleteReq packRlcUeDeleteReqOpts[] =
  99 {
 100    packDuRlcUeDeleteReq,       /* Loose coupling */
 101    RlcProcUeDeleteReq,         /* TIght coupling */
 102    packDuRlcUeDeleteReq        /* Light weight-loose coupling */
 103 };
 104
 105 /******************************************************************
 106  *
 107  * @brief Function to return Drb LcId
 108  *
 109  * @details
 110  *
 111  *    Function : getDrbLcId
 112  *
 113  *    Functionality: Function to return Drb LcId
 114  *
 115  * @params[in] drbBitMap
 116  *
 117  * Returns: lcId - SUCCESS
 118  *         RFAILED - FAILURE
 119  *****************************************************************/
 120
 121 uint8_t getDrbLcId(uint32_t *drbBitMap)
 122 {
 123    uint8_t bitMask = 1, bitPos = 0;
 124    bitPos = MIN_DRB_LCID;
 125
 126    while(bitPos <= MAX_DRB_LCID)
 127    {
 128       if((*drbBitMap & (bitMask << bitPos)) == 0)
 129       {
 130          *drbBitMap = ((bitMask << bitPos)| *drbBitMap);
 131          return bitPos;
 132       }
 133       else
 134       {
 135          bitPos++;
 136       }
 137    }
 138    DU_LOG("\nERROR   -->  DU_APP: Max LC Reached in getDrbLcId()");
 139    return RFAILED;
 140 }
 141
 142 /*******************************************************************
 143  *
 144  * @brief Function to fillDlUserDataInfo
 145  *
 146  * @details
 147  *
 148  *    Function : fillDlUserDataInfo
 149  *
 150  *    Functionality:
 151  *      Function to fillDlUserDataInfo
 152  *
 153  * @params[in] teId,
 154  *             dlDataMsgInfo
 155  *
 156  * @return ROK     - success
 157  *         RFAILED - failure
 158  *
 159  * ****************************************************************/
 160
 161 uint8_t fillDlUserDataInfo(uint32_t teId, RlcDlUserDataInfo *dlDataMsgInfo)
 162 {
 163    uint8_t teIdx = 0;
 164
 165    /*Traversing the duCb to find the CellId, UeId, LCID corresponding to TEID*/
 166    for(teIdx = 0; teIdx < duCb.numTeId; teIdx++)
 167    {
 168       if(duCb.upTnlCfg[teIdx] && (duCb.upTnlCfg[teIdx]->tnlCfg1 != NULLP))
 169       {
 170          if(duCb.upTnlCfg[teIdx]->tnlCfg1->teId == teId)
 171          {
 172             dlDataMsgInfo->cellId = duCb.upTnlCfg[teIdx]->cellId;
 173             dlDataMsgInfo->ueId = duCb.upTnlCfg[teIdx]->ueId;
 174             dlDataMsgInfo->rbId = duCb.upTnlCfg[teIdx]->drbId;
 175             return ROK;
 176          }
 177       }
 178    }
 179    return RFAILED;
 180 }
 181
 182  /*******************************************************************
 183  *
 184  * @brief Build and Send DL Data Message transfer to RLC
 185  *
 186  * @details
 187  *
 188  *    Function : duBuildAndSendDlUserDataToRlc
 189  *
 190  *    Functionality:
 191  *      Build and Send DL Data Message transfer to RLC
 192  *
 193  * @params[in] Cell ID
 194  *             UE Index
 195  *             Logical Channgel ID
 196  *             RRC Message
 197  *             RRC Message Length
 198  * @return ROK     - success
 199  *         RFAILED - failure
 200  *
 201  * ****************************************************************/
 202
 203 uint8_t duBuildAndSendDlUserDataToRlc(uint16_t msgLen, EgtpMsg *egtpMsg)
 204 {
 205    uint8_t ret = RFAILED;
 206    Pst     pst;
 207    RlcDlUserDataInfo *dlDataMsgInfo = NULLP;
 208
 209    DU_ALLOC_SHRABL_BUF(dlDataMsgInfo, sizeof(RlcDlUserDataInfo));
 210    if(!dlDataMsgInfo)
 211    {
 212       DU_LOG("\nERROR  -->  DU_APP : Memory allocation failed for dlDataMsgInfo in duHdlEgtpDlData()");
 213       return RFAILED;
 214    }
 215    memset(dlDataMsgInfo, 0, sizeof(RlcDlUserDataInfo));
 216    dlDataMsgInfo->dlMsg = egtpMsg->msg;
 217    dlDataMsgInfo->msgLen = msgLen;
 218
 219    /* Filling DL DATA Msg Info */
 220    if(fillDlUserDataInfo(egtpMsg->msgHdr.teId, dlDataMsgInfo) == ROK)
 221    {
 222       /* Filling post structure and sending msg */
 223       FILL_PST_DUAPP_TO_RLC(pst, RLC_DL_INST, EVENT_DL_USER_DATA_TRANS_TO_RLC);
 224       DU_LOG("\nDEBUG  -->  DU_APP : Sending User Data Msg to RLC [TEID, nPDU]:[%d, %d]\n",\
 225                        egtpMsg->msgHdr.teId, egtpMsg->msgHdr.nPdu.val);
 226       ret = (*duSendRlcDlUserDataToRlcOpts[pst.selector])(&pst, dlDataMsgInfo);
 227    }
 228    if(ret != ROK)
 229    {
 230       DU_LOG("\nERROR  -->  DU_APP : Failed to send User Data to RLC in duHdlEgtpDlData()");
 231       ODU_PUT_MSG_BUF(dlDataMsgInfo->dlMsg);
 232       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, dlDataMsgInfo, sizeof(RlcDlUserDataInfo));
 233    }
 234    return ret;
 235 }
 236
 237 /*******************************************************************
 238  *
 239  * @brief Handles EGTP data from CU
 240  *
 241  * @details
 242  *
 243  *    Function : duHdlEgtpData
 244  *
 245  *    Functionality:
 246  *      Processes EGTP header and sends data to RLC
 247  *
 248  * @params[in]  Pointer to EGTP Message
 249  * @return ROK     - success
 250  *         RFAILED - failure
 251  *
 252  * ****************************************************************/
 253 uint8_t duHdlEgtpDlData(EgtpMsg  *egtpMsg)
 254 {
 255    uint16_t msgLen = 0;
 256
 257 #ifdef CALL_FLOW_DEBUG_LOG
 258     DU_LOG("\nCall Flow: ENTEGTP -> ENTDUAPP : EVENT_HDL_RECV_DL_DATA\n");
 259 #endif
 260
 261    DU_LOG("\nDEBUG  --> DU_APP : Processing DL data in duHdlEgtpDlData()");
 262
 263    if(!egtpMsg->msg)
 264    {
 265       DU_LOG("\nERROR  -->  DU_APP : Recevied Dl Data is NULLP in duHdlEgtpDlData()");
 266       return RFAILED;
 267    }
 268    ODU_GET_MSG_LEN(egtpMsg->msg, (MsgLen *)&msgLen);
 269    if(duBuildAndSendDlUserDataToRlc(msgLen, egtpMsg) != ROK)
 270    {
 271       DU_LOG("\nERROR  -->  DU_APP : Failed to build DL USer Data in duHdlEgtpDlData()");
 272       return RFAILED;
 273    }
 274    return ROK;
 275 }
 276
 277 /******************************************************************
 278  *
 279  * @brief Builds and Sends DL CCCH Ind to MAC
 280  *
 281  * @details
 282  *
 283  *    Function : duBuildAndSendDlCcchInd
 284  *
 285  *    Functionality: Builds and sends DL CCCH Ind Msg to MAC
 286  *
 287  * @params[in] dlCcchMsg - uint8_t*
 288  * @return ROK     - success
 289  *         RFAILED - failure
 290  *
 291  * ****************************************************************/
 292 uint8_t duBuildAndSendDlCcchInd(uint16_t *cellId, uint16_t *crnti, \
 293       DlCcchMsgType msgType, uint16_t dlCcchMsgSize, uint8_t *dlCcchMsg)
 294 {
 295    uint8_t  ret                  = ROK;
 296    uint16_t idx2;
 297    DlCcchIndInfo *dlCcchIndInfo = NULLP;
 298    Pst pst;
 299
 300    DU_LOG("\nDEBUG   -->  DU APP : Building and Sending DL CCCH Ind to MAC");
 301
 302    DU_ALLOC_SHRABL_BUF(dlCcchIndInfo, sizeof(DlCcchIndInfo));
 303
 304    if(!dlCcchIndInfo)
 305    {
 306       DU_LOG("\nERROR  -->  DU APP : Memory alloc failed while building DL CCCH Ind");
 307       return RFAILED;
 308    }
 309
 310    dlCcchIndInfo->cellId = *cellId;
 311    dlCcchIndInfo->crnti = *crnti;
 312    dlCcchIndInfo->msgType = msgType;
 313    dlCcchIndInfo->dlCcchMsgLen = dlCcchMsgSize;
 314
 315    DU_ALLOC_SHRABL_BUF(dlCcchIndInfo->dlCcchMsg, dlCcchIndInfo->dlCcchMsgLen);
 316    if(!dlCcchIndInfo->dlCcchMsg)
 317    {
 318       DU_LOG("\nERROR  -->  DU APP : Memory alloc failed while building DL CCCH Ind");
 319       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, dlCcchIndInfo, sizeof(DlCcchIndInfo));
 320       return RFAILED;
 321    }
 322    for(idx2 = 0; idx2 < dlCcchIndInfo->dlCcchMsgLen; idx2++)
 323    {
 324       dlCcchIndInfo->dlCcchMsg[idx2] = dlCcchMsg[idx2];
 325    }
 326    DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, dlCcchMsg, dlCcchMsgSize);
 327
 328    /* Fill Pst */
 329    FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_DL_CCCH_IND);
 330    ret = (*packMacDlCcchIndOpts[pst.selector])(&pst, dlCcchIndInfo);
 331    if(ret != ROK)
 332    {
 333       DU_LOG("\nERROR  -->  DU_APP : Failure in sending DL CCCH to MAC");
 334       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, dlCcchIndInfo->dlCcchMsg,\
 335             dlCcchIndInfo->dlCcchMsgLen);
 336       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, dlCcchIndInfo, \
 337             sizeof(DlCcchIndInfo));
 338       ret = RFAILED;
 339    }
 340
 341    return ret;
 342
 343 }
 344
 345 /*******************************************************************
 346  *
 347  * @brief Build and Send DL RRC Message transfer to RLC
 348  *
 349  * @details
 350  *
 351  *    Function : duBuildAndSendDlRrcMsgToRlc
 352  *
 353  *    Functionality:
 354  *      Build and Send DL RRC Message transfer to RLC
 355  *
 356  * @params[in] Cell ID
 357  *             UE Index
 358  *             Logical Channgel ID
 359  *             RRC Message
 360  *             RRC Message Length
 361  * @return ROK     - success
 362  *         RFAILED - failure
 363  *
 364  * ****************************************************************/
 365 uint8_t duBuildAndSendDlRrcMsgToRlc(uint16_t cellId, RlcUeCfg ueCfg, F1DlRrcMsg *f1DlRrcMsg)
 366 {
 367    Pst     pst;
 368    uint8_t ret;
 369    uint8_t lcIdx;
 370    RlcDlRrcMsgInfo  *dlRrcMsgInfo = NULLP;
 371
 372    if(!f1DlRrcMsg)
 373    {
 374       DU_LOG("\nERROR  -->  DU APP : Received Dl RRC Msg is NULL at duBuildAndSendDlRrcMsgToRlc()");
 375       return RFAILED;
 376    }
 377
 378    DU_ALLOC_SHRABL_BUF(dlRrcMsgInfo, sizeof(RlcDlRrcMsgInfo));
 379    if(!dlRrcMsgInfo)
 380    {
 381       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for dlRrcMsgInfo in \
 382          duBuildAndSendDlRrcMsgToRlc");
 383       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, f1DlRrcMsg->rrcMsgPdu, f1DlRrcMsg->rrcMsgSize);
 384       return RFAILED;
 385    }
 386
 387    /* Filling up the RRC msg info */
 388    dlRrcMsgInfo->cellId = cellId;
 389    dlRrcMsgInfo->ueId = ueCfg.ueId;
 390    for(lcIdx = 0; lcIdx <= MAX_NUM_LC; lcIdx++)
 391    {
 392       if(ueCfg.rlcLcCfg[lcIdx].lcId == f1DlRrcMsg->srbId)
 393       {
 394          dlRrcMsgInfo->rbType = ueCfg.rlcLcCfg[lcIdx].rbType;
 395          dlRrcMsgInfo->rbId   = ueCfg.rlcLcCfg[lcIdx].rbId;
 396          dlRrcMsgInfo->lcType = ueCfg.rlcLcCfg[lcIdx].lcType;
 397          dlRrcMsgInfo->lcId   = ueCfg.rlcLcCfg[lcIdx].lcId;
 398          break;
 399       }
 400    }
 401    dlRrcMsgInfo->execDup = f1DlRrcMsg->execDup;
 402    dlRrcMsgInfo->deliveryStaRpt = f1DlRrcMsg->deliveryStatRpt;
 403    dlRrcMsgInfo->msgLen = f1DlRrcMsg->rrcMsgSize;
 404    dlRrcMsgInfo->rrcMsg = f1DlRrcMsg->rrcMsgPdu;
 405
 406    /* Filling post structure and sending msg */
 407    FILL_PST_DUAPP_TO_RLC(pst, RLC_DL_INST, EVENT_DL_RRC_MSG_TRANS_TO_RLC);
 408    DU_LOG("\nDEBUG   -->  DU_APP: Sending Dl RRC Msg to RLC \n");
 409    ret = (*duSendDlRrcMsgToRlcOpts[pst.selector])(&pst, dlRrcMsgInfo);
 410    if(ret != ROK)
 411    {
 412       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, f1DlRrcMsg->rrcMsgPdu, f1DlRrcMsg->rrcMsgSize);
 413       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, dlRrcMsgInfo, sizeof(RlcDlRrcMsgInfo));
 414       return RFAILED;
 415    }
 416
 417    return ROK;
 418 }
 419
 420
 421
 422 /******************************************************************
 423  *
 424  * @brief Process DL RRC Msg recevied from F1AP
 425  *
 426  * @details
 427  *
 428  *    Function : duProcDlRrcMsg
 429  *
 430  *    Functionality: Process DL RRC Msg recevied from F1AP
 431  *
 432  * @params[in] dlCcchMsg - uint8_t*
 433  * @return ROK     - success
 434  *         RFAILED - failure
 435  *
 436  * ****************************************************************/
 437
 438 uint8_t duProcDlRrcMsg(F1DlRrcMsg *dlRrcMsg)
 439 {
 440    uint8_t ueIdx, ret;
 441    uint16_t crnti, cellId, cellIdx;
 442    bool ueCcchCtxtFound = false;
 443    bool ueFound = false;
 444
 445    ret = ROK;
 446
 447    if(dlRrcMsg->srbId == SRB0_LCID) //RRC connection setup
 448    {
 449       for(ueIdx=0; ueIdx<duCb.numUe; ueIdx++)
 450       {
 451          if(dlRrcMsg->gnbDuUeF1apId == duCb.ueCcchCtxt[ueIdx].gnbDuUeF1apId)
 452          {
 453             ueCcchCtxtFound = true;
 454             crnti  = duCb.ueCcchCtxt[ueIdx].crnti;
 455             cellId = duCb.ueCcchCtxt[ueIdx].cellId;
 456             break;
 457          }
 458       }
 459    }
 460    if(ueCcchCtxtFound)
 461    {
 462       ret = duBuildAndSendDlCcchInd(&cellId, &crnti, RRC_SETUP, dlRrcMsg->rrcMsgSize, dlRrcMsg->rrcMsgPdu);
 463       if(ret == RFAILED)
 464       {
 465          DU_LOG("\nERROR  -->  DU APP : Failed to build DlCcch Ind at procDlRrcMsgTrans()");
 466       }
 467       else
 468       {
 469          if(duCb.actvCellLst[cellId-1] == NULLP)
 470          {
 471             DU_LOG("\nERROR  -->  DU APP : cellId [%d] does not exist", cellId);
 472             ret = RFAILED;
 473          }
 474          if(duCb.actvCellLst[cellId-1]->numActvUes < MAX_NUM_UE)
 475          {
 476             ret = duCreateUeCb(&duCb.ueCcchCtxt[ueIdx], dlRrcMsg->gnbCuUeF1apId);
 477             if(ret == RFAILED)
 478             {
 479                DU_LOG("\nERROR  -->  DU APP : Failed to createUeCb for cellId [%d] at procDlRrcMsgTrans()", \
 480                      duCb.ueCcchCtxt[ueIdx].cellId);
 481             }
 482          }
 483          else
 484          {
 485             DU_LOG("\nERROR   -->  DU_APP: Max Active UEs has reached at procDlRrcMsgTrans()");
 486             ret = RFAILED;
 487          }
 488       }
 489    }
 490    else
 491    {
 492       for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
 493       {
 494          for(ueIdx = 0 ; ueIdx < MAX_NUM_UE; ueIdx++)
 495          {
 496             if(duCb.actvCellLst[cellIdx] && (dlRrcMsg->gnbCuUeF1apId == duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId)
 497                   && (dlRrcMsg->gnbDuUeF1apId == duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId))
 498             {
 499                ueFound = true;
 500                ret = duBuildAndSendDlRrcMsgToRlc(duCb.actvCellLst[cellIdx]->cellId, \
 501                      duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg, dlRrcMsg);
 502                break;
 503             }
 504          }
 505          if(ueFound)
 506             break;
 507       }
 508       if(!ueFound)
 509       {
 510          DU_LOG("\nERROR   -->  DU_APP: UE ID [%d] not found", dlRrcMsg->gnbDuUeF1apId);
 511          ret = RFAILED;
 512       }
 513    }
 514    return ret;
 515 }
 516
 517 /******************************************************************
 518  *
 519  * @brief Processes UL CCCH Ind recvd from MAC
 520  *
 521  * @details
 522  *
 523  *    Function : duProcUlCcchInd
 524  *
 525  *    Functionality: Processes UL CCCH Ind recvd from MAC
 526  *
 527  * @params[in] UlCcchIndInfo *ulCcchIndInfo
 528  * @return ROK     - success
 529  *         RFAILED - failure
 530  *
 531  * ****************************************************************/
 532 uint8_t duProcUlCcchInd(UlCcchIndInfo *ulCcchIndInfo)
 533 {
 534
 535    uint8_t ret = ROK;
 536    int32_t gnbDuUeF1apId = 0;
 537
 538    if(ulCcchIndInfo->crnti)
 539    {
 540       GET_UE_ID(ulCcchIndInfo->crnti, gnbDuUeF1apId);
 541    }
 542    else
 543    {
 544       DU_LOG("\nERROR  -->  DU_APP : Received invalid CRNTI [%d] ", ulCcchIndInfo->crnti);
 545       return RFAILED;
 546    }
 547
 548    /* Store Ue mapping */
 549    duCb.ueCcchCtxt[duCb.numUe].gnbDuUeF1apId = (uint32_t)gnbDuUeF1apId;
 550    duCb.ueCcchCtxt[duCb.numUe].crnti         = ulCcchIndInfo->crnti;
 551    duCb.ueCcchCtxt[duCb.numUe].cellId        = ulCcchIndInfo->cellId;
 552
 553    duCb.numUe++;
 554
 555    ret = (BuildAndSendInitialRrcMsgTransfer(gnbDuUeF1apId, ulCcchIndInfo->crnti, ulCcchIndInfo->ulCcchMsgLen,
 556             ulCcchIndInfo->ulCcchMsg));
 557    if(ret != ROK)
 558    {
 559       DU_LOG("\nERROR  -->  DU_APP : BuildAndSendInitialRrcMsgTransfer failed");
 560    }
 561
 562    DU_FREE_SHRABL_BUF(MAC_MEM_REGION, MAC_POOL, ulCcchIndInfo->ulCcchMsg, ulCcchIndInfo->ulCcchMsgLen);
 563    DU_FREE_SHRABL_BUF(MAC_MEM_REGION, MAC_POOL, ulCcchIndInfo, sizeof(UlCcchIndInfo));
 564
 565    return ret;
 566
 567 }
 568
 569 /******************************************************************
 570  *
 571  * @brief Fills Default UL LC Cfg
 572  *
 573  * @details
 574  *
 575  *    Function : fillDefaultUlLcCfg
 576  *
 577  *    Functionality: Fills Default UL LC Cfg
 578  *
 579  * @params[in]  UlLcCfg *ulLcCfg
 580  * @return void
 581  *****************************************************************/
 582 void fillDefaultUlLcCfg(UlLcCfg *ulLcCfg)
 583 {
 584    ulLcCfg->priority = LC_PRIORITY_1;
 585    ulLcCfg->lcGroup =  0;
 586    ulLcCfg->schReqId = 0;
 587    ulLcCfg->pbr = PBR_KBPS_INFINITY;
 588    ulLcCfg->bsd = BSD_MS_1000;
 589 }
 590
 591 /******************************************************************
 592  *
 593  * @brief Fills Initial DL Bandwidth Part
 594  *
 595  * @details
 596  *
 597  *    Function : fillDefaultInitDlBwp
 598  *
 599  *    Functionality: Fills Initial DL Bandwidth Part
 600  *
 601  * @params[in]  InitialDlBwp *initDlBwp
 602  * @return ROK - success
 603  *         RFAILED - failure
 604  *
 605  *****************************************************************/
 606 uint8_t fillDefaultInitDlBwp(InitialDlBwp *initDlBwp)
 607 {
 608    uint8_t idx = 0;
 609    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
 610    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
 611
 612    if(initDlBwp)
 613    {
 614       /* Filling PDCCH Config */
 615       initDlBwp->pdcchPresent = TRUE;
 616       if(initDlBwp->pdcchPresent)
 617       {
 618          initDlBwp->pdcchCfg.numCRsetToAddMod = PDCCH_CTRL_RSRC_SET_ONE_ID;
 619          memset(initDlBwp->pdcchCfg.cRSetToAddModList, 0, MAX_NUM_CRSET);
 620          if(initDlBwp->pdcchCfg.numCRsetToAddMod <= MAX_NUM_CRSET)
 621          {
 622             initDlBwp->pdcchCfg.cRSetToAddModList[idx].cRSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
 623             memset(initDlBwp->pdcchCfg.cRSetToAddModList[idx].freqDomainRsrc, 0, FREQ_DOM_RSRC_SIZE);
 624             coreset0EndPrb = CORESET0_END_PRB;
 625             coreset1StartPrb = coreset0EndPrb +6;
 626             coreset1NumPrb = CORESET1_NUM_PRB;
 627             /* calculate the PRBs */
 628             fillCoresetFeqDomAllocMap(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
 629             memcpy(initDlBwp->pdcchCfg.cRSetToAddModList[idx].freqDomainRsrc, freqDomainResource, FREQ_DOM_RSRC_SIZE);
 630
 631             initDlBwp->pdcchCfg.cRSetToAddModList[idx].duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
 632             initDlBwp->pdcchCfg.cRSetToAddModList[idx].cceRegMappingType = CCE_REG_MAPPINGTYPE_PR_NONINTERLEAVED;
 633             initDlBwp->pdcchCfg.cRSetToAddModList[idx].precoderGranularity = ALL_CONTIGUOUS_RBS;
 634             initDlBwp->pdcchCfg.cRSetToAddModList[idx].dmrsScramblingId = SCRAMBLING_ID;
 635          }
 636          initDlBwp->pdcchCfg.numCRsetToRel = 0;
 637
 638          /* Filling Serach Space */
 639          initDlBwp->pdcchCfg.numSearchSpcToAddMod = PDCCH_CTRL_RSRC_SET_ONE_ID;
 640          memset(initDlBwp->pdcchCfg.searchSpcToAddModList, 0, MAX_NUM_CRSET);
 641          if(initDlBwp->pdcchCfg.numSearchSpcToAddMod <= MAX_NUM_CRSET)
 642          {
 643             initDlBwp->pdcchCfg.searchSpcToAddModList[idx].searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
 644             initDlBwp->pdcchCfg.searchSpcToAddModList[idx].cRSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
 645             initDlBwp->pdcchCfg.searchSpcToAddModList[idx].mSlotPeriodicityAndOffset = SLOTPERIODICITYANDOFFSET_PR_SL1;
 646             memset(initDlBwp->pdcchCfg.searchSpcToAddModList[idx].mSymbolsWithinSlot, 0, MONITORING_SYMB_WITHIN_SLOT_SIZE);
 647             initDlBwp->pdcchCfg.searchSpcToAddModList[idx].mSymbolsWithinSlot[idx] = PDCCH_SYMBOL_WITHIN_SLOT;
 648             initDlBwp->pdcchCfg.searchSpcToAddModList[idx].numCandidatesAggLevel1 = AGGREGATIONLEVEL_N8;
 649             initDlBwp->pdcchCfg.searchSpcToAddModList[idx].numCandidatesAggLevel2 = AGGREGATIONLEVEL_N8;
 650             initDlBwp->pdcchCfg.searchSpcToAddModList[idx].numCandidatesAggLevel4 = AGGREGATIONLEVEL_N4;
 651             initDlBwp->pdcchCfg.searchSpcToAddModList[idx].numCandidatesAggLevel8 = AGGREGATIONLEVEL_N2;
 652             initDlBwp->pdcchCfg.searchSpcToAddModList[idx].numCandidatesAggLevel16 = AGGREGATIONLEVEL_N1;
 653             initDlBwp->pdcchCfg.searchSpcToAddModList[idx].searchSpaceType = SEARCHSPACETYPE_PR_UE_SPECIFIC;
 654             initDlBwp->pdcchCfg.searchSpcToAddModList[idx].ueSpecificDciFormat = PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
 655          }
 656          initDlBwp->pdcchCfg.numSearchSpcToRel = 0;
 657       }
 658
 659       /* Filling PDSCH Config */
 660       initDlBwp->pdschPresent = TRUE;
 661       if(initDlBwp->pdschPresent)
 662       {
 663          initDlBwp->pdschCfg.dmrsDlCfgForPdschMapTypeA.addPos = ADDITIONALPOSITION_POS0;
 664          initDlBwp->pdschCfg.resourceAllocType = RESOURCEALLOCATION_TYPE1;
 665
 666          initDlBwp->pdschCfg.numTimeDomRsrcAlloc = NUM_TIME_DOM_RSRC_ALLOC;
 667
 668          idx = 0;
 669          initDlBwp->pdschCfg.timeDomRsrcAllociList[idx].mappingType = MAPPING_TYPEA;
 670          initDlBwp->pdschCfg.timeDomRsrcAllociList[idx].startSymbol = PDSCH_START_SYMBOL;
 671          initDlBwp->pdschCfg.timeDomRsrcAllociList[idx].symbolLength = PDSCH_LENGTH_SYMBOL;
 672          initDlBwp->pdschCfg.timeDomRsrcAllociList[idx].startSymbolAndLength = calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
 673
 674          idx++;
 675          DU_ALLOC_SHRABL_BUF(initDlBwp->pdschCfg.timeDomRsrcAllociList[idx].k0, sizeof(uint8_t));
 676          if(initDlBwp->pdschCfg.timeDomRsrcAllociList[idx].k0 == NULLP)
 677          {
 678             DU_LOG("\nERROR  -->  DUAPP : Failed to allocate memory to K0 in fillDefaultInitDlBwp");
 679             return RFAILED;
 680          }
 681          if(initDlBwp->pdschCfg.timeDomRsrcAllociList[idx].k0)
 682             *(initDlBwp->pdschCfg.timeDomRsrcAllociList[idx].k0) = 1;
 683          initDlBwp->pdschCfg.timeDomRsrcAllociList[idx].mappingType = MAPPING_TYPEA;
 684          initDlBwp->pdschCfg.timeDomRsrcAllociList[idx].startSymbol = PDSCH_START_SYMBOL;
 685          initDlBwp->pdschCfg.timeDomRsrcAllociList[idx].symbolLength = PDSCH_LENGTH_SYMBOL;
 686          initDlBwp->pdschCfg.timeDomRsrcAllociList[idx].startSymbolAndLength = calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
 687
 688          initDlBwp->pdschCfg.rbgSize = RBG_SIZE_CONFIG1;
 689          initDlBwp->pdschCfg.numCodeWordsSchByDci = CODEWORDS_SCHED_BY_DCI_N1;
 690          initDlBwp->pdschCfg.bundlingType = TYPE_STATIC_BUNDLING;
 691          initDlBwp->pdschCfg.bundlingInfo.StaticBundling.size = 0;
 692       }
 693    }
 694
 695    return ROK;
 696 }
 697
 698 /******************************************************************
 699  *
 700  * @brief Fills Initial UL Bandwidth Part
 701  *
 702  * @details
 703  *
 704  *    Function : fillDefaultInitUlBwp
 705  *
 706  *    Functionality: Fills Initial UL Bandwidth Part
 707  *
 708  * @params[in]  InitialUlBwp *initUlBwp
 709  * @return void
 710  *
 711  *****************************************************************/
 712 void fillDefaultInitUlBwp(InitialUlBwp *initUlBwp)
 713 {
 714    uint8_t idx;
 715    if(initUlBwp)
 716    {
 717       initUlBwp->pucchPresent = FALSE;
 718
 719       /*Filling PUSCH Config */
 720       initUlBwp->puschPresent = TRUE;
 721       if(initUlBwp->puschPresent)
 722       {
 723          initUlBwp->puschCfg.dataScramblingId = SCRAMBLING_ID;
 724          initUlBwp->puschCfg.dmrsUlCfgForPuschMapTypeA.addPos = ADDITIONALPOSITION_POS0;
 725          initUlBwp->puschCfg.dmrsUlCfgForPuschMapTypeA.transPrecodDisabled. \
 726             scramblingId0 = SCRAMBLING_ID;
 727          initUlBwp->puschCfg.resourceAllocType = RESOURCEALLOCATION_TYPE1;
 728          initUlBwp->puschCfg.numTimeDomRsrcAlloc = 2;
 729          idx = 0;
 730          if(initUlBwp->puschCfg.numTimeDomRsrcAlloc <= MAX_NUM_UL_ALLOC)
 731          {
 732             initUlBwp->puschCfg.timeDomRsrcAllocList[idx].k2 = PUSCH_K2_CFG1;
 733             initUlBwp->puschCfg.timeDomRsrcAllocList[idx].mappingType =\
 734                MAPPING_TYPEA;
 735             initUlBwp->puschCfg.timeDomRsrcAllocList[idx].startSymbol = PUSCH_START_SYMBOL;
 736             initUlBwp->puschCfg.timeDomRsrcAllocList[idx].symbolLength = PUSCH_LENGTH_SYMBOL;
 737             initUlBwp->puschCfg.timeDomRsrcAllocList[idx].startSymbolAndLength =\
 738                calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
 739
 740        idx++;
 741        initUlBwp->puschCfg.timeDomRsrcAllocList[idx].k2 = PUSCH_K2_CFG2;
 742        initUlBwp->puschCfg.timeDomRsrcAllocList[idx].mappingType = MAPPING_TYPEA;
 743        initUlBwp->puschCfg.timeDomRsrcAllocList[idx].startSymbol = PUSCH_START_SYMBOL;
 744        initUlBwp->puschCfg.timeDomRsrcAllocList[idx].symbolLength = PUSCH_LENGTH_SYMBOL;
 745        initUlBwp->puschCfg.timeDomRsrcAllocList[idx].startSymbolAndLength =\
 746           calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
 747          }
 748          initUlBwp->puschCfg.transformPrecoder = TRANSFORM_PRECODER_DISABLED;
 749       }
 750    }
 751    else
 752    {
 753       DU_LOG("\nERROR  -->  DU APP : Memory is NULL of InitalUlBwp");
 754    }
 755
 756 }
 757 /******************************************************************
 758  *
 759  * @brief Fills SpCell Group Info
 760  *
 761  * @details
 762  *
 763  *    Function : fillDefaultSpCellGrpInfo
 764  *
 765  *    Functionality: Fills Sp Cell Group Info
 766  *
 767  * @params[in]  MacUeCfg *macUeCfg
 768  * @return ROK - Success
 769  *         RFAILED - Failure
 770  *
 771  *****************************************************************/
 772 uint8_t fillDefaultSpCellGrpInfo(MacUeCfg *macUeCfg)
 773 {
 774    SpCellCfg *spCell = NULL;
 775
 776    if(macUeCfg)
 777       spCell = &macUeCfg->spCellCfg;
 778
 779    if(spCell)
 780    {
 781       macUeCfg->spCellCfgPres = true;
 782
 783       spCell->servCellIdx = SERV_CELL_IDX;
 784       /* Filling Initial Dl Bwp */
 785       if((fillDefaultInitDlBwp(&spCell->servCellCfg.initDlBwp)) != ROK)
 786       {
 787          DU_LOG("\nERROR  -->  DUAPP : Failed in fillDefaultInitDlBwp");
 788          return RFAILED;
 789       }
 790
 791       spCell->servCellCfg.numDlBwpToAdd    = 0;
 792       spCell->servCellCfg.firstActvDlBwpId = ACTIVE_DL_BWP_ID;
 793       spCell->servCellCfg.defaultDlBwpId   = ACTIVE_DL_BWP_ID;
 794       spCell->servCellCfg.bwpInactivityTmr = NULLP;
 795       spCell->servCellCfg.pdschServCellCfg.maxMimoLayers = NULLP;
 796       spCell->servCellCfg.pdschServCellCfg.maxCodeBlkGrpPerTb = NULLP;
 797       spCell->servCellCfg.pdschServCellCfg.codeBlkGrpFlushInd = NULLP;
 798       spCell->servCellCfg.pdschServCellCfg.xOverhead = NULLP;
 799       spCell->servCellCfg.pdschServCellCfg.numHarqProcForPdsch = NUM_HARQ_PROC_FOR_PDSCH_N_16;
 800
 801       /* Filling Initial UL Bwp*/
 802       fillDefaultInitUlBwp(&spCell->servCellCfg.initUlBwp);
 803       spCell->servCellCfg.numUlBwpToAdd     = 0;
 804       spCell->servCellCfg.firstActvUlBwpId  = ACTIVE_DL_BWP_ID;
 805    }
 806    else
 807    {
 808       DU_LOG("\nERROR  -->  DU APP : Memory is NULL for SpCellGrp");
 809       return RFAILED;
 810    }
 811    return ROK;
 812 }
 813
 814 /******************************************************************
 815  *
 816  * @brief Fills Physical Cell Group Info
 817  *
 818  * @details
 819  *
 820  *    Function : fillDefaultPhyCellGrpInfo
 821  *
 822  *    Functionality: Fills Physical Cell Group Info
 823  *
 824  * @params[in]  MacUeCfg *macUeCfg
 825  * @return void
 826  *
 827  *****************************************************************/
 828 void fillDefaultPhyCellGrpInfo(MacUeCfg *macUeCfg)
 829 {
 830    PhyCellGrpCfg *cellGrp = NULL;
 831
 832    if(macUeCfg)
 833       cellGrp = &macUeCfg->phyCellGrpCfg;
 834
 835    if(cellGrp)
 836    {
 837       macUeCfg->phyCellGrpCfgPres = true;
 838       cellGrp->pdschHarqAckCodebook = PDSCH_HARQ_ACK_CODEBOOK_DYNAMIC;
 839       cellGrp->pNrFr1 = P_NR_FR1;
 840    }
 841    else
 842    {
 843       DU_LOG("\nERROR  -->  DU APP : Memory is NULL for Physical Cell Group");
 844    }
 845 }
 846
 847 /******************************************************************
 848  *
 849  * @brief Fills Mac Cell Group Info
 850  *
 851  * @details
 852  *
 853  *    Function : fillDefaultMacCellGrpInfo
 854  *
 855  *    Functionality: Fills Mac Cell Group Info
 856  *
 857  * @params[in]  MacUeCfg *macUeCfg
 858  * @return void
 859  *
 860  *****************************************************************/
 861 void fillDefaultMacCellGrpInfo(MacUeCfg *macUeCfg)
 862 {
 863    uint8_t idx;
 864    MacCellGrpCfg *cellGrp = NULL;
 865
 866    if(macUeCfg)
 867       cellGrp = &macUeCfg->macCellGrpCfg;
 868
 869    if(cellGrp)
 870    {
 871       macUeCfg->macCellGrpCfgPres = true;
 872
 873       /* Filling Scheduling Request Config */
 874       cellGrp->schReqCfg.addModListCount = 1;
 875       if(cellGrp->schReqCfg.addModListCount <= MAX_NUM_SR_CFG_PER_CELL_GRP)
 876       {
 877          for(idx = 0; idx < cellGrp->schReqCfg.addModListCount; idx++)
 878          {
 879             cellGrp->schReqCfg.addModList[idx].schedReqId    = SCH_REQ_ID;
 880             cellGrp->schReqCfg.addModList[idx].srProhibitTmr = SR_PROHIBIT_MS_32;
 881             cellGrp->schReqCfg.addModList[idx].srTransMax    = SR_TRANS_MAX_N_16;
 882          }
 883       }
 884       cellGrp->schReqCfg.relListCount = 0;
 885
 886       /* Filling Tag config */
 887       cellGrp->tagCfg.addModListCount = 1;
 888       if(cellGrp->tagCfg.addModListCount <= MAC_NUM_TAGS)
 889       {
 890          for(idx = 0; idx < cellGrp->tagCfg.addModListCount; idx++)
 891          {
 892             cellGrp->tagCfg.addModList[idx].tagId = TAG_ID;
 893             cellGrp->tagCfg.addModList[idx].timeAlignTimer = TIME_ALIGNMENT_TIMER_INFINITY;
 894          }
 895       }
 896       cellGrp->tagCfg.relListCount = 0;
 897
 898       /* Filling BSR config */
 899       cellGrp->bsrTmrCfg.periodicTimer = BSR_PERIODIC_TIMER_SF_10;
 900       cellGrp->bsrTmrCfg.retxTimer = BSR_RETX_TIMER_SF_320;
 901       cellGrp->bsrTmrCfg.srDelayTimer = BSR_SR_DELAY_TMR_2560;
 902
 903       /* Filling PHR config */
 904       cellGrp->phrCfgSetupPres = true;
 905       cellGrp->phrCfg.periodicTimer = PHR_PERIODIC_TIMER_INFINITY;
 906       cellGrp->phrCfg.prohibitTimer = PHR_PROHIBIT_TIMER_SF_0;
 907       cellGrp->phrCfg.txPowerFactor = PHR_TX_PWR_FACTOR_CHANGE_INFINITY;
 908       cellGrp->phrCfg.multiplePHR   = false;
 909       cellGrp->phrCfg.dummy         = false;
 910       cellGrp->phrCfg.phrType2OtherCell = false;
 911       cellGrp->phrCfg.phrOtherCG = PHR_MODE_OTHER_CG_REAL;
 912
 913    }
 914    else
 915    {
 916       DU_LOG("\nERROR  -->  DU APP : Memory is NULL for Master Cell Group");
 917    }
 918 }
 919
 920 /*******************************************************************
 921  *
 922  * @brief Fills default modulation info for a UE
 923  *
 924  * @details
 925  *
 926  *    Function : fillDefaultModulation
 927  *
 928  *    Functionality: Fills default modulation info for a UE
 929  *
 930  * @params[in] Pointer to MAC UE configuration
 931  * @return ROK     - success
 932  *         RFAILED - failure
 933  *
 934  * ****************************************************************/
 935 void fillDefaultModulation(MacUeCfg *ueCfg)
 936 {
 937    ueCfg->dlModInfo.modOrder = MOD_ORDER_QPSK;
 938    ueCfg->dlModInfo.mcsIndex = DEFAULT_MCS;
 939    ueCfg->dlModInfo.mcsTable = MCS_TABLE_QAM64; /* Spec 38.214-Table 5.1.3.1-1 */
 940
 941    ueCfg->ulModInfo.modOrder = MOD_ORDER_QPSK;
 942    ueCfg->ulModInfo.mcsIndex = DEFAULT_MCS;
 943    ueCfg->ulModInfo.mcsTable = MCS_TABLE_QAM64; /* Spec 38.214-Table 5.1.3.1-1 */
 944 }
 945
 946 /******************************************************************
 947  *
 948  * @brief Function to fill Mac Lc Cfg for SRB1
 949  *
 950  * @details
 951  *
 952  *    Function : fillMacSrb1LcCfg
 953  *
 954  *    Functionality: Function to fill Mac Lc cfg for SRB1
 955  *
 956  * @params[in]  LcCfg *lcCfg, LcCfg *ueSetReqDb
 957  * @return void
 958  *****************************************************************/
 959
 960 void fillMacSrb1LcCfg(LcCfg *macLcCfg)
 961 {
 962    macLcCfg->lcId   = SRB1_LCID;
 963    macLcCfg->configType = CONFIG_ADD;
 964    macLcCfg->drbQos = NULLP;
 965    macLcCfg->snssai = NULLP;
 966    macLcCfg->ulLcCfgPres = true;
 967    fillDefaultUlLcCfg(&macLcCfg->ulLcCfg);
 968 }
 969
 970 /******************************************************************
 971  *
 972  * @brief Function to fill the Lc cfg from ueSetupReqDb
 973  *
 974  * @details
 975  *
 976  *    Function : fillMacLcCfgToAddMod
 977  *
 978  *    Functionality: Function to fill the Lc cfg from ueSetupReqDb
 979  *
 980  * @params[in]  LcCfg *lcCfg, LcCfg *ueSetReqDb
 981  * @return ROK/RFAILED
 982  *
 983  *****************************************************************/
 984
 985 uint8_t fillMacLcCfgToAddMod(LcCfg *macLcCfgToSend, LcCfg *ueLcCfgDb, LcCfg *oldLcCfg, Bool toUpdate)
 986 {
 987    if(!toUpdate)
 988    {
 989       if(macLcCfgToSend)
 990       {
 991          macLcCfgToSend->lcId = ueLcCfgDb->lcId;
 992          macLcCfgToSend->configType = ueLcCfgDb->configType;
 993
 994          if(ueLcCfgDb->drbQos)
 995             macLcCfgToSend->drbQos = ueLcCfgDb->drbQos;
 996          else if(oldLcCfg)
 997             macLcCfgToSend->drbQos = oldLcCfg->drbQos;
 998          else
 999             macLcCfgToSend->drbQos = NULL;
1000
1001          if(ueLcCfgDb->snssai)
1002             macLcCfgToSend->snssai = ueLcCfgDb->snssai;
1003          else if(oldLcCfg)
1004             macLcCfgToSend->snssai = oldLcCfg->snssai;
1005          else
1006             macLcCfgToSend->snssai = NULL;
1007
1008          macLcCfgToSend->ulLcCfgPres = ueLcCfgDb->ulLcCfgPres;
1009          memcpy(&macLcCfgToSend->ulLcCfg, &ueLcCfgDb->ulLcCfg, sizeof(UlLcCfg));
1010          memcpy(&macLcCfgToSend->dlLcCfg, &ueLcCfgDb->dlLcCfg, sizeof(DlLcCfg));
1011       }
1012    }
1013    else
1014    {
1015       oldLcCfg->lcId = ueLcCfgDb->lcId;
1016       oldLcCfg->configType = ueLcCfgDb->configType;
1017
1018       if(ueLcCfgDb->drbQos)
1019       {
1020          if(oldLcCfg->drbQos)
1021             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, oldLcCfg->drbQos, sizeof(DrbQosInfo));
1022
1023          DU_ALLOC_SHRABL_BUF(oldLcCfg->drbQos, sizeof(DrbQosInfo));
1024          if(oldLcCfg->drbQos == NULL)
1025          {
1026             DU_LOG("\nERROR  -->  DU APP : Memory Alloc Failed at fillMacLcCfgToAddMod()");
1027             return RFAILED;
1028          }
1029          memcpy(oldLcCfg->drbQos, ueLcCfgDb->drbQos, sizeof(DrbQosInfo));
1030       }
1031
1032       if(ueLcCfgDb->snssai)
1033       {
1034          if(oldLcCfg->snssai)
1035             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, oldLcCfg->snssai, sizeof(Snssai));
1036
1037          DU_ALLOC_SHRABL_BUF(oldLcCfg->snssai, sizeof(Snssai));
1038          if(oldLcCfg->snssai == NULL)
1039          {
1040             DU_LOG("\nERROR  -->  DU APP : Memory Alloc Failed at fillMacLcCfgToAddMod()");
1041             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, oldLcCfg->drbQos, sizeof(DrbQosInfo));
1042             return RFAILED;
1043          }
1044          memcpy(oldLcCfg->snssai, ueLcCfgDb->snssai, sizeof(Snssai));
1045       }
1046
1047       oldLcCfg->ulLcCfgPres = ueLcCfgDb->ulLcCfgPres;
1048       memcpy(&oldLcCfg->ulLcCfg, &ueLcCfgDb->ulLcCfg, sizeof(UlLcCfg));
1049       memcpy(&oldLcCfg->dlLcCfg, &ueLcCfgDb->dlLcCfg, sizeof(DlLcCfg));
1050    }
1051    return ROK;
1052 }
1053
1054 /******************************************************************
1055  *
1056  * @brief Function to copy the Bit rate from ueSetupReqDb
1057  *
1058  * @details
1059  *
1060  *    Function : fillAmbr
1061  *
1062  *    Functionality: Function to copy bit Rate from ueSetupReqDb
1063  *
1064  * @params[in]  AmbrCfg **macAmbr, AmbrCfg  *ueDbAmbr
1065  * @return ROK/RFAILED
1066  *
1067  *****************************************************************/
1068
1069 uint8_t fillAmbr(AmbrCfg **macAmbrCfgToSend, AmbrCfg *ueDbAmbr, AmbrCfg **oldMacAmbrCfg, Bool toUpdate)
1070 {
1071    if(!toUpdate)
1072    {
1073       if(ueDbAmbr)
1074       {
1075          *macAmbrCfgToSend = ueDbAmbr;
1076       }
1077       else if(oldMacAmbrCfg)
1078          *macAmbrCfgToSend = *oldMacAmbrCfg;
1079    }
1080    else
1081    {
1082       if(ueDbAmbr)
1083       {
1084          if(oldMacAmbrCfg)
1085          {
1086             if(*oldMacAmbrCfg)
1087             {
1088                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, *oldMacAmbrCfg, sizeof(AmbrCfg));
1089             }
1090             DU_ALLOC_SHRABL_BUF(*oldMacAmbrCfg, sizeof(AmbrCfg));
1091             if(*oldMacAmbrCfg == NULLP)
1092             {
1093                DU_LOG("\nERROR  -->  DU APP : Memory Alloc Failed at fillAmbr()");
1094                return RFAILED;
1095             }
1096             memset(*oldMacAmbrCfg, 0, sizeof(AmbrCfg));
1097             (*oldMacAmbrCfg)->ulBr = ueDbAmbr->ulBr;
1098          }
1099       }
1100    }
1101
1102    return ROK;
1103 }
1104
1105 /******************************************************************
1106  *
1107  * @brief Builds and Send UE ReConfig Request to MAC
1108  *
1109  * @details
1110  *
1111  *    Function : sendUeReCfgReqToMac
1112  *
1113  *    Functionality: Builds and Send UE ReConfig Request to MAC
1114  *
1115  * @Params[in]  MacUeCfg pointer
1116  * @return ROK     - success
1117  *         RFAILED - failure
1118  *
1119  * ****************************************************************/
1120
1121 uint8_t sendUeReCfgReqToMac(MacUeCfg *macUeCfg)
1122 {
1123    uint8_t ret = ROK;
1124    Pst pst;
1125
1126    /* Fill Pst */
1127    FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_UE_RECONFIG_REQ);
1128
1129    if(macUeCfg)
1130    {
1131       /* Processing one Ue at a time to MAC */
1132       DU_LOG("\nDEBUG   -->  DU_APP: Sending Ue Reconfig Request to MAC");
1133       ret = (*packMacUeReconfigReqOpts[pst.selector])(&pst, macUeCfg);
1134       if(ret == RFAILED)
1135       {
1136          DU_LOG("\nERROR  -->  DU APP : Failed to send Reconfig Request to MAC at sendUeReCfgReqToMac()");
1137          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, macUeCfg, sizeof(MacUeCfg));
1138       }
1139    }
1140    else
1141    {
1142       DU_LOG("\nERROR  -->  DU_APP: Received macUeCfg is NULLP at sendUeReCfgReqToMac()");
1143       ret = RFAILED;
1144    }
1145    return ret;
1146 }
1147
1148
1149
1150 /******************************************************************
1151  *
1152  * @brief Fills MacUeCfg structure
1153  *
1154  * @details
1155  *
1156  *    Function : fillMacUeCfg
1157  *
1158  *    Functionality: Fills MacUeCfg
1159  *
1160  * @params[in]  cellId, ueId, crnti,
1161  *              DuUeCfg  pointer,
1162  *              MacUeCfg pointer
1163  * @return ROK/RFAILED
1164  *
1165  *****************************************************************/
1166 uint8_t fillMacUeCfg(uint16_t cellId, uint8_t gnbDuUef1apId, uint16_t crnti, DuUeCfg *ueCfgDb, MacUeCfg *macUeCfg)
1167 {
1168    uint8_t ret = ROK, dbIdx = 0, lcIdx = 0, cellIdx = 0;
1169    bool lcIdFound = false;
1170    MacUeCfg *duMacDb = NULLP;
1171
1172    macUeCfg->cellId = cellId;
1173    macUeCfg->ueId = gnbDuUef1apId;
1174    macUeCfg->crnti = crnti;
1175
1176    if(!ueCfgDb)
1177    {
1178       fillDefaultMacCellGrpInfo(macUeCfg);
1179       fillDefaultPhyCellGrpInfo(macUeCfg);
1180
1181       if((fillDefaultSpCellGrpInfo(macUeCfg)) != ROK)
1182       {
1183          DU_LOG("\nERROR  --> DUAPP : Failed in fillDefaultSpCellGrpInfo");
1184          return RFAILED;
1185       }
1186
1187       macUeCfg->ambrCfg = NULLP;
1188       fillDefaultModulation(macUeCfg);
1189       fillMacSrb1LcCfg(&macUeCfg->lcCfgList[0]);
1190       macUeCfg->numLcs++;
1191    }
1192    else
1193    {
1194       if(ueCfgDb->dataTransmissionAction == STOP_TRANSMISSION)
1195       {
1196          macUeCfg->transmissionAction = ueCfgDb->dataTransmissionAction;
1197          return ROK;
1198       }
1199
1200       /* Fetching MacDb from DuUeCb.
1201        * In case of UE hand-in, UE context is created before RRC setup. Hence
1202        * crnti is not known yet. Thus, passing crnti=0 to this function.
1203        * In such a case actvCellLst doesnt yet have any entry for this UE. So
1204        * duMacDb will be NULL.
1205        */
1206
1207       if(crnti != 0)
1208       {
1209          GET_CELL_IDX(cellId, cellIdx);
1210          if(duCb.actvCellLst[cellIdx])
1211             duMacDb = &duCb.actvCellLst[cellIdx]->ueCb[macUeCfg->ueId-1].macUeCfg;
1212          else
1213          {
1214             DU_LOG("\nERROR  -->  DU APP : Cell Id [%d] does not exist", cellId);
1215             return RFAILED;
1216          }
1217          duMacDb->macUeCfgState = UE_CFG_INPROGRESS;
1218       }
1219
1220       if(ueCfgDb->cellGrpCfg)
1221       {
1222          ret = procUeReCfgCellInfo(macUeCfg, duMacDb, ueCfgDb->cellGrpCfg);
1223          if(ret == ROK)
1224          {
1225             if(macUeCfg->spCellCfgPres == true)
1226             {
1227                if(macUeCfg->spCellCfg.servCellCfg.initDlBwp.pdschPresent)
1228                {
1229                   fillStartSymbolAndLen(macUeCfg->spCellCfg.servCellCfg.initDlBwp.pdschCfg.numTimeDomRsrcAlloc,\
1230                         &macUeCfg->spCellCfg.servCellCfg.initDlBwp.pdschCfg, NULL);
1231                }
1232                if(macUeCfg->spCellCfg.servCellCfg.initUlBwp.puschPresent)
1233                {
1234                   fillStartSymbolAndLen(macUeCfg->spCellCfg.servCellCfg.initUlBwp.puschCfg.numTimeDomRsrcAlloc,\
1235                         NULL, &macUeCfg->spCellCfg.servCellCfg.initUlBwp.puschCfg);
1236                }
1237             }
1238
1239             if(duMacDb)
1240                ret = fillAmbr(&macUeCfg->ambrCfg, ueCfgDb->ambrCfg , &duMacDb->ambrCfg, FALSE);
1241             else
1242                ret = fillAmbr(&macUeCfg->ambrCfg, ueCfgDb->ambrCfg , NULL, FALSE);
1243
1244             duFillModulationDetails(macUeCfg, duMacDb, ueCfgDb->ueNrCapability);
1245          }
1246       }
1247       else
1248       {
1249          fillDefaultMacCellGrpInfo(macUeCfg);
1250          fillDefaultPhyCellGrpInfo(macUeCfg);
1251          fillDefaultSpCellGrpInfo(macUeCfg);
1252          fillDefaultModulation(macUeCfg);
1253       }
1254
1255       /* Filling LC Context */
1256       for(dbIdx = 0; (dbIdx < ueCfgDb->numMacLcs && ret == ROK); dbIdx++)
1257       {
1258          if(!ueCfgDb->macLcCfg[dbIdx].ulLcCfgPres)
1259          {
1260             /* Filling default UL LC config in MAC if not present */
1261             ueCfgDb->macLcCfg[dbIdx].ulLcCfgPres = true;
1262             fillDefaultUlLcCfg(&ueCfgDb->macLcCfg[dbIdx].ulLcCfg);
1263          }
1264
1265          if(duMacDb)
1266          {
1267             for(lcIdx = 0; lcIdx < duMacDb->numLcs; lcIdx++)
1268             {
1269                if(ueCfgDb->macLcCfg[dbIdx].lcId == duMacDb->lcCfgList[lcIdx].lcId)
1270                {
1271                   lcIdFound = true;
1272                   if((ueCfgDb->macLcCfg[dbIdx].configType == CONFIG_UNKNOWN) ||
1273                         (ueCfgDb->macLcCfg[dbIdx].configType == CONFIG_MOD))
1274                   {
1275                      ueCfgDb->macLcCfg[dbIdx].configType = CONFIG_MOD;
1276                      ret = fillMacLcCfgToAddMod(&macUeCfg->lcCfgList[dbIdx], &ueCfgDb->macLcCfg[dbIdx],\
1277                            &duMacDb->lcCfgList[lcIdx], FALSE);
1278                   }
1279                }
1280                else
1281                   lcIdFound = false;
1282             }
1283          }
1284
1285          if(!lcIdFound)
1286          {
1287             /* ADD/DEL CONFIG */
1288             ret = fillMacLcCfgToAddMod(&macUeCfg->lcCfgList[dbIdx], &ueCfgDb->macLcCfg[dbIdx], NULL, FALSE);
1289          }
1290          if(ret == ROK)
1291          {
1292             macUeCfg->numLcs++;
1293          }
1294          else
1295          {
1296             DU_LOG("\nERROR  -->  DU APP : Failed to add Lc at Idx %d in fillMacUeCfg()", dbIdx);
1297             break;
1298          }
1299       }/*End of Outer FOR loop */
1300       memcpy(&ueCfgDb->copyOfmacUeCfg, macUeCfg, sizeof(MacUeCfg));
1301    }
1302    return ret;
1303 }
1304
1305 /******************************************************************
1306  *
1307  * @brief Fills Rlc AM Information
1308  *
1309  * @details
1310  *
1311  *    Function : fillDefaultAmInfo
1312  *
1313  *    Functionality: Fills Rlc AM Information
1314  *
1315  * @params[in]  AmBearerCfg *amCfg
1316  * @return void
1317  *
1318  *****************************************************************/
1319 void fillDefaultAmInfo(AmBearerCfg *amCfg)
1320 {
1321    /* DL AM */
1322    amCfg->dlAmCfg.snLenDl     = AM_SIZE_12;
1323    amCfg->dlAmCfg.pollRetxTmr = T_POLL_RETRANSMIT_VAL;
1324    amCfg->dlAmCfg.pollPdu     = POLL_PDU_VAL;
1325    amCfg->dlAmCfg.pollByte    = POLL_BYTE_VAL;
1326    amCfg->dlAmCfg.maxRetxTh   = MAX_RETX_THRESHOLD_VAL;
1327
1328    /* UL AM */
1329    amCfg->ulAmCfg.snLenUl     = AM_SIZE_12;
1330    amCfg->ulAmCfg.reAssemTmr  = T_REASSEMBLY_VAL;
1331    amCfg->ulAmCfg.statProhTmr = T_STATUS_PROHIBHIT_VAL;
1332 }
1333
1334 /******************************************************************
1335  *
1336  * @brief Fills RLC UM Bi Directional Information
1337  *
1338  * @details
1339  *
1340  *    Function : fillDefaultUmBiInfo
1341  *
1342  *    Functionality: Fills RLC UM Bi Directional Information
1343  *
1344  * @params[in]  UmBiDirBearerCfg *umBiDirCfg
1345  * @return void
1346  *
1347  *****************************************************************/
1348 void fillDefaultUmBiInfo(UmBiDirBearerCfg *umBiDirCfg)
1349 {
1350    /* UL UM BI DIR INFO */
1351    umBiDirCfg->ulUmCfg.snLenUlUm = UM_SIZE_12;
1352    umBiDirCfg->ulUmCfg.reAssemTmr = T_REASSEMBLY_VAL;
1353
1354    /* DL UM BI DIR INFO */
1355    umBiDirCfg->dlUmCfg.snLenDlUm  = UM_SIZE_12;
1356 }
1357
1358 /******************************************************************
1359  *
1360  * @brief Fills RLC UM Uni Directional UL Information
1361  *
1362  * @details
1363  *
1364  *    Function : fillDefaultUmUlInfo
1365  *
1366  *    Functionality: Fills RLC UM Uni Directional Info
1367  *
1368  * @params[in]  UmUniDirUlBearerCfg *UmUlCfg
1369  * @return void
1370  *
1371  *****************************************************************/
1372 void fillDefaultUmUlInfo(UmUniDirUlBearerCfg *UmUlCfg)
1373 {
1374    UmUlCfg->ulUmCfg.snLenUlUm = UM_SIZE_12;
1375    UmUlCfg->ulUmCfg.reAssemTmr = T_REASSEMBLY_VAL;
1376 }
1377
1378 /******************************************************************
1379  *
1380  * @brief Fills RLC UM Uni Directional DL Information
1381  *
1382  * @details
1383  *
1384  *    Function : fillDefaultUmDlInfo
1385  *
1386  *    Functionality: Fills RLC UM Uni Directional DL Info
1387  *
1388  * @params[in]  UmUniDirDlBearerCfg *UmDlCfg
1389  * @return void
1390  *
1391  *****************************************************************/
1392 void fillDefaultUmDlInfo(UmUniDirDlBearerCfg *UmDlCfg)
1393 {
1394    UmDlCfg->dlUmCfg.snLenDlUm  = UM_SIZE_12;
1395 }
1396
1397 /******************************************************************
1398  *
1399  * @brief Builds Rlc Mode Default Configuration
1400  *
1401  * @details
1402  *
1403  *    Function : fillDefaultRlcModeCfg
1404  *
1405  *    Functionality: Builds Rlc Mode Default Configuration
1406  *
1407  * @params[in]  rlcMode, RlcBearerCfg *lcCfg
1408  * @return ROK/RFAILED
1409  *
1410  *****************************************************************/
1411
1412 uint8_t fillDefaultRlcModeCfg(uint8_t rlcMode, RlcBearerCfg *lcCfg)
1413 {
1414    if(lcCfg)
1415    {
1416       switch(rlcMode)
1417       {
1418          case RLC_AM :
1419             {
1420                if(!lcCfg->u.amCfg)
1421                {
1422                   DU_ALLOC_SHRABL_BUF(lcCfg->u.amCfg, sizeof(AmBearerCfg));
1423                   if(lcCfg->u.amCfg)
1424                      fillDefaultAmInfo(lcCfg->u.amCfg);
1425                   else
1426                   {
1427                      DU_LOG("\n ERROR  -->  DU APP : Memory Alloc failed at AmCfg at fillDefaultRlcModeCfg()");
1428                      return RFAILED;
1429                   }
1430                }
1431                break;
1432             }
1433          case RLC_UM_BI_DIRECTIONAL :
1434             {
1435                if(!lcCfg->u.umBiDirCfg)
1436                {
1437                   DU_ALLOC_SHRABL_BUF(lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
1438                   if(lcCfg->u.umBiDirCfg)
1439                      fillDefaultUmBiInfo(lcCfg->u.umBiDirCfg);
1440                   else
1441                   {
1442                      DU_LOG("\n ERROR  -->  DU APP : Memory Alloc failed at UmBiDirCfg at fillDefaultRlcModeCfg()");
1443                      return RFAILED;
1444                   }
1445                }
1446                break;
1447             }
1448          case RLC_UM_UNI_DIRECTIONAL_UL :
1449             {
1450                if(!lcCfg->u.umUniDirUlCfg)
1451                {
1452                   DU_ALLOC_SHRABL_BUF(lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
1453                   if(lcCfg->u.umUniDirUlCfg)
1454                      fillDefaultUmUlInfo(lcCfg->u.umUniDirUlCfg);
1455                   else
1456                   {
1457                      DU_LOG("\n ERROR  -->  DU APP : Memory Alloc failed at UmUniDirUlCfg at fillDefaultRlcModeCfg()");
1458                      return RFAILED;
1459                   }
1460                }
1461                break;
1462             }
1463          case RLC_UM_UNI_DIRECTIONAL_DL :
1464             {
1465                if(!lcCfg->u.umUniDirDlCfg)
1466                {
1467                   DU_ALLOC_SHRABL_BUF(lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
1468                   if(lcCfg->u.umUniDirDlCfg)
1469                      fillDefaultUmDlInfo(lcCfg->u.umUniDirDlCfg);
1470                   else
1471                   {
1472                      DU_LOG("\n ERROR  -->  DU APP : Memory Alloc failed at UmUniDirDlCfg at fillDefaultRlcModeCfg()");
1473                      return RFAILED;
1474                   }
1475                }
1476                break;
1477             }
1478          default:
1479             DU_LOG("\nERROR  -->  DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
1480             return RFAILED;
1481       }
1482
1483    }
1484    else
1485    {
1486       DU_LOG("\nERROR  -->  DUAPP: Received LC Config is NULL");
1487       return RFAILED;
1488    }
1489    return ROK;
1490 }
1491
1492 /*******************************************************************
1493  *
1494  * @brief Function to fill Rlc Lc Cfg for SRB1
1495  *
1496  * @details
1497  *
1498  *    Function : fillRlcSrb1LcCfg
1499  *
1500  *    Functionality:
1501  *     Function to fill Rlc Lc Cfg for SRB1
1502  *
1503  *  @params[in]     Pointer to RlcBearerCfg
1504  *  @return ROK/RFAILED
1505  *
1506  *****************************************************************/
1507
1508 uint8_t fillRlcSrb1LcCfg(RlcBearerCfg *rlcLcCfg)
1509 {
1510    uint8_t ret = ROK;
1511
1512    rlcLcCfg->rbId   = SRB1_LCID;
1513    rlcLcCfg->rbType = RB_TYPE_SRB;
1514    rlcLcCfg->lcId   = SRB1_LCID;
1515    rlcLcCfg->lcType = LCH_DCCH;
1516    rlcLcCfg->rlcMode = RLC_AM;
1517    rlcLcCfg->configType = CONFIG_ADD;
1518    ret = fillDefaultRlcModeCfg(rlcLcCfg->rlcMode, rlcLcCfg);
1519    rlcLcCfg->isLcAddModRspSent = true;
1520    return ret;
1521 }
1522
1523 /*******************************************************************
1524  *
1525  * @brief Processes UE ReConfig Req to RLC UL
1526  *
1527  * @details
1528  *
1529  *    Function : sendUeReCfgReqToRlc
1530  *
1531  *    Functionality:
1532  *     Processes UE Reconfig Req to RLC UL
1533  *
1534  *  @params[in]     Pointer to RlcUeCfg
1535  *  @return ROK     - success
1536  *          RFAILED - failure
1537  *
1538  *****************************************************************/
1539
1540 uint8_t sendUeReCfgReqToRlc(RlcUeCfg *rlcUeCfg)
1541 {
1542    uint8_t ret;
1543    Pst pst;
1544
1545    FILL_PST_DUAPP_TO_RLC(pst, RLC_UL_INST, EVENT_RLC_UE_RECONFIG_REQ);
1546    if(rlcUeCfg)
1547    {
1548       /* Processing one Ue at a time to RLC */
1549       DU_LOG("\nDEBUG   -->  DU_APP: Sending Ue Reconfig Request to RLC UL");
1550       ret = (*packRlcUeReconfigReqOpts[pst.selector])(&pst, rlcUeCfg);
1551       if(ret == RFAILED)
1552       {
1553          DU_LOG("\nERROR  -->  DU_APP : Failed to send Ue Reconfig Req to RLC at sendUeReCfgReqToRlc()");
1554          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, rlcUeCfg, sizeof(RlcUeCfg));
1555       }
1556    }
1557    else
1558    {
1559       DU_LOG("\nERROR  -->   DU_APP: Received RlcUeCfg is NULL at sendUeReCfgReqToRlc()");
1560       ret = RFAILED;
1561    }
1562    return ret;
1563 }
1564
1565 /******************************************************************
1566  *
1567  * @brief Fills Snssai information
1568  *
1569  * @details
1570  *
1571  *    Function : fillSnssaiInfo
1572  *
1573  *    Functionality: Fills Snssai information
1574  *
1575  *  @params[in]    LcCfg *snssaiTobeSend, LcCfg *snssaiDb, LcCfg *oldSnssai,
1576  *  Bool toUpdateg
1577  *  @return ROK     - success
1578  *          RFAILED - failure
1579  *
1580  *****************************************************************/
1581 uint8_t fillSnssaiInfo(Snssai *snssaiTobeSend, Snssai *snssaiDb, Snssai **oldSnssai, Bool toUpdate)
1582 {
1583    if(!toUpdate)
1584    {
1585       if(snssaiDb)
1586          snssaiTobeSend = snssaiDb;
1587       else if(oldSnssai)
1588          snssaiTobeSend = *oldSnssai;
1589       else
1590          snssaiTobeSend = NULL;
1591    }
1592    else
1593    {
1594       if(snssaiDb)
1595       {
1596          if(*oldSnssai)
1597             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, *oldSnssai, sizeof(Snssai));
1598
1599          DU_ALLOC_SHRABL_BUF(*oldSnssai, sizeof(Snssai));
1600          if(*oldSnssai == NULL)
1601          {
1602             DU_LOG("\nERROR  -->  DU APP : Memory Alloc Failed at fillSnssaiInfo()");
1603             return RFAILED;
1604          }
1605          memcpy(*oldSnssai, snssaiDb, sizeof(Snssai));
1606       }
1607    }
1608    return ROK;
1609 }
1610 /******************************************************************
1611  *
1612  * @brief Fills RlcBearerCfg structure
1613  *
1614  * @details
1615  *
1616  *    Function : fillRlcUeCfg
1617  *
1618  *    Functionality: Fills Rlc Bearer Cfg
1619  *
1620  *
1621  *****************************************************************/
1622 uint8_t fillRlcUeCfg(uint16_t cellId, uint8_t ueId, DuUeCfg *ueCfgDb, RlcUeCfg *rlcUeCfg)
1623 {
1624    uint8_t ret, dbIdx, lcIdx, cellIdx;
1625    bool lcIdFound = false;
1626    RlcUeCfg *duRlcDb = NULLP;
1627
1628    ret = ROK;
1629    if(!ueCfgDb)
1630    {
1631       /* Initial RB being Added */
1632       rlcUeCfg->cellId       = cellId;
1633       rlcUeCfg->ueId         = ueId;
1634       ret = fillRlcSrb1LcCfg(&rlcUeCfg->rlcLcCfg[0]);
1635       if(ret == ROK)
1636          rlcUeCfg->numLcs++;
1637       else
1638          memset(rlcUeCfg, 0, sizeof(RlcUeCfg));
1639    }
1640    else
1641    {
1642       /* Fetch RlcDb from DuUeCb */
1643       GET_CELL_IDX(cellId, cellIdx);
1644       duRlcDb = &duCb.actvCellLst[cellIdx]->ueCb[ueId-1].rlcUeCfg;
1645       duRlcDb->rlcUeCfgState = UE_CFG_INPROGRESS;
1646       /*Filling RlcUeCfg */
1647       rlcUeCfg->cellId       = cellId;
1648       rlcUeCfg->ueId         = ueId;
1649
1650       for(dbIdx = 0; (dbIdx < ueCfgDb->numRlcLcs && ret == ROK); dbIdx++)
1651       {
1652          ret = fillDefaultRlcModeCfg(ueCfgDb->rlcLcCfg[dbIdx].rlcMode, &ueCfgDb->rlcLcCfg[dbIdx]);
1653          if(ret == RFAILED)
1654          {
1655             DU_LOG("\n ERROR  -->  DU APP : Failed to fill Rlc Mode at fillRlcUeCfg()");
1656             memset(rlcUeCfg, 0, sizeof(RlcUeCfg));
1657             return ret;
1658          }
1659          /* Fill Rlc Ue Cfg List for ADD/MOD/DEL */
1660          for(lcIdx = 0; lcIdx < duRlcDb->numLcs; lcIdx++)
1661          {
1662             if(ueCfgDb->rlcLcCfg[dbIdx].lcId == duRlcDb->rlcLcCfg[lcIdx].lcId)
1663             {
1664                lcIdFound = true;
1665                if((ueCfgDb->rlcLcCfg[dbIdx].configType == CONFIG_UNKNOWN)||
1666                      (ueCfgDb->rlcLcCfg[dbIdx].configType == CONFIG_MOD))
1667                {
1668                   /* MOD */
1669                   ueCfgDb->rlcLcCfg[dbIdx].configType = CONFIG_MOD; /* update Db for MOD type */
1670                   memcpy(&rlcUeCfg->rlcLcCfg[dbIdx], &ueCfgDb->rlcLcCfg[dbIdx], sizeof(RlcBearerCfg));
1671                   fillSnssaiInfo(rlcUeCfg->rlcLcCfg[dbIdx].snssai, ueCfgDb->rlcLcCfg[dbIdx].snssai,\
1672                   &duRlcDb->rlcLcCfg[lcIdx].snssai,false);
1673                }
1674             }
1675             else
1676                lcIdFound = false;
1677          }
1678          if(!lcIdFound)
1679          {
1680             /* ADD/ DEL Config Type */
1681             memcpy(&rlcUeCfg->rlcLcCfg[dbIdx], &ueCfgDb->rlcLcCfg[dbIdx], sizeof(RlcBearerCfg));
1682             fillSnssaiInfo(rlcUeCfg->rlcLcCfg[dbIdx].snssai, ueCfgDb->rlcLcCfg[dbIdx].snssai, NULL, false);
1683          }
1684          rlcUeCfg->numLcs++;
1685       }
1686    }
1687    return ret;
1688 }
1689
1690 /******************************************************************
1691  *
1692  * @brief creates UE context
1693  *
1694  * @details
1695  *
1696  *    Function : duCreateUeCb
1697  *
1698  *    Functionality: Creates UE Conetxt
1699  *
1700  * @params[in] UeCcchCtxt Pointer
1701  *             UeIdx Pointer
1702  *
1703  * @return ROK     - success
1704  *         RFAILED - failure
1705  * ****************************************************************/
1706 uint8_t duCreateUeCb(UeCcchCtxt *ueCcchCtxt, uint32_t gnbCuUeF1apId)
1707 {
1708    uint8_t cellIdx = 0;
1709    uint8_t ret     = ROK;
1710    uint8_t ueId = 0, ueIdx = 0;
1711
1712    for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
1713    {
1714       if(duCb.actvCellLst[cellIdx] && (ueCcchCtxt->cellId == duCb.actvCellLst[cellIdx]->cellId))
1715       {
1716          GET_UE_ID(ueCcchCtxt->crnti, ueId);
1717          DU_LOG("\nDEBUG   -->  DU_APP: Filling UeCb for ueId [%d]", ueId);
1718
1719          ueIdx = ueId-1;
1720          duCb.actvCellLst[cellIdx]->ueCb[ueIdx].f1UeDb        = NULLP;
1721          duCb.actvCellLst[cellIdx]->ueCb[ueIdx].crnti         = ueCcchCtxt->crnti;
1722          duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId = ueCcchCtxt->gnbDuUeF1apId;
1723          duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId = gnbCuUeF1apId;
1724          duCb.actvCellLst[cellIdx]->ueCb[ueIdx].drbBitMap     = NULLP;
1725          duCb.actvCellLst[cellIdx]->ueCb[ueIdx].ueState       = UE_ACTIVE;
1726
1727          /* Filling Mac Ue Config */
1728          memset(&duCb.actvCellLst[cellIdx]->ueCb[ueIdx].macUeCfg, 0, sizeof(MacUeCfg));
1729          ret = duBuildAndSendUeCreateReqToMac(ueCcchCtxt->cellId, ueCcchCtxt->gnbDuUeF1apId, ueCcchCtxt->crnti, NULL,
1730                &duCb.actvCellLst[cellIdx]->ueCb[ueIdx].macUeCfg);
1731          if(ret == RFAILED)
1732             DU_LOG("\nERROR  -->  DU APP : Failed to send UE create request to MAC");
1733
1734          /* Filling Rlc Ue Config */
1735          memset(&duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg, 0, sizeof(RlcUeCfg));
1736          ret = duBuildAndSendUeCreateReqToRlc(ueCcchCtxt->cellId, ueId, \
1737                &duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg);
1738          if(ret == RFAILED)
1739             DU_LOG("\nERROR  -->  DU APP : Failed to send UE create request to RLC");
1740
1741          duCb.actvCellLst[cellIdx]->numActvUes++;
1742          memset(ueCcchCtxt, 0, sizeof(UeCcchCtxt));
1743          duCb.numUe--;
1744       }
1745    }
1746    return ret;
1747 }
1748
1749 /******************************************************************
1750  *
1751  * @brief Builds and Send UE Create Request to MAC
1752  *
1753  * @details
1754  *
1755  *    Function : duBuildAndSendUeCreateReqToMac
1756  *
1757  *    Functionality: Builds and Send UE Create Request to MAC
1758  *
1759  * @Params[in]  cellId,
1760  *              ueId,
1761  *              crnti,
1762  *              UE config extracted from F1AP msg
1763  *              MAC UE config struct to be filled
1764  * @return ROK     - success
1765  *         RFAILED - failure
1766  *
1767  * ****************************************************************/
1768
1769 uint8_t duBuildAndSendUeCreateReqToMac(uint16_t cellId, uint8_t gnbDuUeF1apId, uint16_t crnti, DuUeCfg *ueCfgDb, MacUeCfg *duMacUeCfg)
1770 {
1771    uint8_t  ret = ROK;
1772    MacUeCfg *macUeCfg = NULLP;
1773    Pst       pst;
1774    memset(&pst, 0, sizeof(Pst));
1775
1776
1777    ret = fillMacUeCfg(cellId, gnbDuUeF1apId, crnti, ueCfgDb, duMacUeCfg);
1778    if(ret == RFAILED)
1779    {
1780       DU_LOG("\nERROR  -->  DU APP : Failed to fill MacUeCfg at duBuildAndSendUeCreateReqToMac()");
1781       return RFAILED;
1782    }
1783
1784    /* Fill Pst */
1785    FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_UE_CREATE_REQ);
1786
1787    /* Copying ueCb to a sharable buffer */
1788    DU_ALLOC_SHRABL_BUF(macUeCfg, sizeof(MacUeCfg));
1789    if(macUeCfg)
1790    {
1791       memset(macUeCfg, 0, sizeof(MacUeCfg));
1792       memcpy(macUeCfg, duMacUeCfg, sizeof(MacUeCfg));
1793       DU_LOG("\nDEBUG   -->  DU_APP: Sending UE create request to MAC");
1794
1795       /* Processing one Ue at a time to MAC */
1796       ret = (*packMacUeCreateReqOpts[pst.selector])(&pst, macUeCfg);
1797       if(ret == RFAILED)
1798       {
1799          DU_LOG("\nERROR  -->  DU_APP : Failure in sending Ue Create Req to MAC at duBuildAndSendUeCreateReqToMac()");
1800          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, macUeCfg, sizeof(MacUeCfg));
1801       }
1802    }
1803    else
1804    {
1805       DU_LOG("\n ERROR  -->  DU APP : Memory alloc failed at duBuildAndSendUeCreateReqToMac()");
1806       ret = RFAILED;
1807    }
1808    return ret;
1809 }
1810
1811 /*******************************************************************
1812  *
1813  * @brief To update DuUeCb Mac Cfg
1814  *
1815  * @details
1816  *
1817  *    Function : duUpdateMacCfg
1818  *    Functionality:  update DuUeCb MAC Cfg
1819  *
1820  * @params[in] DuUeCb Pointer
1821  *             F1UeContextSetupDb pointer
1822  * @return ROK     - success
1823  *         RFAILED - failure
1824  *
1825  * ****************************************************************/
1826 uint8_t duUpdateMacCfg(MacUeCfg *macUeCfg, F1UeContextSetupDb *f1UeDb)
1827 {
1828    uint8_t ret, lcIdx, dbIdx, numLcs, lcDelIdx, cellIdx;
1829    MacUeCfg *oldMacUeCfg;
1830    ret = ROK;
1831
1832    GET_CELL_IDX(macUeCfg->cellId, cellIdx);
1833    if(duCb.actvCellLst[cellIdx] == NULLP)
1834    {
1835       DU_LOG("\nERROR  --> DU APP: CellId[%d] not found", macUeCfg->cellId);
1836       return RFAILED;
1837    }
1838    oldMacUeCfg = &duCb.actvCellLst[cellIdx]->ueCb[macUeCfg->ueId-1].macUeCfg;
1839
1840    /*Filling Cell Group Cfg*/
1841    ret =  procUeReCfgCellInfo(macUeCfg, &f1UeDb->duUeCfg.copyOfmacUeCfg, f1UeDb->duUeCfg.cellGrpCfg);
1842    if(ret == ROK)
1843    {
1844       if(macUeCfg->spCellCfg.servCellCfg.initDlBwp.pdschPresent)
1845       {
1846          fillStartSymbolAndLen(macUeCfg->spCellCfg.servCellCfg.initDlBwp.pdschCfg.numTimeDomRsrcAlloc,\
1847                &macUeCfg->spCellCfg.servCellCfg.initDlBwp.pdschCfg, NULL);
1848       }
1849       if(macUeCfg->spCellCfg.servCellCfg.initUlBwp.puschPresent)
1850       {
1851          fillStartSymbolAndLen(macUeCfg->spCellCfg.servCellCfg.initUlBwp.puschCfg.numTimeDomRsrcAlloc,\
1852                NULL, &macUeCfg->spCellCfg.servCellCfg.initUlBwp.puschCfg);
1853       }
1854       ret = fillAmbr(NULL, f1UeDb->duUeCfg.ambrCfg, &oldMacUeCfg->ambrCfg, true);
1855       duFillModulationDetails(macUeCfg, oldMacUeCfg, f1UeDb->duUeCfg.ueNrCapability);
1856    }
1857
1858    /* Filling LC Context */
1859    for(dbIdx = 0; (dbIdx < f1UeDb->duUeCfg.numMacLcs && ret == ROK); dbIdx++)
1860    {
1861       numLcs = macUeCfg->numLcs;
1862       for(lcIdx = 0; lcIdx < numLcs; lcIdx++)
1863       {
1864          if(f1UeDb->duUeCfg.macLcCfg[dbIdx].lcId ==  macUeCfg->lcCfgList[lcIdx].lcId)
1865          {
1866             if(f1UeDb->duUeCfg.macLcCfg[dbIdx].configType == CONFIG_MOD)
1867             {
1868                ret = fillMacLcCfgToAddMod(NULL, &f1UeDb->duUeCfg.macLcCfg[dbIdx], &macUeCfg->lcCfgList[lcIdx], true);
1869             }
1870             else if(f1UeDb->duUeCfg.macLcCfg[dbIdx].configType == CONFIG_DEL)
1871             {
1872                /* Free memory at matched  lcIdx index */
1873                freeMacLcCfg(&macUeCfg->lcCfgList[lcIdx]);
1874                macUeCfg->numLcs--;
1875                for(lcDelIdx = lcIdx; lcDelIdx < macUeCfg->numLcs; lcDelIdx++)
1876                {
1877                   /* moving all elements one index ahead */
1878                   ret = fillMacLcCfgToAddMod(NULL,  &macUeCfg->lcCfgList[lcDelIdx+1], &macUeCfg->lcCfgList[lcDelIdx], true);
1879                   freeMacLcCfg(&macUeCfg->lcCfgList[lcDelIdx+1]);
1880                   if(ret == RFAILED)
1881                   {
1882                      DU_LOG("\nERROR  -->  DU APP : Failed to delete LC at Idx %d in duUpdateMacCfg()", lcDelIdx);
1883                      break;
1884                   }
1885                }
1886             }
1887          }
1888       }
1889       if(f1UeDb->duUeCfg.macLcCfg[dbIdx].configType == CONFIG_ADD)
1890       {
1891          ret = fillMacLcCfgToAddMod(NULL, &f1UeDb->duUeCfg.macLcCfg[dbIdx], &macUeCfg->lcCfgList[numLcs], true);
1892          if(ret == RFAILED)
1893          {
1894             DU_LOG("\nERROR  -->  DU APP : Failed to add LC at Idx %d in duUpdateMacCfg()", numLcs);
1895             break;
1896          }
1897          macUeCfg->numLcs++;
1898       }
1899
1900    }
1901    return ret;
1902 }
1903
1904 /******************************************************************
1905  *
1906  * @brief Function to fill the RLC Lc cfg from ueSetupReqDb
1907  *
1908  * @details
1909  *
1910  *    Function : fillRlcCfgToAddMod
1911  *
1912  *    Functionality: Function to fill the RLC Lc cfg from ueSetupReqDb
1913  *
1914  *
1915  *****************************************************************/
1916
1917 uint8_t fillRlcCfgToAddMod(RlcBearerCfg *lcCfg, RlcBearerCfg *f1UeDbLcCfg)
1918 {
1919    lcCfg->configType = f1UeDbLcCfg->configType;
1920    lcCfg->rbId       = f1UeDbLcCfg->rbId;
1921    lcCfg->rbType     = f1UeDbLcCfg->rbType;
1922    lcCfg->lcId       = f1UeDbLcCfg->lcId;
1923    lcCfg->lcType     = f1UeDbLcCfg->lcType;
1924    lcCfg->rlcMode    = f1UeDbLcCfg->rlcMode;
1925
1926    switch(lcCfg->rlcMode)
1927    {
1928       case RLC_AM :
1929          {
1930             if(!lcCfg->u.amCfg)
1931             {
1932                DU_ALLOC_SHRABL_BUF(lcCfg->u.amCfg, sizeof(AmBearerCfg));
1933                if(!lcCfg->u.amCfg)
1934                   return RFAILED;
1935             }
1936             /* DL AM */
1937             lcCfg->u.amCfg->dlAmCfg.snLenDl     = f1UeDbLcCfg->u.amCfg->dlAmCfg.snLenDl;
1938             lcCfg->u.amCfg->dlAmCfg.pollRetxTmr = f1UeDbLcCfg->u.amCfg->dlAmCfg.pollRetxTmr;
1939             lcCfg->u.amCfg->dlAmCfg.pollPdu     = f1UeDbLcCfg->u.amCfg->dlAmCfg.pollPdu;
1940             lcCfg->u.amCfg->dlAmCfg.pollByte    = f1UeDbLcCfg->u.amCfg->dlAmCfg.pollByte;
1941             lcCfg->u.amCfg->dlAmCfg.maxRetxTh   = f1UeDbLcCfg->u.amCfg->dlAmCfg.maxRetxTh;
1942
1943             /* UL AM */
1944             lcCfg->u.amCfg->ulAmCfg.snLenUl     = f1UeDbLcCfg->u.amCfg->ulAmCfg.snLenUl;
1945             lcCfg->u.amCfg->ulAmCfg.reAssemTmr  = f1UeDbLcCfg->u.amCfg->ulAmCfg.reAssemTmr;
1946             lcCfg->u.amCfg->ulAmCfg.statProhTmr = f1UeDbLcCfg->u.amCfg->ulAmCfg.statProhTmr;
1947             break;
1948          }
1949       case RLC_UM_BI_DIRECTIONAL :
1950          {
1951             if(!lcCfg->u.umBiDirCfg)
1952             {
1953                DU_ALLOC_SHRABL_BUF(lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
1954                if(!lcCfg->u.umBiDirCfg)
1955                   return RFAILED;
1956             }
1957             /* UL UM BI DIR INFO */
1958             lcCfg->u.umBiDirCfg->ulUmCfg.snLenUlUm  = f1UeDbLcCfg->u.umBiDirCfg->ulUmCfg.snLenUlUm;
1959             lcCfg->u.umBiDirCfg->ulUmCfg.reAssemTmr = f1UeDbLcCfg->u.umBiDirCfg->ulUmCfg.reAssemTmr;
1960             /* DL UM BI DIR INFO */
1961             lcCfg->u.umBiDirCfg->dlUmCfg.snLenDlUm  = f1UeDbLcCfg->u.umBiDirCfg->dlUmCfg.snLenDlUm;
1962             break;
1963          }
1964       case RLC_UM_UNI_DIRECTIONAL_UL :
1965          {
1966             if(!lcCfg->u.umUniDirUlCfg)
1967             {
1968                DU_ALLOC_SHRABL_BUF(lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
1969                if(!lcCfg->u.umUniDirUlCfg)
1970                   return RFAILED;
1971             }
1972             lcCfg->u.umUniDirUlCfg->ulUmCfg.snLenUlUm  = f1UeDbLcCfg->u.umUniDirUlCfg->ulUmCfg.snLenUlUm;
1973             lcCfg->u.umUniDirUlCfg->ulUmCfg.reAssemTmr = f1UeDbLcCfg->u.umUniDirUlCfg->ulUmCfg.reAssemTmr;
1974             break;
1975
1976          }
1977       case RLC_UM_UNI_DIRECTIONAL_DL :
1978          {
1979             if(!lcCfg->u.umUniDirDlCfg)
1980             {
1981                DU_ALLOC_SHRABL_BUF(lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
1982                if(!lcCfg->u.umUniDirDlCfg)
1983                   return RFAILED;
1984             }
1985             lcCfg->u.umUniDirDlCfg->dlUmCfg.snLenDlUm  = f1UeDbLcCfg->u.umUniDirDlCfg->dlUmCfg.snLenDlUm;
1986             break;
1987          }
1988       default:
1989          DU_LOG("\nERROR  -->  DU_APP: Invalid Rlc Mode %d at fillRlcCfgToAddMod()", lcCfg->rlcMode);
1990          return RFAILED;
1991    }
1992    return ROK;
1993 }
1994
1995 /*******************************************************************
1996  *
1997  * @brief To update DuUeCb Rlc Lc Cfg
1998  *
1999  * @details
2000  *
2001  *    Function : duUpdateRlcLcCfg
2002  *    Functionality:  update DuUeCb Rlc Lc Cfg
2003  *
2004  * @params[in] DuUeCb Pointer
2005  *             F1UeContextSetupDb pointer
2006  * @return ROK     - success
2007  *         RFAILED - failure
2008  *
2009  * ****************************************************************/
2010
2011 uint8_t duUpdateRlcLcCfg(RlcUeCfg *rlcUeCfg, F1UeContextSetupDb *f1UeDb)
2012 {
2013    uint8_t ret, lcIdx, dbIdx, numLcs, lcDelIdx;
2014
2015    ret = ROK;
2016    for(dbIdx = 0; (dbIdx < f1UeDb->duUeCfg.numRlcLcs && ret ==ROK); dbIdx++)
2017    {
2018       numLcs = rlcUeCfg->numLcs;
2019       for(lcIdx = 0; lcIdx < numLcs; lcIdx++)
2020       {
2021          if(f1UeDb->duUeCfg.rlcLcCfg[dbIdx].lcId == rlcUeCfg->rlcLcCfg[lcIdx].lcId)
2022          {
2023             if(f1UeDb->duUeCfg.rlcLcCfg[dbIdx].configType == CONFIG_MOD)
2024             {
2025                ret = fillRlcCfgToAddMod(&rlcUeCfg->rlcLcCfg[lcIdx], &f1UeDb->duUeCfg.rlcLcCfg[dbIdx]);
2026                if(ret == RFAILED)
2027                {
2028                   DU_LOG("\nERROR  -->  DU APP : Failed to modify LC at Idx %d in duUpdateRlcCfg()", lcDelIdx);
2029                   break;
2030                }
2031                fillSnssaiInfo(NULL, f1UeDb->duUeCfg.rlcLcCfg[dbIdx].snssai, &rlcUeCfg->rlcLcCfg[lcIdx].snssai, true);
2032             }
2033             else if(f1UeDb->duUeCfg.rlcLcCfg[dbIdx].configType == CONFIG_DEL)
2034             {
2035                /* Free memory at matched lcIdx index */
2036                freeRlcLcCfg(&rlcUeCfg->rlcLcCfg[lcIdx]);
2037                rlcUeCfg->numLcs--;
2038                for(lcDelIdx = lcIdx; lcDelIdx < rlcUeCfg->numLcs; lcDelIdx++)
2039                {
2040                   ret = fillRlcCfgToAddMod(&rlcUeCfg->rlcLcCfg[lcDelIdx], &rlcUeCfg->rlcLcCfg[lcDelIdx+1]);
2041                   fillSnssaiInfo(NULL, rlcUeCfg->rlcLcCfg[lcDelIdx+1].snssai, &rlcUeCfg->rlcLcCfg[lcDelIdx].snssai,\
2042                   true);
2043                   freeRlcLcCfg(&rlcUeCfg->rlcLcCfg[lcDelIdx+1]);
2044                   if(ret == RFAILED)
2045                   {
2046                      DU_LOG("\nERROR  -->  DU APP : Failed to delete LC at Idx %d in duUpdateRlcCfg()", lcDelIdx);
2047                      break;
2048                   }
2049                }
2050             }
2051          }
2052       }
2053       if(f1UeDb->duUeCfg.rlcLcCfg[dbIdx].configType == CONFIG_ADD)
2054       {
2055          ret = fillRlcCfgToAddMod(&rlcUeCfg->rlcLcCfg[lcIdx], &f1UeDb->duUeCfg.rlcLcCfg[dbIdx]);
2056          if(ret == ROK)
2057          {
2058             fillSnssaiInfo(NULL, f1UeDb->duUeCfg.rlcLcCfg[dbIdx].snssai, &rlcUeCfg->rlcLcCfg[ rlcUeCfg->numLcs].snssai,\
2059                   true);
2060             rlcUeCfg->numLcs++;
2061          }
2062       }
2063    }
2064    return ret;
2065 }
2066
2067 /*******************************************************************
2068  *
2069  * @brief Function to fill Tunnel Config to Add/Mod
2070  *
2071  *
2072  * @details
2073  *
2074  *    Function : fillTnlCfgToAddMod
2075  *
2076  *    Functionality: Function to fill tunnel Config to Add/Mod
2077  *
2078  * @params[in] Pointer to tnlCfgDb,
2079  *             pointer to f1TnlCfg
2080  * @return ROK     - success
2081  *         RFAILED - failure
2082  *
2083  * ****************************************************************/
2084 uint8_t fillTnlCfgToAddMod(UpTnlCfg **ueCbTnlCfg, UpTnlCfg *f1TnlCfg)
2085 {
2086    if(*ueCbTnlCfg)
2087    {
2088       DU_FREE((*ueCbTnlCfg)->tnlCfg1, sizeof(GtpTnlCfg));
2089       DU_FREE(*ueCbTnlCfg, sizeof(UpTnlCfg));
2090    }
2091
2092    if(*ueCbTnlCfg == NULLP)
2093    {
2094       /* copying to DuCb Tnl Cfg */
2095       DU_ALLOC(*ueCbTnlCfg, sizeof(UpTnlCfg));
2096       if(*ueCbTnlCfg == NULLP)
2097       {
2098          DU_LOG("\nERROR  -->  DU_APP : fillTnlCfgToAddMod: Memory Alloc failed for drbId[%d]", f1TnlCfg->drbId);
2099          return RFAILED;
2100       }
2101    }
2102    memset(*ueCbTnlCfg, 0, sizeof(UpTnlCfg));
2103    (*ueCbTnlCfg)->configType = f1TnlCfg->configType;
2104    (*ueCbTnlCfg)->cellId    = f1TnlCfg->cellId;
2105    (*ueCbTnlCfg)->ueId      = f1TnlCfg->ueId;
2106    (*ueCbTnlCfg)->drbId     = f1TnlCfg->drbId;
2107    if(f1TnlCfg->tnlCfg1)
2108    {
2109       if((*ueCbTnlCfg)->tnlCfg1 == NULLP)
2110       {
2111          DU_ALLOC((*ueCbTnlCfg)->tnlCfg1, sizeof(GtpTnlCfg));
2112          if((*ueCbTnlCfg)->tnlCfg1 == NULLP)
2113          {
2114             DU_LOG("\nERROR  -->  DU_APP : fillTnlCfgToAddMod: Memory Alloc failed for tnlCfg1 for drbId[%d]", f1TnlCfg->drbId);
2115             return RFAILED;
2116          }
2117       }
2118       memset((*ueCbTnlCfg)->tnlCfg1, 0, sizeof(GtpTnlCfg));
2119       (*ueCbTnlCfg)->tnlCfg1->teId = f1TnlCfg->tnlCfg1->teId;
2120       (*ueCbTnlCfg)->tnlCfg1->ulTnlAddress = f1TnlCfg->tnlCfg1->ulTnlAddress;
2121       (*ueCbTnlCfg)->tnlCfg1->dlTnlAddress = f1TnlCfg->tnlCfg1->dlTnlAddress;
2122    }
2123    return ROK;
2124 }
2125
2126 /*******************************************************************
2127  *
2128  * @brief Processing the tunnel Request to EGTP
2129  *
2130  * @details
2131  *
2132  *    Function : duProcEgtpTunnelCfg
2133  *
2134  *    Functionality: Processing the tunnel Request to EGTP
2135  *
2136  * @params[in] UptnlCfg *duTnlCfg, UpTnlCfg *f1TnlCfg
2137  * @return ROK     - success
2138  *         RFAILED - failure
2139  *
2140  * ****************************************************************/
2141
2142 uint8_t duProcEgtpTunnelCfg(uint8_t ueCbIdx, UpTnlCfg *duTnlCfg, UpTnlCfg *f1TnlCfg)
2143 {
2144    uint8_t ret = RFAILED, delIdx;
2145
2146    if(f1TnlCfg->tnlCfg1 == NULLP)
2147    {
2148       DU_LOG("\nERROR  -->  DU_APP : Tunnel config not found");
2149       return ret;
2150    }
2151
2152    if(f1TnlCfg->configType == CONFIG_ADD)
2153    {
2154       if(duSendEgtpTnlMgmtReq(EGTP_TNL_MGMT_ADD, NULLP, f1TnlCfg->tnlCfg1) == ROK)
2155       {
2156          if(fillTnlCfgToAddMod(&duCb.upTnlCfg[duCb.numTeId], f1TnlCfg) == ROK)
2157          {
2158             duCb.numTeId++;
2159             ret = ROK;
2160          }
2161       }
2162    }
2163    else if(f1TnlCfg->configType == CONFIG_MOD)
2164    {
2165       if(duSendEgtpTnlMgmtReq(EGTP_TNL_MGMT_MOD, duTnlCfg->tnlCfg1->teId, f1TnlCfg->tnlCfg1) == ROK)
2166       {
2167          if(fillTnlCfgToAddMod(&duTnlCfg, f1TnlCfg) == ROK)
2168          {
2169             ret = ROK;
2170          }
2171       }
2172    }
2173    else if(f1TnlCfg->configType == CONFIG_DEL)
2174    {
2175       if(duSendEgtpTnlMgmtReq(EGTP_TNL_MGMT_DEL, duTnlCfg->tnlCfg1->teId, f1TnlCfg->tnlCfg1) == ROK)
2176       {
2177          /* Free memory at drbIdx */
2178          duCb.numTeId--;
2179          for(delIdx = ueCbIdx; delIdx < duCb.numTeId; delIdx++)
2180          {
2181             /* moving all elements one index ahead */
2182             ret = fillTnlCfgToAddMod(&duCb.upTnlCfg[delIdx], duCb.upTnlCfg[delIdx+1]);
2183             if(ret != ROK)
2184             {
2185                return ret;
2186             }
2187          }
2188          if(duCb.upTnlCfg[delIdx])
2189          {
2190             DU_FREE(duCb.upTnlCfg[delIdx]->tnlCfg1, sizeof(GtpTnlCfg));
2191             DU_FREE(duCb.upTnlCfg[delIdx], sizeof(UpTnlCfg));
2192          }
2193       }
2194    }
2195    return ret;
2196 }
2197
2198 /***********************************************************************
2199  *
2200  * @brief Function to fill Tunnel Config
2201  *        and sends tunnel Req to EGTP
2202  *
2203  *
2204  * @details
2205  *
2206  *    Function : duUpdateTunnelCfgDb
2207  *
2208  *    Functionality: Function to fill tunnel Config
2209  *                   and sends tunnel Cfg Req to EGTP
2210  *
2211  * @params[in] ueId, cellId, DuUeCfg
2212  * @return ROK     - success
2213  *         RFAILED - failure
2214  *
2215  * ****************************************************************/
2216
2217 uint8_t duUpdateTunnelCfgDb(uint8_t ueId, uint8_t cellId, DuUeCfg *duUeCfg)
2218 {
2219    uint8_t ret = ROK, drbIdx, teIdx;
2220    bool drbFound = false;
2221
2222    /*If Add/Mod tunnels request for that DRB is successful in EGTP */
2223    /*then update drbId and tunnel Info in duCb */
2224    for(drbIdx=0; drbIdx < duUeCfg->numDrb; drbIdx++)
2225    {
2226       duUeCfg->upTnlInfo[drbIdx].cellId = cellId;
2227       duUeCfg->upTnlInfo[drbIdx].ueId = ueId;
2228       for(teIdx = 0; teIdx < duCb.numTeId; teIdx++)
2229       {
2230          if((duCb.upTnlCfg[teIdx]->ueId == duUeCfg->upTnlInfo[drbIdx].ueId) && \
2231             (duCb.upTnlCfg[teIdx]->drbId == duUeCfg->upTnlInfo[drbIdx].drbId))
2232          {
2233             drbFound = true; /* existing DRB */
2234             if(duProcEgtpTunnelCfg(teIdx, duCb.upTnlCfg[teIdx], &duUeCfg->upTnlInfo[drbIdx]) != ROK)
2235             {
2236                DU_LOG("\nERROR  -> DU_APP : duUpdateTunnelCfgDb: Failed to modify tunnel req for Drb id[%d]",
2237                      duUeCfg->upTnlInfo[drbIdx].drbId);
2238                ret = RFAILED;
2239             }
2240             break;
2241          }
2242          else
2243             drbFound = false;
2244       }
2245
2246       if(!drbFound && ret == ROK)/* new DRB to Add */
2247       {
2248          if(duProcEgtpTunnelCfg(NULLP, NULLP, &duUeCfg->upTnlInfo[drbIdx]) != ROK)
2249          {
2250             DU_LOG("\nERROR  -> DU_APP : duUpdateTunnelCfgDb: Failed to add tunnel req for Drb id[%d]",
2251                   duUeCfg->upTnlInfo[drbIdx].drbId);
2252             ret = RFAILED;
2253             break;
2254          }
2255       }
2256       else
2257          break;
2258    }
2259    return ret;
2260 }
2261
2262 /*******************************************************************
2263  *
2264  * @brief @brief To update DuUeCb Mac and Rlc Ue Cfg
2265  *
2266  *
2267  * @details
2268  *
2269  *    Function : duUpdateDuUeCbCfg
2270  *
2271  *    Functionality: update DuUeCb Mac and Rlc Ue Cfg
2272  *
2273  * @params[in] ueId, cellIdx
2274  * @return ROK     - success
2275  *         RFAILED - failure
2276  *
2277  * ****************************************************************/
2278
2279 uint8_t duUpdateDuUeCbCfg(uint8_t ueId, uint8_t cellId)
2280 {
2281    uint8_t ret = ROK, cellIdx = 0, crnti=0;
2282    DuUeCb *ueCb = NULLP;
2283
2284    GET_CELL_IDX(cellId, cellIdx);
2285
2286    if(duCb.actvCellLst[cellIdx] && (duCb.actvCellLst[cellIdx]->ueCb[ueId-1].macUeCfg.macUeCfgState == UE_RECFG_COMPLETE) &&
2287       (duCb.actvCellLst[cellIdx]->ueCb[ueId-1].rlcUeCfg.rlcUeCfgState == UE_RECFG_COMPLETE))
2288    {
2289       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueId-1];
2290
2291       /*Filling RLC Ue Cfg */
2292       ueCb->rlcUeCfg.cellId = cellId;
2293       ueCb->rlcUeCfg.ueId   = ueId;
2294       ret = duUpdateRlcLcCfg(&ueCb->rlcUeCfg, ueCb->f1UeDb);
2295       if(ret == ROK)
2296       {
2297          /*Filling MAC Ue Cfg */
2298          GET_CRNTI(crnti, ueId);
2299          ueCb->macUeCfg.cellId = cellId;
2300          ueCb->macUeCfg.ueId  = ueId;
2301          ueCb->macUeCfg.crnti  = crnti;
2302          ret = duUpdateMacCfg(&ueCb->macUeCfg, ueCb->f1UeDb);
2303          if(ret == RFAILED)
2304             DU_LOG("\nERROR  -->  DU APP : Failed while updating MAC LC Config at duUpdateDuUeCbCfg()");
2305          else
2306          {
2307             if(duUpdateTunnelCfgDb(ueId, cellId, &ueCb->f1UeDb->duUeCfg) != ROK)
2308             {
2309                DU_LOG("\nERROR  -->  DU_APP : Failed to establish tunnel in duUpdateDuUeCbCfg()");
2310                     return RFAILED;
2311             }
2312          }
2313       }
2314       else
2315          DU_LOG("\nERROR  -->  DU APP : Failed while updating RLC LC Config at duUpdateDuUeCbCfg()");
2316    }
2317    else
2318       ret = RFAILED;
2319    return ret;
2320 }
2321
2322 /*******************************************************************
2323  *
2324  * @brief Handle UE config response from MAC
2325  *
2326  * @details
2327  *
2328  *    Function : DuProcMacUeCfgRsp
2329  *
2330  *    Functionality: Handle UE Config response from MAC
2331  *
2332  * @params[in] Pointer to MacUeCfgRsp and Pst
2333  * @return ROK     - success
2334  *         RFAILED - failure
2335  *
2336  * ****************************************************************/
2337 uint8_t DuProcMacUeCfgRsp(Pst *pst, MacUeCfgRsp *cfgRsp)
2338 {
2339    uint8_t ret = ROK;
2340    uint16_t cellIdx;
2341
2342    if(cfgRsp)
2343    {
2344       GET_CELL_IDX(cfgRsp->cellId, cellIdx);
2345       if(cfgRsp->result == MAC_DU_APP_RSP_OK)
2346       {
2347          if(pst->event == EVENT_MAC_UE_CREATE_RSP)
2348          {
2349             DU_LOG("\nINFO   -->  DU APP : MAC UE Create Response : SUCCESS [DU UE F1AP ID : %d]", cfgRsp->ueId);
2350
2351             if(duCb.actvCellLst[cellIdx] &&
2352                   (duCb.actvCellLst[cellIdx]->ueCb[cfgRsp->ueId -1].gnbDuUeF1apId == cfgRsp->ueId))
2353             {
2354                duCb.actvCellLst[cellIdx]->ueCb[cfgRsp->ueId -1].macUeCfg.macUeCfgState = UE_CREATE_COMPLETE;
2355
2356                /* TODO : IF UE state is HANDIN_IN_PROGRESS, then send UE Context Setup Response */
2357             }
2358          }
2359          else if(pst->event == EVENT_MAC_UE_RECONFIG_RSP)
2360          {
2361             DU_LOG("\nINFO   -->  DU APP : MAC UE Reconfig Response : SUCCESS [DU UE F1AP ID : %d]", cfgRsp->ueId);
2362             if(duCb.actvCellLst[cellIdx] &&
2363                   (duCb.actvCellLst[cellIdx]->ueCb[cfgRsp->ueId -1].gnbDuUeF1apId == cfgRsp->ueId))
2364             {
2365                duCb.actvCellLst[cellIdx]->ueCb[cfgRsp->ueId -1].macUeCfg.macUeCfgState = UE_RECFG_COMPLETE;
2366                if((ret = duUpdateDuUeCbCfg(cfgRsp->ueId, cfgRsp->cellId)) == ROK)
2367                {
2368                   BuildAndSendUeCtxtRsp(cfgRsp->cellId, cfgRsp->ueId);
2369                }
2370             }
2371          }
2372       }
2373       else
2374       {
2375          DU_LOG("\nERROR  -->  DU APP : MAC UE CFG Response for EVENT[%d]: FAILURE [DU UE F1AP ID : %d]", pst->event, cfgRsp->ueId);
2376          if(pst->event == EVENT_MAC_UE_RECONFIG_RSP)
2377          {
2378             //TODO: Send the failure case in Ue Context Setup Response
2379          }
2380          ret = RFAILED;
2381       }
2382       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(MacUeCfgRsp));
2383    }
2384    else
2385    {
2386       DU_LOG("\nERROR  -->  DU APP : Received MAC Ue Config Response is NULL at DuProcMacUeCfgRsp()");
2387       ret = RFAILED;
2388    }
2389    return ret;
2390 }
2391
2392
2393 /*******************************************************************
2394  *
2395  * @brief Processes UE create Req to RLC UL
2396  *
2397  * @details
2398  *
2399  *    Function : duBuildAndSendUeCreateReqToRlc
2400  *
2401  *    Functionality:
2402  *     Processes UE create Req to RLC UL
2403  *
2404  *  @params[in]  cellId,
2405  *               ueId,
2406  *               Pointer to RlcUeCfg
2407  *  @return ROK     - success
2408  *          RFAILED - failure
2409  *
2410  *****************************************************************/
2411
2412 uint8_t duBuildAndSendUeCreateReqToRlc(uint16_t cellId, uint8_t ueId, RlcUeCfg *duRlcUeCfg)
2413 {
2414    uint8_t  ret = ROK;
2415    RlcUeCfg *rlcUeCfg = NULLP;
2416    Pst       pst;
2417
2418    ret = fillRlcUeCfg(cellId, ueId, NULL, duRlcUeCfg);
2419    if(ret == RFAILED)
2420    {
2421       DU_LOG("\nERROR  -->  DU APP : Failed to fill Rlc Ue Cfg at duBuildAndSendUeCreateReqToRlc()");
2422       return ret;
2423    }
2424
2425    FILL_PST_DUAPP_TO_RLC(pst, RLC_UL_INST, EVENT_RLC_UE_CREATE_REQ);
2426    /* Copying ueCfg to a sharable buffer */
2427    DU_ALLOC_SHRABL_BUF(rlcUeCfg, sizeof(RlcUeCfg));
2428    if(rlcUeCfg)
2429    {
2430       memset(rlcUeCfg, 0, sizeof(RlcUeCfg));
2431       memcpy(rlcUeCfg, duRlcUeCfg, sizeof(RlcUeCfg));
2432       /* Processing one Ue at a time to RLC */
2433       DU_LOG("\nDEBUG   -->  DU_APP: Sending UE create request to RLC UL");
2434       ret = (*packRlcUeCreateReqOpts[pst.selector])(&pst, rlcUeCfg);
2435       if(ret == RFAILED)
2436       {
2437          DU_LOG("\nERROR  -->  DU_APP : Failure in sending Ue Create Req to RLC");
2438          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, rlcUeCfg, sizeof(RlcUeCfg));
2439          ret = RFAILED;
2440       }
2441    }
2442    else
2443    {
2444       DU_LOG("\n ERROR  -->  DU APP : Memory alloc failed at duBuildAndSendUeCreateReqToRlc()");
2445       ret = RFAILED;
2446    }
2447    return ret;
2448 }
2449
2450 /*******************************************************************
2451  *
2452  * @brief Processes UE create Rsp received from RLC UL
2453  *
2454  * @details
2455  *
2456
2457  *    Function : DuProcRlcUeCfgRsp
2458  *
2459  *    Functionality:
2460  *     Processes UE create Rsp received from RLC UL
2461  *
2462  *  @params[in]  Post structure
2463  *               Pointer to RlcCfgCfm
2464  *  @return ROK     - success
2465  *          RFAILED - failure
2466  *
2467  *****************************************************************/
2468 uint8_t DuProcRlcUeCfgRsp(Pst *pst, RlcUeCfgRsp *cfgRsp)
2469 {
2470    uint8_t ret = ROK;
2471
2472    if(cfgRsp)
2473    {
2474       if(cfgRsp->result == RLC_DU_APP_RSP_OK)
2475       {
2476          if(pst->event == EVENT_RLC_UE_CREATE_RSP)
2477          {
2478             DU_LOG("\nINFO   -->  DU_APP: RLC UE Create Response : SUCCESS [UE IDX:%d]", cfgRsp->ueId);
2479             duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueId -1].\
2480                rlcUeCfg.rlcUeCfgState = UE_CREATE_COMPLETE;
2481          }
2482          else if(pst->event == EVENT_RLC_UE_RECONFIG_RSP)
2483          {
2484             DU_LOG("\nINFO   -->  DU_APP: RLC UE Reconfig Response : SUCCESS [UE IDX:%d]", cfgRsp->ueId);
2485             duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueId -1].\
2486                rlcUeCfg.rlcUeCfgState = UE_RECFG_COMPLETE;
2487             if((ret = duUpdateDuUeCbCfg(cfgRsp->ueId, cfgRsp->cellId)) == ROK)
2488             {
2489                BuildAndSendUeCtxtRsp(cfgRsp->cellId, cfgRsp->ueId);
2490             }
2491          }
2492       }
2493       else
2494       {
2495          DU_LOG("\nERROR  -->  DU_APP: RLC UE CFG Response for EVENT[%d] : FAILED [UE IDX : %d, REASON :%d]",\
2496                pst->event, cfgRsp->ueId, cfgRsp->reason);
2497          if((pst->event == EVENT_RLC_UE_RECONFIG_RSP))
2498          {
2499             //TODO: update failure case in ue Context setup Response
2500          }
2501          ret = RFAILED;
2502       }
2503       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(RlcUeCfgRsp));
2504    }
2505    else
2506    {
2507       DU_LOG("\nERROR  -->  DU_APP: Received RLC Ue Config Response is NULL at DuProcRlcUeCfgRsp()");
2508       ret = RFAILED;
2509    }
2510    return ret;
2511 }
2512
2513 /*******************************************************************
2514  *
2515  * @brief Builds and Send Ue Reconfig Req to RLC
2516  *
2517  * @details
2518  *
2519  *    Function : duBuildAndSendUeReCfgReqToRLC
2520  *
2521  *    Functionality: Builds and Send Ue Reconfig Req to RLC
2522  *
2523  * @params[in] cellId, crnti
2524  *             DuUeCfg *ueCfgDb
2525  *             RlcUeCfg *rlcUeCfg
2526  * @return ROK     - success
2527  *         RFAILED - failure
2528  *
2529  * ****************************************************************/
2530
2531 uint8_t duBuildAndSendUeReCfgReqToRlc(uint8_t cellId, uint8_t crnti, DuUeCfg *ueCfgDb)
2532 {
2533    uint8_t ret = ROK, ueId = 0;
2534    RlcUeCfg *rlcUeCfg = NULLP;
2535
2536    GET_UE_ID(crnti, ueId);
2537    DU_ALLOC_SHRABL_BUF(rlcUeCfg, sizeof(RlcUeCfg));
2538    if(rlcUeCfg)
2539    {
2540       memset(rlcUeCfg, 0, sizeof(RlcUeCfg));
2541       ret = fillRlcUeCfg(cellId, ueId, ueCfgDb, rlcUeCfg);
2542       if(ret == RFAILED)
2543          DU_LOG("\nERROR  -->  DU APP : Failed at duBuildAndSendUeReCfgReqToRlc()");
2544       else
2545          ret = sendUeReCfgReqToRlc(rlcUeCfg);
2546    }
2547    else
2548    {
2549       DU_LOG("\nERROR  -->  DU APP : Memory Alloc failed at duBuildAndSendUeReCfgReqToRlc()");
2550       ret = RFAILED;
2551    }
2552    return ret;
2553 }
2554
2555 /*******************************************************************
2556  *
2557  * @brief Builds and Send Ue Reconfig Req to MAC
2558  *
2559  * @details
2560  *
2561  *    Function : duBuildAndSendUeReCfgReqToMac
2562  *
2563  *    Functionality: Builds and Send Ue Reconfig Req to MAC
2564  *
2565  * @params[in] CellGroupConfigRrc_t *macCellGrpCfg
2566  *             DuUeCfg *ueCfgDb
2567  *             MacUeCfg    *macUeCfg
2568  * @return ROK     - success
2569  *         RFAILED - failure
2570  *
2571  * ****************************************************************/
2572
2573 uint8_t duBuildAndSendUeReCfgReqToMac(uint8_t cellId, uint8_t duUeF1apId, uint8_t crnti, DuUeCfg *ueCfgDb)
2574 {
2575    uint8_t ret = ROK;
2576    MacUeCfg *macUeCfg = NULLP;
2577
2578    DU_ALLOC_SHRABL_BUF(macUeCfg, sizeof(MacUeCfg));
2579    if(macUeCfg)
2580    {
2581       memset(macUeCfg, 0, sizeof(MacUeCfg));
2582       ret = fillMacUeCfg(cellId, duUeF1apId, crnti, ueCfgDb, macUeCfg);
2583       if(ret == RFAILED)
2584          DU_LOG("\nERROR  -->  DU APP : Failed to fill Mac Ue Cfg at duBuildAndSendUeReCfgReqToMac()");
2585       else
2586          ret = sendUeReCfgReqToMac(macUeCfg);
2587    }
2588    else
2589    {
2590       DU_LOG("\nERROR  -->  DU APP : Memory alloc failed for macUeCfg at duBuildAndSendUeReCfgReqToMac()");
2591       ret = RFAILED;
2592    }
2593    return ret;
2594 }
2595
2596 /*******************************************************************
2597  *
2598  * @brief Build and Send Ue context setup request
2599  *
2600  * @details
2601  *
2602
2603  *    Function : duBuildAndSendUeContextSetupReq
2604  *
2605  *    Functionality:
2606  *     Build and Send Ue context setup request
2607  *
2608  *  @params[in]  cellId, crnti, DuUeCfg pointer
2609  *  @return ROK     - success
2610  *          RFAILED - failure
2611  *
2612  *****************************************************************/
2613
2614 uint8_t duBuildAndSendUeContextSetupReq(uint16_t cellId, DuUeCb *ueCb)
2615 {
2616    uint8_t ret = ROK;
2617    uint16_t crnti;
2618    DuUeCfg *duUeCfg = NULLP;
2619
2620    DU_LOG("\nDEBUG   -->  DU_APP: Processing Ue Context Setup Request for cellId [%d]", cellId);
2621
2622    if(!ueCb)
2623    {
2624       DU_LOG("\nERROR  -->  DU APP : UE Cb is NULL");
2625       return RFAILED;
2626    }
2627
2628    crnti = ueCb->crnti;
2629    duUeCfg = &ueCb->f1UeDb->duUeCfg;
2630
2631    /* If UE is being handed-in to this DU, UE context setup request will create
2632     * new UE context at MAC/SCH and RLC.
2633     * If UE is in active state, UE contex setup request will lead to
2634     * reconfiguration of UE at MAC/SCH and RLC
2635     */
2636    if(ueCb->ueState == UE_HANDIN_IN_PROGRESS)
2637    {
2638       /* Filling MAC UE Config */
2639       memset(&ueCb->macUeCfg, 0, sizeof(MacUeCfg));
2640
2641       /* Since UE attach has not yet happened, ueId and crnti is unknow. Hence
2642        * passing 0 */
2643       ret = duBuildAndSendUeCreateReqToMac(cellId, ueCb->gnbDuUeF1apId, 0, duUeCfg, &ueCb->macUeCfg);
2644       if(ret == RFAILED)
2645          DU_LOG("\nERROR  -->  DU APP : Failed to send UE create request to MAC");
2646    }
2647    else
2648    {
2649       /* Filling RLC UE Reconfig */
2650       ret = duBuildAndSendUeReCfgReqToRlc(cellId, crnti, duUeCfg);
2651       if(ret == RFAILED)
2652          DU_LOG("\nERROR  -->  DU APP : Failed to build ctxt setup req for RLC at duBuildAndSendUeContextSetupReq()");
2653
2654       /* Filling MAC UE Reconfig */
2655       ret = duBuildAndSendUeReCfgReqToMac(cellId, ueCb->gnbDuUeF1apId, crnti, duUeCfg);
2656       if(ret == RFAILED)
2657          DU_LOG("\nERROR  -->  DU APP : Failed at build ctxt setup req for MAC at duBuildAndSendUeContextSetupReq()");
2658    }
2659
2660    return ret;
2661 }
2662
2663 /*******************************************************************
2664  *
2665  * @brief Processes DL Rsp received from RLC DL
2666  *
2667  * @details
2668  *
2669
2670  *    Function : DuProcRlcDlRrcMsgRsp
2671  *
2672  *    Functionality:
2673  *     Processes UE Rsp received from RLC DL
2674  *
2675  *  @params[in]  Post structure
2676  *               Pointer to RlcCfgCfm
2677  *  @return ROK     - success
2678  *          RFAILED - failure
2679  *
2680  *****************************************************************/
2681 uint8_t DuProcRlcDlRrcMsgRsp(Pst *pst, RlcDlRrcMsgRsp *dlRrcMsg)
2682 {
2683    uint8_t ret = ROK, ueId = 0;
2684    uint16_t cellId, crnti;
2685    DuUeCb *ueCb = NULLP;
2686    DlMsgState state;
2687
2688    state = dlRrcMsg->state;
2689    cellId = dlRrcMsg->cellId;
2690    crnti = dlRrcMsg->crnti;
2691    DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, dlRrcMsg, sizeof(RlcDlRrcMsgRsp));
2692
2693    if(state == TRANSMISSION_COMPLETE)
2694    {
2695       GET_UE_ID(crnti, ueId);
2696       ueCb = &duCb.actvCellLst[cellId -1]->ueCb[ueId -1];
2697
2698       if(ueCb->f1UeDb && ueCb->f1UeDb->dlRrcMsgPres)
2699       {
2700          if(ueCb->f1UeDb->actionType == UE_CTXT_SETUP)
2701          {
2702             ret = duBuildAndSendUeContextSetupReq(cellId, ueCb);
2703             if(ret == RFAILED)
2704                DU_LOG("\nERROR  -->  DU APP : Failed to process UE Context Setup Request in DuProcRlcDlRrcMsgRsp()");
2705          }
2706
2707          if(ueCb->f1UeDb->actionType == UE_CTXT_MOD)
2708          {
2709             ret = duBuildAndSendUeContextModReq(cellId, ueCb->gnbDuUeF1apId, crnti, &ueCb->f1UeDb->duUeCfg);
2710             if(ret == RFAILED)
2711                DU_LOG("\nERROR  -->  DU APP : Failed to process UE Context Mod Request in DuProcRlcDlRrcMsgRsp()");
2712          }
2713
2714          if(ueCb->f1UeDb->actionType == UE_CTXT_RELEASE && ueCb->ueState == UE_ACTIVE)
2715          {
2716             ret = duBuildAndSendUeDeleteReq(cellId, crnti);
2717             if(ret == RFAILED)
2718             {
2719                DU_LOG("\nERROR  -->  DU APP : Failed to process UE Context Release Request in DuProcRlcDlRrcMsgRsp()");
2720             }
2721          }
2722       }
2723    }
2724    else
2725       DU_LOG("\nERROR  -->  DU APP : Failed to transmit DL RRC Msg");
2726
2727    return ret;
2728 }
2729 /*******************************************************************
2730  *
2731  * @brief Process UE context setup request from CU
2732  *
2733  * @details
2734  *
2735  *    Function : duProcUeContextSetupRequest
2736  *
2737  *    Functionality: Process UE context setup request from CU
2738  *
2739  * @params[in] F1AP message
2740  * @return ROK     - success
2741  *         RFAILED - failure
2742  *
2743  * ****************************************************************/
2744
2745 uint8_t duProcUeContextSetupRequest(DuUeCb *ueCb)
2746 {
2747    uint8_t ret, cellId;
2748
2749    ret = ROK;
2750    if(ueCb)
2751    {
2752       cellId = duCb.actvCellLst[ueCb->f1UeDb->cellIdx]->cellId;
2753
2754       /* Send DL RRC msg for security Mode */
2755       if(ueCb->f1UeDb->dlRrcMsg)
2756       {
2757          if(ueCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
2758          {
2759             /* Sending DL RRC Message to RLC */
2760             ret = duBuildAndSendDlRrcMsgToRlc(cellId, ueCb->rlcUeCfg, ueCb->f1UeDb->dlRrcMsg);
2761             if(ret == RFAILED)
2762             {
2763                DU_LOG("\nERROR  -->  DU APP : Failed to send DL RRC msg in duProcUeContextSetupRequest()");
2764                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCb->f1UeDb->dlRrcMsg->rrcMsgPdu,\
2765                      ueCb->f1UeDb->dlRrcMsg->rrcMsgSize);
2766                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
2767             }
2768          }
2769       }
2770       else if(ueCb->f1UeDb->actionType == UE_CTXT_SETUP)
2771       {
2772          ret = duBuildAndSendUeContextSetupReq(cellId, ueCb);
2773          if(ret == RFAILED)
2774          {
2775             DU_LOG("\nERROR  -->  DU APP : Failed to build ue context setup Req in duProcUeContextSetupRequest()");
2776          }
2777       }
2778    }
2779    else
2780    {
2781       //TODO: To send the failure cause in UeContextSetupRsp
2782       DU_LOG("ERROR  -->  DU APP : Failed to process UE CNTXT SETUP REQ at duProcUeContextSetupRequest()");
2783    }
2784    return ret;
2785 }
2786
2787 /*******************************************************************
2788  *
2789  * @brief Build and Send Ue context mod request
2790  *
2791  * @details
2792  *
2793  *
2794  *    Function : duBuildAndSendUeContextModReq
2795  *
2796  *    Functionality:
2797  *     Build and Send Ue context mod request
2798  *
2799  *  @params[in]  cellId, crnti, DuUeCfg pointer
2800  *  @return ROK     - success
2801  *          RFAILED - failure
2802  *
2803  *****************************************************************/
2804
2805 uint8_t duBuildAndSendUeContextModReq(uint16_t cellId, uint8_t gnbDuUeF1apId, uint16_t crnti, DuUeCfg *duUeCfg)
2806 {
2807    uint8_t ret = ROK;
2808
2809    DU_LOG("\nDEBUG   -->  DU_APP: Processing Ue Context Mod Request for cellId [%d]", cellId);
2810    /* Filling RLC Ue Reconfig */
2811    ret = duBuildAndSendUeReCfgReqToRlc(cellId, crnti, duUeCfg);
2812    if(ret == RFAILED)
2813       DU_LOG("\nERROR  -->  DU APP : Failed to build ctxt setup req for RLC at duBuildAndSendUeContextModReq()");
2814
2815    /* Filling MAC Ue Reconfig */
2816    ret = duBuildAndSendUeReCfgReqToMac(cellId, gnbDuUeF1apId, crnti, duUeCfg);
2817    if(ret == RFAILED)
2818       DU_LOG("\nERROR  -->  DU APP : Failed at build ctxt setup req for MAC at duBuildAndSendUeContextModReq()");
2819
2820    return ret;
2821 }
2822 /*******************************************************************
2823  *
2824  * @brief Processing Ue context mod request
2825  *
2826  * @details
2827  *
2828  *
2829  *    Function : duProcUeContextModReq
2830  *
2831  *    Functionality:
2832  *        Processing  Ue context mod request
2833  *
2834  *  @params[in] DuUeCb *ueCb
2835  *  @return ROK     - success
2836  *          RFAILED - failure
2837  *
2838  *****************************************************************/
2839
2840 uint8_t duProcUeContextModReq(DuUeCb *ueCb)
2841 {
2842    uint8_t ret, cellId;
2843
2844    ret = ROK;
2845    if(ueCb)
2846    {
2847       cellId = duCb.actvCellLst[ueCb->f1UeDb->cellIdx]->cellId;
2848       /* Send DL RRC msg for security Mode */
2849       if(ueCb->f1UeDb->dlRrcMsg)
2850       {
2851          if(ueCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
2852          {
2853             /* Sending DL RRC Message to RLC */
2854             ret = duBuildAndSendDlRrcMsgToRlc(cellId, ueCb->rlcUeCfg, ueCb->f1UeDb->dlRrcMsg);
2855             if(ret == RFAILED)
2856             {
2857                DU_LOG("\nERROR  -->  DU APP : Failed to send DL RRC msg in duProcUeContextModReq()");
2858                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCb->f1UeDb->dlRrcMsg->rrcMsgPdu,\
2859                      ueCb->f1UeDb->dlRrcMsg->rrcMsgSize);
2860                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
2861             }
2862          }
2863       }
2864       else if(ueCb->f1UeDb->actionType == UE_CTXT_MOD)
2865       {
2866          ret = duBuildAndSendUeContextModReq(cellId, ueCb->gnbDuUeF1apId, ueCb->crnti, &ueCb->f1UeDb->duUeCfg);
2867          if(ret == RFAILED)
2868          {
2869             DU_LOG("\nERROR  -->  DU APP : Failed to build ue context setup Req in duProcUeContextModReq()");
2870             return RFAILED;
2871          }
2872       }
2873       else if((ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY) || (ueCb->f1UeDb->actionType == UE_CTXT_RRC_RECFG_COMPLETE))
2874       {
2875          if((BuildAndSendUeContextModRsp(ueCb) != ROK))
2876          {
2877             DU_LOG("\nERROR  -->  DU APP : Failed to build UE Context modification response");
2878             return RFAILED;
2879          }
2880       }
2881    }
2882    else
2883    {
2884       //TODO: To send the failure cause in UeContextModRsp
2885
2886       DU_LOG("ERROR  -->  DU APP : Failed to process UE CNTXT MOD REQ at duProcUeContextModReq()");
2887       return RFAILED;
2888    }
2889    return ROK;
2890 }
2891
2892 /*******************************************************************
2893 *
2894 * @brief Function to delete Pdsch ServCellCfg
2895 *
2896 * @details
2897 *
2898 *    Function : deletePdschServCellCfg
2899 *
2900 *    Functionality: Function to delete Pdsch ServCellCfg
2901 *
2902 * @params[in] PdschServCellCfg *pdschServCellCfg
2903 * @return void
2904 *
2905 * ****************************************************************/
2906
2907 void deletePdschServCellCfg(PdschServCellCfg *pdschServCellCfg)
2908 {
2909    DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL,pdschServCellCfg->maxMimoLayers, sizeof(uint8_t));
2910    DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL,pdschServCellCfg->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
2911    DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL,pdschServCellCfg->codeBlkGrpFlushInd, sizeof(bool));
2912    DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL,pdschServCellCfg->xOverhead, sizeof(PdschXOverhead));
2913 }
2914
2915 /*******************************************************************
2916  *
2917 * @brief delete MacUeCfg from duCb
2918 *
2919 * @details
2920 *
2921 *    Function : deleteMacUeCfg
2922 *
2923 *    Functionality: delete MacUeCfg from duCb
2924 *
2925 * @params[in] Pointer to MacUeCfg
2926 * @return ROK     - success
2927 *         RFAILED - failure
2928 *
2929 *******************************************************************/
2930
2931 void deleteMacUeCfg(MacUeCfg *ueCfg)
2932 {
2933    uint8_t lcCfgIdx=0;
2934
2935    DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL,ueCfg->ambrCfg, sizeof(AmbrCfg));
2936    if(ueCfg->spCellCfgPres)
2937    {
2938       freeUeReCfgCellGrpInfo(ueCfg);
2939    }
2940    for(lcCfgIdx=0; lcCfgIdx< ueCfg->numLcs; lcCfgIdx++)
2941    {
2942       freeMacLcCfg(&ueCfg->lcCfgList[lcCfgIdx]);
2943    }
2944    memset(ueCfg, 0, sizeof(MacUeCfg));
2945 }
2946
2947 /*******************************************************************
2948 *
2949 * @brief delete UE Configuration of a particular UE
2950 *
2951 * @details
2952 *
2953 *    Function : deleteUeCfg
2954 *
2955 *    Functionality: delete UE Configuration of a particular UE
2956 *
2957 * @params[in] uint16_t cellIdx, uint8_t ueId
2958 * @return ROK     - success
2959 *         RFAILED - failure
2960 *
2961 * ****************************************************************/
2962 uint8_t  deleteUeCfg(uint16_t cellId, uint8_t ueId)
2963 {
2964    uint8_t tnlIdx = 0;
2965    uint16_t cellIdx = 0;
2966    DuUeCb *ueCb = NULLP;
2967
2968    GET_CELL_IDX(cellId, cellIdx);
2969    if(duCb.actvCellLst[cellIdx] != NULLP)
2970    {
2971       if((duCb.actvCellLst[cellIdx]->ueCb[ueId-1].macUeCfg.macUeCfgState == UE_DELETE_COMPLETE)\
2972             &&(duCb.actvCellLst[cellIdx]->ueCb[ueId-1].rlcUeCfg.rlcUeCfgState == UE_DELETE_COMPLETE))
2973       {
2974          ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueId-1];
2975          deleteMacUeCfg(&ueCb->macUeCfg);
2976          deleteRlcUeCfg(&ueCb->rlcUeCfg);
2977          if(ueCb->f1UeDb !=NULLP)
2978          {
2979             freeF1UeDb(ueCb->f1UeDb);
2980          }
2981          for(tnlIdx = 0; tnlIdx < duCb.numTeId; )
2982          {
2983             if(duCb.upTnlCfg[tnlIdx]->ueId == ueId)
2984             {
2985                duCb.upTnlCfg[tnlIdx]->configType = CONFIG_DEL;
2986                duProcEgtpTunnelCfg(tnlIdx, duCb.upTnlCfg[tnlIdx], duCb.upTnlCfg[tnlIdx]);
2987             }
2988             else
2989                tnlIdx++;
2990          }
2991          unsetBitInUeBitMap(cellId, ueId-1);
2992          duCb.actvCellLst[cellIdx]->numActvUes--;
2993          memset(ueCb, 0, sizeof(DuUeCb));
2994       }
2995       else
2996       {
2997          return RFAILED;
2998       }
2999    }
3000    else
3001    {
3002       DU_LOG("\nERROR  --> DU APP : deleteUeCfg(): CellIdx[%d] is not found", cellIdx);
3003       return RFAILED;
3004    }
3005    return ROK;
3006 }
3007
3008
3009 /*******************************************************************
3010 *
3011 * @brief Handle UE delete response from MAC
3012 *
3013 * @details
3014 *
3015 *    Function : DuProcMacUeDeleteRsp
3016 *
3017 *    Functionality: Handle UE delete response from MAC
3018 *
3019 * @params[in] Pointer to MacUeDeleteRsp and Pst
3020 * @return ROK     - success
3021 *         RFAILED - failure
3022 *
3023 * ****************************************************************/
3024
3025 uint8_t DuProcMacUeDeleteRsp(Pst *pst, MacUeDeleteRsp *deleteRsp)
3026 {
3027    uint8_t  ret =ROK,ueId=0;
3028    uint16_t cellIdx=0;
3029    uint32_t gnbCuUeF1apId =0 , gnbDuUeF1apId =0;
3030
3031    if(deleteRsp)
3032    {
3033       if(deleteRsp->result == SUCCESS)
3034       {
3035          DU_LOG("\nINFO   -->  DU APP : MAC UE Delete Response : SUCCESS [UE IDX : %d]", deleteRsp->ueId);
3036          GET_CELL_IDX(deleteRsp->cellId, cellIdx);
3037          if(duCb.actvCellLst[cellIdx])
3038          {
3039             duCb.actvCellLst[cellIdx]->ueCb[deleteRsp->ueId -1].macUeCfg.macUeCfgState = UE_DELETE_COMPLETE;
3040             ueId = deleteRsp->ueId;
3041             gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbCuUeF1apId;
3042             gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbDuUeF1apId;
3043             if(deleteUeCfg(deleteRsp->cellId, ueId) == ROK)
3044             {
3045                ret = BuildAndSendUeContextReleaseComplete(deleteRsp->cellId, gnbCuUeF1apId, gnbDuUeF1apId);
3046                if(ret != ROK)
3047                {
3048                   DU_LOG("\nERROR  -->  DU APP : DuProcMacUeDeleteRsp(): failed to send UE context release complete");
3049                }
3050             }
3051
3052          }
3053       }
3054       else
3055       {
3056          DU_LOG("\nERROR  -->  DU APP : DuProcMacUeDeleteRsp(): MAC UE Delete Response : FAILURE [UE IDX : %d]",\
3057          deleteRsp->ueId);
3058          ret =  RFAILED;
3059       }
3060       DU_FREE_SHRABL_BUF(pst->region, pst->pool, deleteRsp, sizeof(MacUeDeleteRsp));
3061    }
3062    else
3063    {
3064       DU_LOG("\nERROR  -->  DU APP : DuProcMacUeDeleteRsp(): MAC UE Delete Response is null");
3065       ret = RFAILED;
3066    }
3067    return ret;
3068 }
3069
3070 /*******************************************************************
3071  *
3072  * @brief Processes UE Delete Rsp received from RLC
3073  *
3074  * @details
3075  *
3076  *    Function : DuProcRlcUeDeleteRsp
3077  *
3078  *    Functionality:
3079  *     Processes UE Delete Rsp received from RLC
3080  *
3081  *  @params[in]  Post structure
3082  *               Pointer to RlcUeDeleteRsp
3083  *  @return ROK     - success
3084  *          RFAILED - failure
3085  *
3086  * *****************************************************************/
3087
3088 uint8_t DuProcRlcUeDeleteRsp(Pst *pst, RlcUeDeleteRsp *delRsp)
3089 {
3090    uint8_t  ueId = 0, ret = ROK;
3091    uint16_t cellIdx = 0,crnti=0;
3092
3093    if(delRsp)
3094    {
3095       ueId = delRsp->ueId;
3096       GET_CELL_IDX(delRsp->cellId, cellIdx);
3097
3098       if(delRsp->result == SUCCESSFUL)
3099       {
3100          DU_LOG("\nINFO   -->  DU_APP: RLC UE Delete Response : SUCCESS [UE IDX:%d]", ueId);
3101          if(duCb.actvCellLst[cellIdx]!=NULLP)
3102          {
3103             duCb.actvCellLst[cellIdx]->ueCb[ueId-1].rlcUeCfg.rlcUeCfgState = UE_DELETE_COMPLETE;
3104             GET_CRNTI(crnti, ueId);
3105             if(sendUeDeleteReqToMac(delRsp->cellId, ueId, crnti) == RFAILED)
3106             {
3107                DU_LOG("\nERROR  -->  DU APP : duBuildAndSendUeDeleteReq(): Failed to build UE  delete req for MAC ");
3108                return RFAILED;
3109             }
3110
3111          }
3112       }
3113       else
3114       {
3115          DU_LOG("\nERROR   -->  DU_APP: RLC UE Delete Response : FAILED [UE IDX:%d]", ueId);
3116          ret = RFAILED;
3117       }
3118       DU_FREE_SHRABL_BUF(pst->region, pst->pool, delRsp, sizeof(RlcUeDeleteRsp));
3119
3120    }
3121    return ret;
3122 }
3123
3124 /*******************************************************************
3125  *
3126  * @brief Sending UE Delete Req To Mac
3127 *
3128 * @details
3129 *
3130 *    Function : sendUeDeleteReqToMac
3131 *
3132 *    Functionality:
3133 *     sending UE Delete Req To Mac
3134 *
3135 *  @params[in]    cellId, ueId, crnti
3136 *  @return ROK     - success
3137 *          RFAILED - failure
3138 *
3139 *****************************************************************/
3140
3141 uint8_t sendUeDeleteReqToMac(uint16_t cellId, uint8_t ueId, uint16_t crnti)
3142 {
3143    Pst pst;
3144    uint8_t ret=ROK;
3145    MacUeDelete *ueDelete = NULLP;
3146
3147    DU_ALLOC_SHRABL_BUF(ueDelete, sizeof(MacUeDelete));
3148    if(ueDelete)
3149    {
3150       ueDelete->cellId = cellId;
3151       ueDelete->ueId   = ueId;
3152       ueDelete->crnti  = crnti;
3153       FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_UE_DELETE_REQ);
3154
3155       DU_LOG("\nDEBUG  -->  DU_APP: Sending UE delete Request to MAC ");
3156       ret = (*packMacUeDeleteReqOpts[pst.selector])(&pst, ueDelete);
3157       if(ret == RFAILED)
3158       {
3159          DU_LOG("\nERROR  -->  DU_APP: sendUeDeleteReqToMac(): Failed to send UE delete Req to MAC");
3160          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueDelete, sizeof(MacUeDelete));
3161       }
3162    }
3163    else
3164    {
3165       DU_LOG("\nERROR  -->   DU_APP: sendUeDeleteReqToMac(): Failed to allocate memory");
3166       ret = RFAILED;
3167    }
3168    return ret;
3169 }
3170
3171 /*******************************************************************
3172  *
3173  * @brief Sending UE Delete Req To Rlc
3174  *
3175  * @details
3176  *
3177  *    Function : sendUeDeleteReqToRlc
3178  *
3179  *    Functionality:
3180  *     Sending UE Delete Req To Rlc
3181  *
3182  *  @params[in]  cellId, ueId
3183  *  @return ROK     - success
3184  *          RFAILED - failure
3185  *
3186  *****************************************************************/
3187
3188 uint8_t sendUeDeleteReqToRlc(uint16_t cellId, uint8_t ueId)
3189 {
3190    uint8_t ret;
3191    Pst pst;
3192    RlcUeDelete *ueDelete;
3193
3194    DU_ALLOC_SHRABL_BUF(ueDelete, sizeof(RlcUeDelete));
3195    if(ueDelete !=NULLP)
3196    {
3197       ueDelete->cellId = cellId;
3198       ueDelete->ueId = ueId;
3199       FILL_PST_DUAPP_TO_RLC(pst, RLC_UL_INST, EVENT_RLC_UE_DELETE_REQ);
3200
3201       ret = (*packRlcUeDeleteReqOpts[pst.selector])(&pst, ueDelete);
3202       if(ret == RFAILED)
3203       {
3204          DU_LOG("\nERROR  -->  DU_APP : sendUeDeleteReqToRlc():Failed to send UE Delete  Req to RLC");
3205          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueDelete, sizeof(RlcUeDelete));
3206       }
3207    }
3208    else
3209    {
3210       DU_LOG("\nERROR  -->   DU_APP: sendUeDeleteReqToRlc():Memory allocation failed");
3211       ret = RFAILED;
3212    }
3213    return ret;
3214 }
3215
3216 /*******************************************************************
3217  *
3218  * @brief DU processes UE delete req from CU and sends to MAC and RLC
3219  *
3220  * @details
3221  *
3222  *    Function : duBuildAndSendUeDeleteReq
3223  *
3224  *    Functionality: DU processes UE delete req from CU and sends to MAC
3225  *                   and RLC
3226  *
3227  * @params[in] cellId, crnti
3228  * @return ROK     - success
3229  *         RFAILED - failure
3230  *
3231  * ****************************************************************/
3232
3233 uint8_t duBuildAndSendUeDeleteReq(uint16_t cellId, uint16_t crnti)
3234 {
3235    uint8_t  ueId =0;
3236    uint16_t cellIdx = 0;
3237
3238    DU_LOG("\nDEBUG  -->  DU_APP: Processing UE Delete Request ");
3239    GET_CELL_IDX(cellId, cellIdx);
3240    GET_UE_ID(crnti, ueId);
3241
3242    if(duCb.actvCellLst[cellIdx] != NULLP)
3243    {
3244       if(crnti != duCb.actvCellLst[cellIdx]->ueCb[ueId - 1].crnti)
3245       {
3246          DU_LOG("\nERROR  -->  DU APP : duBuildAndSendUeDeleteReq(): CRNTI [%d] not found", crnti);
3247          return RFAILED;
3248       }
3249
3250       duCb.actvCellLst[cellIdx]->ueCb[ueId - 1].ueState = UE_DELETION_IN_PROGRESS;
3251       if(sendUeDeleteReqToRlc(cellId, ueId) == RFAILED)
3252       {
3253          DU_LOG("\nERROR  -->  DU APP : DuProcMacUeDeleteRsp():Failed to build UE  delete req for RLC ");
3254          return RFAILED;
3255       }
3256    }
3257    else
3258    {
3259       DU_LOG("\nERROR  -->  DU APP : duBuildAndSendUeDeleteReq(): Cell Id is not found");
3260       return RFAILED;
3261    }
3262
3263    return ROK;
3264 }
3265
3266 /*******************************************************************
3267  *
3268  * @brief delete RlcUeCfg from duCb
3269  *
3270  * @details
3271  *
3272  *    Function : deleteRlcUeCfg
3273  *
3274  *    Functionality:
3275  *       delete  RlcUeCfg from duCb
3276  *
3277  *  @params[in] RlcUeCfg *ueCfg
3278  *
3279  *  @return ROK     - success
3280  *          RFAILED - failure
3281  *
3282  *****************************************************************/
3283
3284 void deleteRlcUeCfg(RlcUeCfg *ueCfg)
3285 {
3286    uint8_t lcIdx = 0;
3287    RlcBearerCfg *lcCfg= NULLP;
3288    if(ueCfg)
3289    {
3290       for(lcIdx =0 ; lcIdx < ueCfg->numLcs ; lcIdx++)
3291       {
3292          lcCfg = &ueCfg->rlcLcCfg[lcIdx];
3293          switch(lcCfg->rlcMode)
3294          {
3295             case RLC_AM :
3296                {
3297                   DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.amCfg, sizeof(AmBearerCfg));
3298                   break;
3299                }
3300             case RLC_UM_BI_DIRECTIONAL :
3301                {
3302                   DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
3303                   break;
3304                }
3305             case RLC_UM_UNI_DIRECTIONAL_UL :
3306                {
3307                   DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
3308                   break;
3309                }
3310             case RLC_UM_UNI_DIRECTIONAL_DL :
3311                {
3312                   DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
3313                   break;
3314                }
3315          }
3316          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
3317       }
3318       memset(ueCfg, 0, sizeof(RlcUeCfg));
3319    }
3320 }
3321
3322 /*******************************************************************
3323 *
3324 * @brief Du process Ue Context Release Command
3325 *
3326 * @details
3327 *
3328 *    Function : duProcUeContextReleaseCommand
3329 *
3330 *    Functionality: Du process Ue Context Release Command
3331 *
3332 * @params[in] DuUeCb *duUeCb
3333 * @return ROK     - success
3334 *         RFAILED - failure
3335 *
3336 * ****************************************************************/
3337 uint8_t duProcUeContextReleaseCommand(uint16_t cellId, DuUeCb *duUeCb)
3338 {
3339    uint8_t ret =ROK, ueId=0;
3340    uint16_t crnti = 0;
3341
3342    if(duUeCb != NULLP)
3343    {
3344       crnti = duUeCb->crnti;
3345       GET_UE_ID(crnti, ueId);
3346
3347       if(duUeCb->f1UeDb)
3348       {
3349          /* Send DL RRC msg for RRC release */
3350          if(duUeCb->f1UeDb->dlRrcMsg)
3351          {
3352             if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu != NULLP)
3353             {
3354                ret = duBuildAndSendDlRrcMsgToRlc(cellId, duCb.actvCellLst[duUeCb->f1UeDb->cellIdx]->ueCb[ueId-1].rlcUeCfg,\
3355                      duUeCb->f1UeDb->dlRrcMsg);
3356                if(ret == RFAILED)
3357                {
3358                   DU_LOG("\nERROR  -->  DU APP : duProcUeContextReleaseCommand() : Failed to send DL RRC msg");
3359                   DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu,\
3360                         duUeCb->f1UeDb->dlRrcMsg->rrcMsgSize);
3361                   DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
3362                }
3363             }
3364          }
3365       }
3366       else
3367       {
3368          ret = duBuildAndSendUeDeleteReq(cellId,crnti);
3369          if(ret == RFAILED)
3370          {
3371             DU_LOG("\nERROR  -->  DU APP : duProcUeContextReleaseCommand(): Failed to build and send Ue Delete request");
3372          }
3373       }
3374    }
3375    return ret;
3376 }
3377
3378 /**********************************************************************
3379   End of file
3380 ***********************************************************************/