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