src/du_app/du_ue_mgr.c

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