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