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