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 DuMacDlCcchInd packMacDlCcchIndOpts[] =
  38 {
  39    packMacDlCcchInd,           /* Loose coupling */
  40    MacProcDlCcchInd,           /* TIght coupling */
  41    packMacDlCcchInd            /* Light weight-loose coupling */
  42 };
  43
  44 DuMacUeCreateReq packMacUeCreateReqOpts[] =
  45 {
  46    packDuMacUeCreateReq,       /* Loose coupling */
  47    MacProcUeCreateReq,         /* TIght coupling */
  48    packDuMacUeCreateReq        /* Light weight-loose coupling */
  49 };
  50
  51 DuRlcUeCreateReq packRlcUeCreateReqOpts[] =
  52 {
  53    packDuRlcUeCreateReq,       /* Loose coupling */
  54    RlcProcUeCreateReq,         /* TIght coupling */
  55    packDuRlcUeCreateReq        /* Light weight-loose coupling */
  56 };
  57
  58 DuDlRrcMsgToRlcFunc duSendDlRrcMsgToRlcOpts[] =
  59 {
  60    packDlRrcMsgToRlc,          /* Loose coupling */
  61    RlcProcDlRrcMsgTransfer,    /* Tight coupling */
  62    packDlRrcMsgToRlc           /* Light weight-loose coupling */
  63 };
  64
  65 DuRlcUeReconfigReq packRlcUeReconfigReqOpts[] =
  66 {
  67    packDuRlcUeReconfigReq,     /* Loose coupling */
  68    RlcProcUeReconfigReq,       /* TIght coupling */
  69    packDuRlcUeReconfigReq      /* Light weight-loose coupling */
  70 };
  71
  72 DuMacUeReconfigReq packMacUeReconfigReqOpts[] =
  73 {
  74    packDuMacUeReconfigReq,     /* Loose coupling */
  75    MacProcUeReconfigReq,       /* TIght coupling */
  76    packDuMacUeReconfigReq      /* Light weight-loose coupling */
  77 };
  78
  79 DuRlcDlUserDataToRlcFunc duSendRlcDlUserDataToRlcOpts[] =
  80 {
  81    packRlcDlUserDataToRlc,        /* Loose coupling */
  82    RlcProcDlUserDataTransfer,  /* Tight coupling */
  83    packRlcDlUserDataToRlc         /* Light weight-loose coupling */
  84 };
  85
  86 /*******************************************************************
  87  *
  88  * @brief Function to fillDlUserDataInfo
  89  *
  90  * @details
  91  *
  92  *    Function : fillDlUserDataInfo
  93  *
  94  *    Functionality:
  95  *      Function to fillDlUserDataInfo
  96  *
  97  * @params[in] teId,
  98  *             dlDataMsgInfo
  99  *
 100  * @return ROK     - success
 101  *         RFAILED - failure
 102  *
 103  * ****************************************************************/
 104
 105 uint8_t fillDlUserDataInfo(uint32_t teId, RlcDlUserDataInfo *dlDataMsgInfo)
 106 {
 107    uint8_t drbIdx;
 108
 109    for(drbIdx = 0; drbIdx < duCb.numDrb; drbIdx++)
 110    {
 111       if(duCb.upTnlCfg[drbIdx] && (duCb.upTnlCfg[drbIdx]->tnlCfg1 != NULLP))
 112       {
 113         if(duCb.upTnlCfg[drbIdx]->tnlCfg1->teId == teId)
 114         {
 115            dlDataMsgInfo->cellId = duCb.upTnlCfg[drbIdx]->cellId;
 116            dlDataMsgInfo->ueIdx = duCb.upTnlCfg[drbIdx]->ueIdx;
 117            dlDataMsgInfo->rbId = duCb.upTnlCfg[drbIdx]->drbId;
 118            return ROK;
 119         }
 120       }
 121    }
 122    return RFAILED;
 123 }
 124
 125  /*******************************************************************
 126  *
 127  * @brief Build and Send DL Data Message transfer to RLC
 128  *
 129  * @details
 130  *
 131  *    Function : duBuildAndSendDlUserDataToRlc
 132  *
 133  *    Functionality:
 134  *      Build and Send DL Data Message transfer to RLC
 135  *
 136  * @params[in] Cell ID
 137  *             UE Index
 138  *             Logical Channgel ID
 139  *             RRC Message
 140  *             RRC Message Length
 141  * @return ROK     - success
 142  *         RFAILED - failure
 143  *
 144  * ****************************************************************/
 145
 146 uint8_t duBuildAndSendDlUserDataToRlc(uint16_t msgLen, EgtpMsg *egtpMsg)
 147 {
 148    uint8_t ret = RFAILED;
 149    Pst     pst;
 150    RlcDlUserDataInfo *dlDataMsgInfo = NULLP;
 151
 152    DU_ALLOC_SHRABL_BUF(dlDataMsgInfo, sizeof(RlcDlUserDataInfo));
 153    if(!dlDataMsgInfo)
 154    {
 155       DU_LOG("\nERROR  -->  DU_APP : Memory allocation failed for dlDataMsgInfo in duHdlEgtpDlData()");
 156       return RFAILED;
 157    }
 158    memset(dlDataMsgInfo, 0, sizeof(RlcDlUserDataInfo));
 159    if(ODU_GET_MSG_BUF(DU_APP_MEM_REGION, DU_POOL, &dlDataMsgInfo->dlMsg) != ROK)
 160    {
 161       DU_LOG("\nERROR  -->  DU_APP : Memory allocation failed for dlMsg in duHdlEgtpDlData()");
 162       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, dlDataMsgInfo, sizeof(RlcDlUserDataInfo));
 163       return RFAILED;
 164    }
 165    dlDataMsgInfo->dlMsg = egtpMsg->msg;
 166    dlDataMsgInfo->msgLen = msgLen;
 167
 168    /* Filling DL DATA Msg Info */
 169    if(fillDlUserDataInfo(egtpMsg->msgHdr.teId, dlDataMsgInfo) == ROK)
 170    {
 171       /* Filling post structure and sending msg */
 172       FILL_PST_DUAPP_TO_RLC(pst, RLC_DL_INST, EVENT_DL_USER_DATA_TRANS_TO_RLC);
 173       DU_LOG("\nDEBUG  -->  DU_APP : Sending User Data Msg to RLC \n");
 174       ret = (*duSendRlcDlUserDataToRlcOpts[pst.selector])(&pst, dlDataMsgInfo);
 175    }
 176    if(ret != ROK)
 177    {
 178       DU_LOG("\nERROR  -->  DU_APP : Failed to send User Data to RLC in duHdlEgtpDlData()");
 179       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, dlDataMsgInfo->dlMsg, msgLen);
 180       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, dlDataMsgInfo, sizeof(RlcDlUserDataInfo));
 181    }
 182    return ret;
 183 }
 184
 185 /*******************************************************************
 186  *
 187  * @brief Handles EGTP data from CU
 188  *
 189  * @details
 190  *
 191  *    Function : duHdlEgtpData
 192  *
 193  *    Functionality:
 194  *      Processes EGTP header and sends data to RLC
 195  *
 196  * @params[in]  Pointer to EGTP Message
 197  * @return ROK     - success
 198  *         RFAILED - failure
 199  *
 200  * ****************************************************************/
 201 uint8_t duHdlEgtpDlData(EgtpMsg  *egtpMsg)
 202 {
 203    uint16_t msgLen = 0;
 204    DU_LOG("\nDEBUG  --> DU_APP : Processing DL data in duHdlEgtpDlData()");
 205
 206    if(!egtpMsg->msg)
 207    {
 208       DU_LOG("\nERROR  -->  DU_APP : Recevied Dl Data is NULLP in duHdlEgtpDlData()");
 209       return RFAILED;
 210    }
 211    ODU_GET_MSG_LEN(egtpMsg->msg, (MsgLen *)&msgLen);
 212    if(duBuildAndSendDlUserDataToRlc(msgLen, egtpMsg) != ROK)
 213    {
 214       DU_LOG("\nERROR  -->  DU_APP : Failed to build DL USer Data in duHdlEgtpDlData()");
 215       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, egtpMsg->msg, msgLen);
 216       return RFAILED;
 217    }
 218    return ROK;
 219 }
 220
 221 /******************************************************************
 222  *
 223  * @brief Builds and Sends DL CCCH Ind to MAC
 224  *
 225  * @details
 226  *
 227  *    Function : duBuildAndSendDlCcchInd
 228  *
 229  *    Functionality: Builds and sends DL CCCH Ind Msg to MAC
 230  *
 231  * @params[in] dlCcchMsg - uint8_t*
 232  * @return ROK     - success
 233  *         RFAILED - failure
 234  *
 235  * ****************************************************************/
 236 uint8_t duBuildAndSendDlCcchInd(uint16_t *cellId, uint16_t *crnti, \
 237       DlCcchMsgType msgType, uint16_t dlCcchMsgSize, uint8_t *dlCcchMsg)
 238 {
 239    uint8_t  ret                  = ROK;
 240    uint16_t idx2;
 241    DlCcchIndInfo *dlCcchIndInfo = NULLP;
 242    Pst pst;
 243
 244    DU_LOG("\nDEBUG   -->  DU APP : Building and Sending DL CCCH Ind to MAC");
 245
 246    DU_ALLOC_SHRABL_BUF(dlCcchIndInfo, sizeof(DlCcchIndInfo));
 247
 248    if(!dlCcchIndInfo)
 249    {
 250       DU_LOG("\nERROR  -->  DU APP : Memory alloc failed while building DL CCCH Ind");
 251       return RFAILED;
 252    }
 253
 254    dlCcchIndInfo->cellId = *cellId;
 255    dlCcchIndInfo->crnti = *crnti;
 256    dlCcchIndInfo->msgType = msgType;
 257    dlCcchIndInfo->dlCcchMsgLen = dlCcchMsgSize;
 258
 259    DU_ALLOC_SHRABL_BUF(dlCcchIndInfo->dlCcchMsg, dlCcchIndInfo->dlCcchMsgLen);
 260    if(!dlCcchIndInfo->dlCcchMsg)
 261    {
 262       DU_LOG("\nERROR  -->  DU APP : Memory alloc failed while building DL CCCH Ind");
 263       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, dlCcchIndInfo, sizeof(DlCcchIndInfo));
 264       return RFAILED;
 265    }
 266    for(idx2 = 0; idx2 < dlCcchIndInfo->dlCcchMsgLen; idx2++)
 267    {
 268       dlCcchIndInfo->dlCcchMsg[idx2] = dlCcchMsg[idx2];
 269    }
 270    DU_FREE(dlCcchMsg, dlCcchMsgSize);
 271
 272    /* Fill Pst */
 273    FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_DL_CCCH_IND);
 274    ret = (*packMacDlCcchIndOpts[pst.selector])(&pst, dlCcchIndInfo);
 275    if(ret != ROK)
 276    {
 277       DU_LOG("\nERROR  -->  DU_APP : Failure in sending DL CCCH to MAC");
 278       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, dlCcchIndInfo->dlCcchMsg,\
 279             dlCcchIndInfo->dlCcchMsgLen);
 280       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, dlCcchIndInfo, \
 281             sizeof(DlCcchIndInfo));
 282       ret = RFAILED;
 283    }
 284
 285    return ret;
 286
 287 }
 288
 289 /*******************************************************************
 290  *
 291  * @brief Build and Send DL RRC Message transfer to RLC
 292  *
 293  * @details
 294  *
 295  *    Function : duBuildAndSendDlRrcMsgToRlc
 296  *
 297  *    Functionality:
 298  *      Build and Send DL RRC Message transfer to RLC
 299  *
 300  * @params[in] Cell ID
 301  *             UE Index
 302  *             Logical Channgel ID
 303  *             RRC Message
 304  *             RRC Message Length
 305  * @return ROK     - success
 306  *         RFAILED - failure
 307  *
 308  * ****************************************************************/
 309 uint8_t duBuildAndSendDlRrcMsgToRlc(uint16_t cellId, RlcUeCfg ueCfg, F1DlRrcMsg *f1DlRrcMsg)
 310 {
 311    Pst     pst;
 312    uint8_t ret;
 313    uint8_t lcIdx;
 314    RlcDlRrcMsgInfo  *dlRrcMsgInfo = NULLP;
 315
 316    if(!f1DlRrcMsg)
 317    {
 318       DU_LOG("\nERROR  -->  DU APP : Received Dl RRC Msg is NULL at duBuildAndSendDlRrcMsgToRlc()");
 319       return RFAILED;
 320    }
 321
 322    DU_ALLOC_SHRABL_BUF(dlRrcMsgInfo, sizeof(RlcDlRrcMsgInfo));
 323    if(!dlRrcMsgInfo)
 324    {
 325       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for dlRrcMsgInfo in \
 326          duBuildAndSendDlRrcMsgToRlc");
 327       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, f1DlRrcMsg->rrcMsgPdu, f1DlRrcMsg->rrcMsgSize);
 328       return RFAILED;
 329    }
 330
 331    /* Filling up the RRC msg info */
 332    dlRrcMsgInfo->cellId = cellId;
 333    dlRrcMsgInfo->ueIdx = ueCfg.ueIdx;
 334    for(lcIdx = 0; lcIdx <= MAX_NUM_LC; lcIdx++)
 335    {
 336       if(ueCfg.rlcLcCfg[lcIdx].lcId == f1DlRrcMsg->srbId)
 337       {
 338          dlRrcMsgInfo->rbType = ueCfg.rlcLcCfg[lcIdx].rbType;
 339          dlRrcMsgInfo->rbId   = ueCfg.rlcLcCfg[lcIdx].rbId;
 340          dlRrcMsgInfo->lcType = ueCfg.rlcLcCfg[lcIdx].lcType;
 341          dlRrcMsgInfo->lcId   = ueCfg.rlcLcCfg[lcIdx].lcId;
 342          break;
 343       }
 344    }
 345    dlRrcMsgInfo->execDup = f1DlRrcMsg->execDup;
 346    dlRrcMsgInfo->deliveryStaRpt = f1DlRrcMsg->deliveryStatRpt;
 347    dlRrcMsgInfo->msgLen = f1DlRrcMsg->rrcMsgSize;
 348    dlRrcMsgInfo->rrcMsg = f1DlRrcMsg->rrcMsgPdu;
 349
 350    /* Filling post structure and sending msg */
 351    FILL_PST_DUAPP_TO_RLC(pst, RLC_DL_INST, EVENT_DL_RRC_MSG_TRANS_TO_RLC);
 352    DU_LOG("\nDEBUG   -->  DU_APP: Sending Dl RRC Msg to RLC \n");
 353    ret = (*duSendDlRrcMsgToRlcOpts[pst.selector])(&pst, dlRrcMsgInfo);
 354    if(ret != ROK)
 355    {
 356       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, f1DlRrcMsg->rrcMsgPdu, f1DlRrcMsg->rrcMsgSize);
 357       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, dlRrcMsgInfo, sizeof(RlcDlRrcMsgInfo));
 358       return RFAILED;
 359    }
 360
 361    return ROK;
 362 }
 363
 364
 365
 366 /******************************************************************
 367  *
 368  * @brief Process DL RRC Msg recevied from F1AP
 369  *
 370  * @details
 371  *
 372  *    Function : duProcDlRrcMsg
 373  *
 374  *    Functionality: Process DL RRC Msg recevied from F1AP
 375  *
 376  * @params[in] dlCcchMsg - uint8_t*
 377  * @return ROK     - success
 378  *         RFAILED - failure
 379  *
 380  * ****************************************************************/
 381
 382 uint8_t duProcDlRrcMsg(F1DlRrcMsg *dlRrcMsg)
 383 {
 384    uint8_t ueIdx, ret;
 385    uint16_t crnti, cellId, cellIdx;
 386    bool ueCcchCtxtFound = false;
 387    bool ueFound = false;
 388
 389    ret = ROK;
 390
 391    if(dlRrcMsg->srbId == SRB0_LCID) //RRC connection setup
 392    {
 393       for(ueIdx=0; ueIdx<duCb.numUe; ueIdx++)
 394       {
 395          if(dlRrcMsg->gnbDuUeF1apId == duCb.ueCcchCtxt[ueIdx].gnbDuUeF1apId)
 396          {
 397             ueCcchCtxtFound = true;
 398             crnti  = duCb.ueCcchCtxt[ueIdx].crnti;
 399             cellId = duCb.ueCcchCtxt[ueIdx].cellId;
 400             break;
 401          }
 402       }
 403    }
 404    if(ueCcchCtxtFound)
 405    {
 406       ret = duBuildAndSendDlCcchInd(&cellId, &crnti, RRC_SETUP, dlRrcMsg->rrcMsgSize, dlRrcMsg->rrcMsgPdu);
 407       if(ret == RFAILED)
 408       {
 409          DU_LOG("\nERROR  -->  DU APP : Failed to build DlCcch Ind at procDlRrcMsgTrans()");
 410       }
 411       else
 412       {
 413          if(duCb.actvCellLst[cellId-1]->numActvUes < MAX_NUM_UE)
 414          {
 415             ret = duCreateUeCb(&duCb.ueCcchCtxt[ueIdx], dlRrcMsg->gnbCuUeF1apId);
 416             if(ret == RFAILED)
 417             {
 418                DU_LOG("\nERROR  -->  DU APP : Failed to createUeCb for cellId [%d] at procDlRrcMsgTrans()", \
 419                      duCb.ueCcchCtxt[ueIdx].cellId);
 420             }
 421          }
 422          else
 423          {
 424             DU_LOG("\nERROR   -->  DU_APP: Max Active UEs has reached at procDlRrcMsgTrans()");
 425             ret = RFAILED;
 426          }
 427       }
 428    }
 429    else
 430    {
 431       for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
 432       {
 433          for(ueIdx = 0 ; ueIdx < MAX_NUM_UE; ueIdx++)
 434          {
 435             if((dlRrcMsg->gnbCuUeF1apId == duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId)
 436                   && (dlRrcMsg->gnbDuUeF1apId == duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId))
 437             {
 438                ueFound = true;
 439                ret = duBuildAndSendDlRrcMsgToRlc(duCb.actvCellLst[cellIdx]->cellId, \
 440                      duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg, dlRrcMsg);
 441                break;
 442             }
 443          }
 444          if(ueFound)
 445             break;
 446       }
 447       if(!ueFound)
 448          ret = RFAILED;
 449    }
 450    return ret;
 451 }
 452
 453 /******************************************************************
 454  *
 455  * @brief Generates GNB DU Ue F1AP ID
 456  *
 457  * @details
 458  *
 459  *    Function : genGnbDuUeF1apId
 460  *
 461  *    Functionality: Generates GNB DU Ue F1AP ID
 462  *
 463  * @params[in] void
 464  * @return gnbDuF1apId
 465  *
 466  * ****************************************************************/
 467 uint32_t genGnbDuUeF1apId()
 468 {
 469    static uint32_t gnbDuUeF1apId = 0;
 470
 471    return ++gnbDuUeF1apId;
 472 }
 473
 474 /******************************************************************
 475  *
 476  * @brief Processes UL CCCH Ind recvd from MAC
 477  *
 478  * @details
 479  *
 480  *    Function : duProcUlCcchInd
 481  *
 482  *    Functionality: Processes UL CCCH Ind recvd from MAC
 483  *
 484  * @params[in] UlCcchIndInfo *ulCcchIndInfo
 485  * @return ROK     - success
 486  *         RFAILED - failure
 487  *
 488  * ****************************************************************/
 489 uint8_t duProcUlCcchInd(UlCcchIndInfo *ulCcchIndInfo)
 490 {
 491
 492    uint8_t ret = ROK;
 493    uint32_t gnbDuUeF1apId = 0;
 494
 495    gnbDuUeF1apId = genGnbDuUeF1apId();
 496
 497    /* Store Ue mapping */
 498    duCb.ueCcchCtxt[duCb.numUe].gnbDuUeF1apId = gnbDuUeF1apId;
 499    duCb.ueCcchCtxt[duCb.numUe].crnti         = ulCcchIndInfo->crnti;
 500    duCb.ueCcchCtxt[duCb.numUe].cellId        = ulCcchIndInfo->cellId;
 501
 502    duCb.numUe++;
 503
 504    ret = (BuildAndSendInitialRrcMsgTransfer(gnbDuUeF1apId, ulCcchIndInfo->crnti, ulCcchIndInfo->ulCcchMsgLen,
 505             ulCcchIndInfo->ulCcchMsg));
 506    if(ret != ROK)
 507    {
 508       DU_LOG("\nERROR  -->  DU_APP : BuildAndSendInitialRrcMsgTransfer failed");
 509    }
 510
 511    DU_FREE_SHRABL_BUF(MAC_MEM_REGION, MAC_POOL, ulCcchIndInfo->ulCcchMsg, ulCcchIndInfo->ulCcchMsgLen);
 512    DU_FREE_SHRABL_BUF(MAC_MEM_REGION, MAC_POOL, ulCcchIndInfo, sizeof(UlCcchIndInfo));
 513
 514    return ret;
 515
 516 }
 517
 518 /******************************************************************
 519  *
 520  * @brief Fills Default UL LC Cfg
 521  *
 522  * @details
 523  *
 524  *    Function : fillDefaultUlLcCfg
 525  *
 526  *    Functionality: Fills Default UL LC Cfg
 527  *
 528  * @params[in]  UlLcCfg *ulLcCfg
 529  * @return void
 530  *****************************************************************/
 531 void fillDefaultUlLcCfg(UlLcCfg *ulLcCfg)
 532 {
 533    ulLcCfg->priority = LC_PRIORITY_1;
 534    ulLcCfg->lcGroup =  0;
 535    ulLcCfg->schReqId = 0;
 536    ulLcCfg->pbr = PBR_KBPS_INFINITY;
 537    ulLcCfg->bsd = BSD_MS_1000;
 538 }
 539
 540 /******************************************************************
 541  *
 542  * @brief Fills Initial DL Bandwidth Part
 543  *
 544  * @details
 545  *
 546  *    Function : fillDefaultInitDlBwp
 547  *
 548  *    Functionality: Fills Initial DL Bandwidth Part
 549  *
 550  * @params[in]  InitialDlBwp *initDlBwp
 551  * @return void
 552  *
 553  *****************************************************************/
 554 void fillDefaultInitDlBwp(InitialDlBwp *initDlBwp)
 555 {
 556    uint8_t idx = 0;
 557    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
 558    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
 559
 560
 561    if(initDlBwp)
 562    {
 563       /* Filling PDCCH Config */
 564       initDlBwp->pdcchPresent = TRUE;
 565       if(initDlBwp->pdcchPresent)
 566       {
 567          initDlBwp->pdcchCfg.numCRsetToAddMod = PDCCH_CTRL_RSRC_SET_ONE_ID;
 568          memset(initDlBwp->pdcchCfg.cRSetToAddModList, 0, MAX_NUM_CRSET);
 569          if(initDlBwp->pdcchCfg.numCRsetToAddMod <= MAX_NUM_CRSET)
 570          {
 571             initDlBwp->pdcchCfg.cRSetToAddModList[idx].cRSetId = \
 572                PDCCH_CTRL_RSRC_SET_ONE_ID;
 573             memset(initDlBwp->pdcchCfg.cRSetToAddModList[idx].freqDomainRsrc, 0,\
 574                FREQ_DOM_RSRC_SIZE);
 575             coreset0EndPrb = CORESET0_END_PRB;
 576             coreset1StartPrb = coreset0EndPrb +6;
 577             coreset1NumPrb = CORESET1_NUM_PRB;
 578             /* calculate the PRBs */
 579             freqDomRscAllocType0(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
 580             memcpy(initDlBwp->pdcchCfg.cRSetToAddModList[idx].freqDomainRsrc, freqDomainResource,
 581                FREQ_DOM_RSRC_SIZE);
 582
 583             initDlBwp->pdcchCfg.cRSetToAddModList[idx].duration = \
 584                PDCCH_CTRL_RSRC_SET_ONE_DURATION;
 585             initDlBwp->pdcchCfg.cRSetToAddModList[idx].cceRegMappingType = \
 586                CCE_REG_MAPPINGTYPE_PR_NONINTERLEAVED;
 587             initDlBwp->pdcchCfg.cRSetToAddModList[idx].precoderGranularity = \
 588                ALL_CONTIGUOUS_RBS;
 589             initDlBwp->pdcchCfg.cRSetToAddModList[idx].dmrsScramblingId = \
 590                SCRAMBLING_ID;
 591          }
 592          initDlBwp->pdcchCfg.numCRsetToRel = 0;
 593          /* Filling Serach Space */
 594          initDlBwp->pdcchCfg.numSearchSpcToAddMod = PDCCH_CTRL_RSRC_SET_ONE_ID;
 595          memset(initDlBwp->pdcchCfg.searchSpcToAddModList, 0, MAX_NUM_CRSET);
 596          if(initDlBwp->pdcchCfg.numSearchSpcToAddMod <= MAX_NUM_CRSET)
 597          {
 598             initDlBwp->pdcchCfg.searchSpcToAddModList[idx].searchSpaceId =\
 599                PDCCH_SRCH_SPC_TWO_ID;
 600             initDlBwp->pdcchCfg.searchSpcToAddModList[idx].cRSetId = \
 601                PDCCH_CTRL_RSRC_SET_ONE_ID;
 602             initDlBwp->pdcchCfg.searchSpcToAddModList[idx].\
 603                mSlotPeriodicityAndOffset = SLOTPERIODICITYANDOFFSET_PR_SL1;
 604             memset(initDlBwp->pdcchCfg.searchSpcToAddModList[idx].mSymbolsWithinSlot, 0,\
 605                MONITORING_SYMB_WITHIN_SLOT_SIZE);
 606             initDlBwp->pdcchCfg.searchSpcToAddModList[idx].mSymbolsWithinSlot[idx] =\
 607                PDCCH_SYMBOL_WITHIN_SLOT;
 608             initDlBwp->pdcchCfg.searchSpcToAddModList[idx].numCandidatesAggLevel1 =\
 609                AGGREGATIONLEVEL_N8;
 610             initDlBwp->pdcchCfg.searchSpcToAddModList[idx].numCandidatesAggLevel2 =\
 611                AGGREGATIONLEVEL_N8;
 612             initDlBwp->pdcchCfg.searchSpcToAddModList[idx].numCandidatesAggLevel4 =\
 613                AGGREGATIONLEVEL_N4;
 614             initDlBwp->pdcchCfg.searchSpcToAddModList[idx].numCandidatesAggLevel8 =\
 615                AGGREGATIONLEVEL_N2;
 616             initDlBwp->pdcchCfg.searchSpcToAddModList[idx].numCandidatesAggLevel16 =\
 617                AGGREGATIONLEVEL_N1;
 618             initDlBwp->pdcchCfg.searchSpcToAddModList[idx].searchSpaceType = \
 619                SEARCHSPACETYPE_PR_UE_SPECIFIC;
 620             initDlBwp->pdcchCfg.searchSpcToAddModList[idx].ueSpecificDciFormat =\
 621                PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
 622
 623             initDlBwp->pdcchCfg.numSearchSpcToRel = 0;
 624
 625          }
 626       }
 627       /* Filling PDSCH Config */
 628       initDlBwp->pdschPresent = TRUE;
 629       if(initDlBwp->pdschPresent)
 630       {
 631          initDlBwp->pdschCfg.dmrsDlCfgForPdschMapTypeA.addPos = ADDITIONALPOSITION_POS0;
 632          initDlBwp->pdschCfg.resourceAllocType = RESOURCEALLOCATION_TYPE1;
 633          initDlBwp->pdschCfg.numTimeDomRsrcAlloc = 1;
 634          initDlBwp->pdschCfg.timeDomRsrcAllociList[idx].mappingType = \
 635             MAPPING_TYPEA;
 636          initDlBwp->pdschCfg.timeDomRsrcAllociList[idx].startSymbol = PDSCH_START_SYMBOL;
 637          initDlBwp->pdschCfg.timeDomRsrcAllociList[idx].symbolLength = PDSCH_LENGTH_SYMBOL;
 638          initDlBwp->pdschCfg.timeDomRsrcAllociList[idx].startSymbolAndLength = \
 639             calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
 640          initDlBwp->pdschCfg.rbgSize = RBG_SIZE_CONFIG1;
 641          initDlBwp->pdschCfg.numCodeWordsSchByDci = CODEWORDS_SCHED_BY_DCI_N1;
 642          initDlBwp->pdschCfg.bundlingType = TYPE_STATIC_BUNDLING;
 643          initDlBwp->pdschCfg.bundlingInfo.StaticBundling.size = 0;
 644       }
 645    }
 646
 647 }
 648
 649 /******************************************************************
 650  *
 651  * @brief Fills Initial UL Bandwidth Part
 652  *
 653  * @details
 654  *
 655  *    Function : fillDefaultInitUlBwp
 656  *
 657  *    Functionality: Fills Initial UL Bandwidth Part
 658  *
 659  * @params[in]  InitialUlBwp *initUlBwp
 660  * @return void
 661  *
 662  *****************************************************************/
 663 void fillDefaultInitUlBwp(InitialUlBwp *initUlBwp)
 664 {
 665    uint8_t idx;
 666    if(initUlBwp)
 667    {
 668       initUlBwp->pucchPresent = FALSE;
 669
 670       /*Filling PUSCH Config */
 671       initUlBwp->puschPresent = TRUE;
 672       if(initUlBwp->puschPresent)
 673       {
 674          initUlBwp->puschCfg.dataScramblingId = SCRAMBLING_ID;
 675          initUlBwp->puschCfg.dmrsUlCfgForPuschMapTypeA.addPos = ADDITIONALPOSITION_POS0;
 676          initUlBwp->puschCfg.dmrsUlCfgForPuschMapTypeA.transPrecodDisabled. \
 677             scramblingId0 = SCRAMBLING_ID;
 678          initUlBwp->puschCfg.resourceAllocType = RESOURCEALLOCATION_TYPE1;
 679          initUlBwp->puschCfg.numTimeDomRsrcAlloc = 1;
 680          idx = 0;
 681          if(initUlBwp->puschCfg.numTimeDomRsrcAlloc <= MAX_NUM_UL_ALLOC)
 682          {
 683             initUlBwp->puschCfg.timeDomRsrcAllocList[idx].k2 = PUSCH_K2;
 684             initUlBwp->puschCfg.timeDomRsrcAllocList[idx].mappingType =\
 685                MAPPING_TYPEA;
 686             initUlBwp->puschCfg.timeDomRsrcAllocList[idx].startSymbol = PUSCH_START_SYMBOL;
 687             initUlBwp->puschCfg.timeDomRsrcAllocList[idx].symbolLength = PUSCH_LENGTH_SYMBOL;
 688             initUlBwp->puschCfg.timeDomRsrcAllocList[idx].startSymbolAndLength =\
 689                calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
 690          }
 691          initUlBwp->puschCfg.transformPrecoder = TRANSFORM_PRECODER_DISABLED;
 692       }
 693    }
 694    else
 695    {
 696       DU_LOG("\nERROR  -->  DU APP : Memory is NULL of InitalUlBwp");
 697    }
 698
 699 }
 700 /******************************************************************
 701  *
 702  * @brief Fills SpCell Group Info
 703  *
 704  * @details
 705  *
 706  *    Function : fillDefaultSpCellGrpInfo
 707  *
 708  *    Functionality: Fills Sp Cell Group Info
 709  *
 710  * @params[in]  SpCellCfg *spCell
 711  * @return void
 712  *
 713  *****************************************************************/
 714 void fillDefaultSpCellGrpInfo(SpCellCfg *spCell)
 715 {
 716    if(spCell)
 717    {
 718       spCell->servCellIdx = SERV_CELL_IDX;
 719       /* Filling Initial Dl Bwp */
 720       fillDefaultInitDlBwp(&spCell->servCellCfg.initDlBwp);
 721
 722       spCell->servCellCfg.numDlBwpToAdd    = 0;
 723       spCell->servCellCfg.firstActvDlBwpId = ACTIVE_DL_BWP_ID;
 724       spCell->servCellCfg.defaultDlBwpId   = ACTIVE_DL_BWP_ID;
 725       spCell->servCellCfg.bwpInactivityTmr = NULLP;
 726       spCell->servCellCfg.pdschServCellCfg.maxMimoLayers = NULLP;
 727       spCell->servCellCfg.pdschServCellCfg.maxCodeBlkGrpPerTb = NULLP;
 728       spCell->servCellCfg.pdschServCellCfg.codeBlkGrpFlushInd = NULLP;
 729       spCell->servCellCfg.pdschServCellCfg.xOverhead = NULLP;
 730       spCell->servCellCfg.pdschServCellCfg.numHarqProcForPdsch =\
 731          NUM_HARQ_PROC_FOR_PDSCH_N_16;
 732       /* Filling Initial UL Bwp*/
 733       fillDefaultInitUlBwp(&spCell->servCellCfg.initUlBwp);
 734       spCell->servCellCfg.numUlBwpToAdd     = 0;
 735       spCell->servCellCfg.firstActvUlBwpId  = ACTIVE_DL_BWP_ID;
 736    }
 737    else
 738    {
 739       DU_LOG("\nERROR  -->  DU APP : Memory is NULL for SpCellGrp");
 740    }
 741 }
 742
 743 /******************************************************************
 744  *
 745  * @brief Fills Physical Cell Group Info
 746  *
 747  * @details
 748  *
 749  *    Function : fillDefaultPhyCellGrpInfo
 750  *
 751  *    Functionality: Fills Physical Cell Group Info
 752  *
 753  * @params[in]  PhyCellGrpCfg *cellGrp
 754  * @return void
 755  *
 756  *****************************************************************/
 757 void fillDefaultPhyCellGrpInfo(PhyCellGrpCfg *cellGrp)
 758 {
 759    if(cellGrp)
 760    {
 761       cellGrp->pdschHarqAckCodebook = PDSCH_HARQ_ACK_CODEBOOK_DYNAMIC;
 762       cellGrp->pNrFr1 = P_NR_FR1;
 763    }
 764    else
 765    {
 766       DU_LOG("\nERROR  -->  DU APP : Memory is NULL for Physical Cell Group");
 767    }
 768 }
 769
 770 /******************************************************************
 771  *
 772  * @brief Fills Mac Cell Group Info
 773  *
 774  * @details
 775  *
 776  *    Function : fillDefaultMacCellGrpInfo
 777  *
 778  *    Functionality: Fills Mac Cell Group Info
 779  *
 780  * @params[in]  MacCellGrpCfg *cellGrp
 781  * @return void
 782  *
 783  *****************************************************************/
 784 void fillDefaultMacCellGrpInfo(MacCellGrpCfg *cellGrp)
 785 {
 786    uint8_t idx;
 787
 788    if(cellGrp)
 789    {
 790       /* Filling Scheduling Request Config */
 791       cellGrp->schReqCfg.addModListCount = 1;
 792       if(cellGrp->schReqCfg.addModListCount <= MAX_NUM_SR_CFG_PER_CELL_GRP)
 793       {
 794          for(idx = 0; idx < cellGrp->schReqCfg.addModListCount; idx++)
 795          {
 796             cellGrp->schReqCfg.addModList[idx].schedReqId    = SCH_REQ_ID;
 797             cellGrp->schReqCfg.addModList[idx].srProhibitTmr = SR_PROHIBIT_MS_32;
 798             cellGrp->schReqCfg.addModList[idx].srTransMax    = SR_TRANS_MAX_N_16;
 799          }
 800       }
 801       cellGrp->schReqCfg.relListCount = 0;
 802
 803       /* Filling Tag config */
 804       cellGrp->tagCfg.addModListCount = 1;
 805       if(cellGrp->tagCfg.addModListCount <= MAC_NUM_TAGS)
 806       {
 807          for(idx = 0; idx < cellGrp->tagCfg.addModListCount; idx++)
 808          {
 809             cellGrp->tagCfg.addModList[idx].tagId = TAG_ID;
 810             cellGrp->tagCfg.addModList[idx].timeAlignTimer = TIME_ALIGNMENT_TIMER_INFINITY;
 811          }
 812       }
 813       cellGrp->tagCfg.relListCount = 0;
 814
 815       /* Filling BSR config */
 816       cellGrp->bsrTmrCfg.periodicTimer = BSR_PERIODIC_TIMER_SF_10;
 817       cellGrp->bsrTmrCfg.retxTimer = BSR_RETX_TIMER_SF_320;
 818       cellGrp->bsrTmrCfg.srDelayTimer = BSR_SR_DELAY_TMR_2560;
 819
 820       /* Filling PHR config */
 821       cellGrp->phrCfgSetupPres = true;
 822       cellGrp->phrCfg.periodicTimer = PHR_PERIODIC_TIMER_INFINITY;
 823       cellGrp->phrCfg.prohibitTimer = PHR_PROHIBIT_TIMER_SF_0;
 824       cellGrp->phrCfg.txPowerFactor = PHR_TX_PWR_FACTOR_CHANGE_INFINITY;
 825       cellGrp->phrCfg.multiplePHR   = false;
 826       cellGrp->phrCfg.dummy         = false;
 827       cellGrp->phrCfg.phrType2OtherCell = false;
 828       cellGrp->phrCfg.phrOtherCG = PHR_MODE_OTHER_CG_REAL;
 829
 830    }
 831    else
 832    {
 833       DU_LOG("\nERROR  -->  DU APP : Memory is NULL for Master Cell Group");
 834    }
 835 }
 836
 837 /*******************************************************************
 838  *
 839  * @brief Fills default modulation info for a UE
 840  *
 841  * @details
 842  *
 843  *    Function : fillDefaultModulation
 844  *
 845  *    Functionality: Fills default modulation info for a UE
 846  *
 847  * @params[in] Pointer to MAC UE configuration
 848  * @return ROK     - success
 849  *         RFAILED - failure
 850  *
 851  * ****************************************************************/
 852 void fillDefaultModulation(MacUeCfg *ueCfg)
 853 {
 854    ueCfg->dlModInfo.modOrder = MOD_ORDER_QPSK;
 855    ueCfg->dlModInfo.mcsIndex = SIB1_MCS;
 856    ueCfg->dlModInfo.mcsTable = MCS_TABLE_QAM64; /* Spec 38.214-Table 5.1.3.1-1 */
 857
 858    ueCfg->ulModInfo.modOrder = MOD_ORDER_QPSK;
 859    ueCfg->ulModInfo.mcsIndex = SIB1_MCS;
 860    ueCfg->ulModInfo.mcsTable = MCS_TABLE_QAM64; /* Spec 38.214-Table 5.1.3.1-1 */
 861 }
 862
 863 /******************************************************************
 864  *
 865  * @brief Function to fill Mac Lc Cfg for SRB1
 866  *
 867  * @details
 868  *
 869  *    Function : fillMacSrb1LcCfg
 870  *
 871  *    Functionality: Function to fill Mac Lc cfg for SRB1
 872  *
 873  * @params[in]  LcCfg *lcCfg, LcCfg *ueSetReqDb
 874  * @return void
 875  *****************************************************************/
 876
 877 void fillMacSrb1LcCfg(LcCfg *macLcCfg)
 878 {
 879    macLcCfg->lcId   = SRB1_LCID;
 880    macLcCfg->configType = CONFIG_ADD;
 881    macLcCfg->drbQos = NULLP;
 882    macLcCfg->snssai = NULLP;
 883    macLcCfg->ulLcCfgPres = true;
 884    fillDefaultUlLcCfg(&macLcCfg->ulLcCfg);
 885 }
 886
 887 /******************************************************************
 888  *
 889  * @brief Function to fill the Lc cfg from ueSetupReqDb
 890  *
 891  * @details
 892  *
 893  *    Function : fillMacLcCfgToAddMod
 894  *
 895  *    Functionality: Function to fill the Lc cfg from ueSetupReqDb
 896  *
 897  * @params[in]  LcCfg *lcCfg, LcCfg *ueSetReqDb
 898  * @return ROK/RFAILED
 899  *
 900  *****************************************************************/
 901
 902 uint8_t fillMacLcCfgToAddMod(LcCfg *lcCfg, LcCfg *ueSetReqDb)
 903 {
 904    uint8_t ret = ROK;
 905    lcCfg->lcId = ueSetReqDb->lcId;
 906    lcCfg->configType = ueSetReqDb->configType;
 907    /* Filling DRBQOS */
 908    if(ueSetReqDb->drbQos)
 909    {
 910       if(!lcCfg->drbQos)
 911       {
 912          DU_ALLOC_SHRABL_BUF(lcCfg->drbQos, sizeof(DrbQosInfo));
 913          if(!lcCfg->drbQos)
 914          {
 915             DU_LOG("\nERROR  -->  DU APP : Memory Alloc failed at drQos at fillMacLcCfgToAddMod()");
 916             return RFAILED;
 917          }
 918       }
 919       if(ret == ROK)
 920       {
 921          memcpy(lcCfg->drbQos, ueSetReqDb->drbQos, sizeof(DrbQosInfo));
 922       }
 923    }
 924    else
 925    {
 926       lcCfg->drbQos = NULLP;
 927    }
 928
 929    if(ret == ROK)
 930    {
 931       if(ueSetReqDb->snssai)
 932       {
 933          if(!lcCfg->snssai)
 934          {
 935             DU_ALLOC_SHRABL_BUF(lcCfg->snssai, sizeof(Snssai));
 936             if(!lcCfg->snssai)
 937             {
 938                DU_LOG("\nERROR  -->  DU APP : Memory Alloc failed at snnsai at fillMacLcCfgToAddMod()");
 939                ret = RFAILED;
 940             }
 941          }
 942          if(ret == ROK)
 943          {
 944             /* Filling SNSSAI */
 945             memcpy(lcCfg->snssai, ueSetReqDb->snssai, sizeof(Snssai));
 946          }
 947          else
 948          {
 949             lcCfg->snssai = NULLP;
 950             if(lcCfg->drbQos)
 951             {
 952                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
 953                lcCfg->drbQos = NULLP;
 954             }
 955             return ret;
 956          }
 957       }
 958       else
 959          lcCfg->snssai = NULLP;
 960    }
 961    lcCfg->ulLcCfgPres = ueSetReqDb->ulLcCfgPres;
 962    memcpy(&lcCfg->ulLcCfg, &ueSetReqDb->ulLcCfg, sizeof(UlLcCfg));
 963    memcpy(&lcCfg->dlLcCfg, &ueSetReqDb->dlLcCfg, sizeof(DlLcCfg));
 964    return ret;
 965 }
 966
 967 /******************************************************************
 968  *
 969  * @brief Function to copy the Bit rate from ueSetupReqDb
 970  *
 971  * @details
 972  *
 973  *    Function : fillAmbr
 974  *
 975  *    Functionality: Function to copy bit Rate from ueSetupReqDb
 976  *
 977  * @params[in]  AmbrCfg **macAmbr, AmbrCfg  *ueDbAmbr
 978  * @return ROK/RFAILED
 979  *
 980  *****************************************************************/
 981
 982 uint8_t fillAmbr(AmbrCfg **macAmbr, AmbrCfg *ueDbAmbr)
 983 {
 984    if(ueDbAmbr)
 985    {
 986       if(*macAmbr == NULLP)
 987       {
 988          DU_ALLOC_SHRABL_BUF(*macAmbr, sizeof(AmbrCfg));
 989          if(*macAmbr == NULLP)
 990          {
 991             DU_LOG("\nERROR  -->  DU APP : Memory Alloc Failed at fillAmbr()");
 992             return RFAILED;
 993          }
 994       }
 995       memset(*macAmbr, 0, sizeof(AmbrCfg));
 996       (*macAmbr)->ulBr = ueDbAmbr->ulBr;
 997    }
 998    else
 999    {
1000       *macAmbr = NULLP;
1001    }
1002    return ROK;
1003 }
1004
1005 /******************************************************************
1006  *
1007  * @brief Builds and Send UE ReConfig Request to MAC
1008  *
1009  * @details
1010  *
1011  *    Function : sendUeReCfgReqToMac
1012  *
1013  *    Functionality: Builds and Send UE ReConfig Request to MAC
1014  *
1015  * @Params[in]  MacUeCfg pointer
1016  * @return ROK     - success
1017  *         RFAILED - failure
1018  *
1019  * ****************************************************************/
1020
1021 uint8_t sendUeReCfgReqToMac(MacUeCfg *macUeCfg)
1022 {
1023    uint8_t ret = ROK;
1024    Pst pst;
1025
1026    /* Fill Pst */
1027    FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_UE_RECONFIG_REQ);
1028
1029    if(macUeCfg)
1030    {
1031       /* Processing one Ue at a time to MAC */
1032       DU_LOG("\nDEBUG   -->  DU_APP: Sending Ue Reconfig Request to MAC");
1033       ret = (*packMacUeReconfigReqOpts[pst.selector])(&pst, macUeCfg);
1034       if(ret == RFAILED)
1035       {
1036          DU_LOG("\nERROR  -->  DU APP : Failed to send Reconfig Request to MAC at sendUeReCfgReqToMac()");
1037          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, macUeCfg, sizeof(MacUeCfg));
1038       }
1039    }
1040    else
1041    {
1042       DU_LOG("\nERROR  -->  DU_APP: Received macUeCfg is NULLP at sendUeReCfgReqToMac()");
1043       ret = RFAILED;
1044    }
1045    return ret;
1046 }
1047
1048 /******************************************************************
1049  *
1050  * @brief Function to return Drb LcId
1051  *
1052  * @details
1053  *
1054  *    Function : getDrbLcId
1055  *
1056  *    Functionality: Function to return Drb LcId
1057  *
1058  * Returns: lcId - SUCCESS
1059  *         RFAILED - FAILURE
1060  *****************************************************************/
1061
1062 uint8_t getDrbLcId(uint32_t *drbBitMap)
1063 {
1064    uint8_t bitMask = 1, bitPos = 0;
1065    bitPos = MIN_DRB_LCID;
1066
1067    while(bitPos <= MAX_DRB_LCID)
1068    {
1069       if((*drbBitMap & (bitMask << bitPos)) == 0)
1070       {
1071          *drbBitMap = ((bitMask << bitPos)| *drbBitMap);
1072          return bitPos;
1073       }
1074       else
1075       {
1076          bitPos++;
1077       }
1078    }
1079    DU_LOG("\nERROR   -->  DU_APP: Max LC Reached in getDrbLcId()");
1080    return RFAILED;
1081 }
1082
1083 /******************************************************************
1084  *
1085  * @brief Fills MacUeCfg structure
1086  *
1087  * @details
1088  *
1089  *    Function : fillMacUeCfg
1090  *
1091  *    Functionality: Fills MacUeCfg
1092  *
1093  * @params[in]  cellId, ueIdx, crnti,
1094  *              DuUeCfg  pointer,
1095  *              MacUeCfg pointer
1096  * @return ROK/RFAILED
1097  *
1098  *****************************************************************/
1099 uint8_t fillMacUeCfg(uint16_t cellId, uint8_t ueIdx, uint16_t crnti, \
1100    DuUeCfg *ueCfgDb, MacUeCfg *macUeCfg)
1101 {
1102    uint8_t ret, dbIdx, lcIdx, cellIdx;
1103    bool lcIdFound = false;
1104    MacUeCfg *duMacDb = NULLP;
1105
1106    ret =ROK;
1107
1108    if(!ueCfgDb)
1109    {
1110       macUeCfg->cellId       = cellId;
1111       macUeCfg->ueIdx        = ueIdx;
1112       macUeCfg->crnti        = crnti;
1113       fillDefaultMacCellGrpInfo(&macUeCfg->macCellGrpCfg);
1114       fillDefaultPhyCellGrpInfo(&macUeCfg->phyCellGrpCfg);
1115       fillDefaultSpCellGrpInfo(&macUeCfg->spCellCfg);
1116       macUeCfg->ambrCfg = NULLP;
1117       fillMacSrb1LcCfg(&macUeCfg->lcCfgList[0]);
1118       fillDefaultModulation(macUeCfg);
1119       macUeCfg->numLcs++;
1120    }
1121    else
1122    {
1123       /* Fetching MacDb from DuUeCb */
1124       GET_CELL_IDX(cellId, cellIdx);
1125       duMacDb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].macUeCfg;
1126       /* Fetching MaUeCfg List for ADD/MOD/DEL */
1127       macUeCfg->cellId       = cellId;
1128       macUeCfg->ueIdx        = ueIdx;
1129       macUeCfg->crnti        = crnti;
1130       ret = procUeReCfgCellInfo(macUeCfg, ueCfgDb->cellGrpCfg);
1131       if(ret == ROK)
1132       {
1133          if(macUeCfg->spCellCfg.servCellCfg.initDlBwp.pdschPresent)
1134          {
1135             fillStartSymbolAndLen(macUeCfg->spCellCfg.servCellCfg.initDlBwp.pdschCfg.numTimeDomRsrcAlloc,\
1136                &macUeCfg->spCellCfg.servCellCfg.initDlBwp.pdschCfg, NULL);
1137          }
1138          if(macUeCfg->spCellCfg.servCellCfg.initUlBwp.puschPresent)
1139          {
1140             fillStartSymbolAndLen(macUeCfg->spCellCfg.servCellCfg.initUlBwp.puschCfg.numTimeDomRsrcAlloc,\
1141                NULL, &macUeCfg->spCellCfg.servCellCfg.initUlBwp.puschCfg);
1142          }
1143          ret = fillAmbr(&macUeCfg->ambrCfg, ueCfgDb->ambrCfg);
1144
1145          duFillModulationDetails(macUeCfg, duMacDb, ueCfgDb->ueNrCapability);
1146       }
1147
1148       /* Filling LC Context */
1149       for(dbIdx = 0; (dbIdx < ueCfgDb->numMacLcs && ret == ROK); dbIdx++)
1150       {
1151          if(!ueCfgDb->macLcCfg[dbIdx].ulLcCfgPres)
1152          {
1153             /* Filling default UL LC config in MAC if not present */
1154             ueCfgDb->macLcCfg[dbIdx].ulLcCfgPres = true;
1155             fillDefaultUlLcCfg(&ueCfgDb->macLcCfg[dbIdx].ulLcCfg);
1156          }
1157          for(lcIdx = 0; lcIdx < duMacDb->numLcs; lcIdx++)
1158          {
1159             if(ueCfgDb->macLcCfg[dbIdx].lcId == duMacDb->lcCfgList[lcIdx].lcId)
1160             {
1161                lcIdFound = true;
1162                if((ueCfgDb->macLcCfg[dbIdx].configType == CONFIG_UNKNOWN) ||
1163                      (ueCfgDb->macLcCfg[dbIdx].configType == CONFIG_MOD))
1164                {
1165                   ueCfgDb->macLcCfg[dbIdx].configType = CONFIG_MOD;
1166                   ret = fillMacLcCfgToAddMod(&macUeCfg->lcCfgList[dbIdx], &ueCfgDb->macLcCfg[dbIdx]);
1167                }
1168             }
1169             else
1170                lcIdFound = false;
1171          }
1172          if(!lcIdFound)
1173          {
1174             /* ADD/DEL CONFIG */
1175             ret = fillMacLcCfgToAddMod(&macUeCfg->lcCfgList[dbIdx], &ueCfgDb->macLcCfg[dbIdx]);
1176          }
1177          if(ret == ROK)
1178          {
1179             macUeCfg->numLcs++;
1180          }
1181          else
1182          {
1183             DU_LOG("\nERROR  -->  DU APP : Failed to add Lc at Idx %d in fillMacUeCfg()", dbIdx);
1184             break;
1185          }
1186       }/*End of Outer FOR loop */
1187    }
1188    return ret;
1189 }
1190
1191 /******************************************************************
1192  *
1193  * @brief Fills Rlc AM Information
1194  *
1195  * @details
1196  *
1197  *    Function : fillDefaultAmInfo
1198  *
1199  *    Functionality: Fills Rlc AM Information
1200  *
1201  * @params[in]  AmBearerCfg *amCfg
1202  * @return void
1203  *
1204  *****************************************************************/
1205 void fillDefaultAmInfo(AmBearerCfg *amCfg)
1206 {
1207    /* DL AM */
1208    amCfg->dlAmCfg.snLenDl     = AM_SIZE_12;
1209    amCfg->dlAmCfg.pollRetxTmr = T_POLL_RETRANSMIT_VAL;
1210    amCfg->dlAmCfg.pollPdu     = POLL_PDU_VAL;
1211    amCfg->dlAmCfg.pollByte    = POLL_BYTE_VAL;
1212    amCfg->dlAmCfg.maxRetxTh   = MAX_RETX_THRESHOLD_VAL;
1213
1214    /* UL AM */
1215    amCfg->ulAmCfg.snLenUl     = AM_SIZE_12;
1216    amCfg->ulAmCfg.reAssemTmr  = T_REASSEMBLY_VAL;
1217    amCfg->ulAmCfg.statProhTmr = T_STATUS_PROHIBHIT_VAL;
1218 }
1219
1220 /******************************************************************
1221  *
1222  * @brief Fills RLC UM Bi Directional Information
1223  *
1224  * @details
1225  *
1226  *    Function : fillDefaultUmBiInfo
1227  *
1228  *    Functionality: Fills RLC UM Bi Directional Information
1229  *
1230  * @params[in]  UmBiDirBearerCfg *umBiDirCfg
1231  * @return void
1232  *
1233  *****************************************************************/
1234 void fillDefaultUmBiInfo(UmBiDirBearerCfg *umBiDirCfg)
1235 {
1236    /* UL UM BI DIR INFO */
1237    umBiDirCfg->ulUmCfg.snLenUlUm = UM_SIZE_12;
1238    umBiDirCfg->ulUmCfg.reAssemTmr = T_REASSEMBLY_VAL;
1239
1240    /* DL UM BI DIR INFO */
1241    umBiDirCfg->dlUmCfg.snLenDlUm  = UM_SIZE_12;
1242 }
1243
1244 /******************************************************************
1245  *
1246  * @brief Fills RLC UM Uni Directional UL Information
1247  *
1248  * @details
1249  *
1250  *    Function : fillDefaultUmUlInfo
1251  *
1252  *    Functionality: Fills RLC UM Uni Directional Info
1253  *
1254  * @params[in]  UmUniDirUlBearerCfg *UmUlCfg
1255  * @return void
1256  *
1257  *****************************************************************/
1258 void fillDefaultUmUlInfo(UmUniDirUlBearerCfg *UmUlCfg)
1259 {
1260    UmUlCfg->ulUmCfg.snLenUlUm = UM_SIZE_12;
1261    UmUlCfg->ulUmCfg.reAssemTmr = T_REASSEMBLY_VAL;
1262 }
1263
1264 /******************************************************************
1265  *
1266  * @brief Fills RLC UM Uni Directional DL Information
1267  *
1268  * @details
1269  *
1270  *    Function : fillDefaultUmDlInfo
1271  *
1272  *    Functionality: Fills RLC UM Uni Directional DL Info
1273  *
1274  * @params[in]  UmUniDirDlBearerCfg *UmDlCfg
1275  * @return void
1276  *
1277  *****************************************************************/
1278 void fillDefaultUmDlInfo(UmUniDirDlBearerCfg *UmDlCfg)
1279 {
1280    UmDlCfg->dlUmCfg.snLenDlUm  = UM_SIZE_12;
1281 }
1282
1283 /******************************************************************
1284  *
1285  * @brief Builds Rlc Mode Default Configuration
1286  *
1287  * @details
1288  *
1289  *    Function : fillDefaultRlcModeCfg
1290  *
1291  *    Functionality: Builds Rlc Mode Default Configuration
1292  *
1293  * @params[in]  rlcMode, RlcBearerCfg *lcCfg
1294  * @return ROK/RFAILED
1295  *
1296  *****************************************************************/
1297
1298 uint8_t fillDefaultRlcModeCfg(uint8_t rlcMode, RlcBearerCfg *lcCfg)
1299 {
1300
1301    if(lcCfg)
1302    {
1303       switch(rlcMode)
1304       {
1305          case RLC_AM :
1306             {
1307                if(!lcCfg->u.amCfg)
1308                {
1309                  DU_ALLOC_SHRABL_BUF(lcCfg->u.amCfg, sizeof(AmBearerCfg));
1310                  if(lcCfg->u.amCfg)
1311                     fillDefaultAmInfo(lcCfg->u.amCfg);
1312                  else
1313                  {
1314                     DU_LOG("\n ERROR  -->  DU APP : Memory Alloc failed at AmCfg at fillDefaultRlcModeCfg()");
1315                     return RFAILED;
1316                  }
1317                }
1318                break;
1319             }
1320          case RLC_UM_BI_DIRECTIONAL :
1321             {
1322                if(!lcCfg->u.umBiDirCfg)
1323                {
1324                  DU_ALLOC_SHRABL_BUF(lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
1325                  if(lcCfg->u.umBiDirCfg)
1326                     fillDefaultUmBiInfo(lcCfg->u.umBiDirCfg);
1327                  else
1328                  {
1329                     DU_LOG("\n ERROR  -->  DU APP : Memory Alloc failed at UmBiDirCfg at fillDefaultRlcModeCfg()");
1330                     return RFAILED;
1331                  }
1332                }
1333                break;
1334             }
1335          case RLC_UM_UNI_DIRECTIONAL_UL :
1336             {
1337                if(!lcCfg->u.umUniDirUlCfg)
1338                {
1339                   DU_ALLOC_SHRABL_BUF(lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
1340                   if(lcCfg->u.umUniDirUlCfg)
1341                     fillDefaultUmUlInfo(lcCfg->u.umUniDirUlCfg);
1342                   else
1343                   {
1344                      DU_LOG("\n ERROR  -->  DU APP : Memory Alloc failed at UmUniDirUlCfg at fillDefaultRlcModeCfg()");
1345                      return RFAILED;
1346                   }
1347                }
1348                break;
1349             }
1350          case RLC_UM_UNI_DIRECTIONAL_DL :
1351             {
1352                if(!lcCfg->u.umUniDirDlCfg)
1353                {
1354                   DU_ALLOC_SHRABL_BUF(lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
1355                   if(lcCfg->u.umUniDirDlCfg)
1356                    fillDefaultUmDlInfo(lcCfg->u.umUniDirDlCfg);
1357                   else
1358                   {
1359                      DU_LOG("\n ERROR  -->  DU APP : Memory Alloc failed at UmUniDirDlCfg at fillDefaultRlcModeCfg()");
1360                      return RFAILED;
1361                   }
1362                }
1363                break;
1364             }
1365          default:
1366             DU_LOG("\nERROR  -->  DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
1367             return RFAILED;
1368       }
1369
1370    }
1371    else
1372    {
1373       DU_LOG("\nERROR  -->  DUAPP: Received LC Config is NULL");
1374       return RFAILED;
1375    }
1376    return ROK;
1377 }
1378
1379 /*******************************************************************
1380  *
1381  * @brief Function to fill Rlc Lc Cfg for SRB1
1382  *
1383  * @details
1384  *
1385  *    Function : fillRlcSrb1LcCfg
1386  *
1387  *    Functionality:
1388  *     Function to fill Rlc Lc Cfg for SRB1
1389  *
1390  *  @params[in]     Pointer to RlcBearerCfg
1391  *  @return ROK/RFAILED
1392  *
1393  *****************************************************************/
1394
1395 uint8_t fillRlcSrb1LcCfg(RlcBearerCfg *rlcLcCfg)
1396 {
1397    uint8_t ret = ROK;
1398
1399    rlcLcCfg->rbId   = SRB1_LCID;
1400    rlcLcCfg->rbType = RB_TYPE_SRB;
1401    rlcLcCfg->lcId   = SRB1_LCID;
1402    rlcLcCfg->lcType = LCH_DCCH;
1403    rlcLcCfg->rlcMode = RLC_AM;
1404    rlcLcCfg->configType = CONFIG_ADD;
1405    ret = fillDefaultRlcModeCfg(rlcLcCfg->rlcMode, rlcLcCfg);
1406    return ret;
1407 }
1408
1409 /*******************************************************************
1410  *
1411  * @brief Processes UE ReConfig Req to RLC UL
1412  *
1413  * @details
1414  *
1415  *    Function : sendUeReCfgReqToRlc
1416  *
1417  *    Functionality:
1418  *     Processes UE Reconfig Req to RLC UL
1419  *
1420  *  @params[in]     Pointer to RlcUeCfg
1421  *  @return ROK     - success
1422  *          RFAILED - failure
1423  *
1424  *****************************************************************/
1425
1426 uint8_t sendUeReCfgReqToRlc(RlcUeCfg *rlcUeCfg)
1427 {
1428    uint8_t ret;
1429    Pst pst;
1430
1431    FILL_PST_DUAPP_TO_RLC(pst, RLC_UL_INST, EVENT_RLC_UE_RECONFIG_REQ);
1432    if(rlcUeCfg)
1433    {
1434       /* Processing one Ue at a time to RLC */
1435       DU_LOG("\nDEBUG   -->  DU_APP: Sending Ue Reconfig Request to RLC UL");
1436       ret = (*packRlcUeReconfigReqOpts[pst.selector])(&pst, rlcUeCfg);
1437       if(ret == RFAILED)
1438       {
1439          DU_LOG("\nERROR  -->  DU_APP : Failed to send Ue Reconfig Req to RLC at sendUeReCfgReqToRlc()");
1440          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, rlcUeCfg, sizeof(RlcUeCfg));
1441       }
1442    }
1443    else
1444    {
1445       DU_LOG("\nERROR  -->   DU_APP: Received RlcUeCfg is NULL at sendUeReCfgReqToRlc()");
1446       ret = RFAILED;
1447    }
1448    return ret;
1449 }
1450
1451 /******************************************************************
1452  *
1453  * @brief Fills RlcBearerCfg structure
1454  *
1455  * @details
1456  *
1457  *    Function : fillRlcUeCfg
1458  *
1459  *    Functionality: Fills Rlc Bearer Cfg
1460  *
1461  *
1462  *****************************************************************/
1463 uint8_t fillRlcUeCfg(uint16_t cellId, uint8_t ueIdx,\
1464    DuUeCfg *ueCfgDb, RlcUeCfg *rlcUeCfg)
1465 {
1466    uint8_t ret, dbIdx, lcIdx, cellIdx;
1467    bool lcIdFound = false;
1468    RlcUeCfg *duRlcDb = NULLP;
1469
1470    ret = ROK;
1471    if(!ueCfgDb)
1472    {
1473       /* Initial RB being Added */
1474       rlcUeCfg->cellId       = cellId;
1475       rlcUeCfg->ueIdx        = ueIdx;
1476       ret = fillRlcSrb1LcCfg(&rlcUeCfg->rlcLcCfg[0]);
1477       if(ret == ROK)
1478          rlcUeCfg->numLcs++;
1479       else
1480          memset(rlcUeCfg, 0, sizeof(RlcUeCfg));
1481    }
1482    else
1483    {
1484       /* Fetch RlcDb from DuUeCb */
1485       GET_CELL_IDX(cellId, cellIdx);
1486       duRlcDb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].rlcUeCfg;
1487       /*Filling RlcUeCfg */
1488       rlcUeCfg->cellId       = cellId;
1489       rlcUeCfg->ueIdx        = ueIdx;
1490       for(dbIdx = 0; (dbIdx < ueCfgDb->numRlcLcs && ret == ROK); dbIdx++)
1491       {
1492          ret = fillDefaultRlcModeCfg(ueCfgDb->rlcLcCfg[dbIdx].rlcMode, &ueCfgDb->rlcLcCfg[dbIdx]);
1493          if(ret == RFAILED)
1494          {
1495             DU_LOG("\n ERROR  -->  DU APP : Failed to fill Rlc Mode at fillRlcUeCfg()");
1496             memset(rlcUeCfg, 0, sizeof(RlcUeCfg));
1497             return ret;
1498          }
1499          /* Fill Rlc Ue Cfg List for ADD/MOD/DEL */
1500          for(lcIdx = 0; lcIdx < duRlcDb->numLcs; lcIdx++)
1501          {
1502             if(ueCfgDb->rlcLcCfg[dbIdx].lcId == duRlcDb->rlcLcCfg[lcIdx].lcId)
1503             {
1504                lcIdFound = true;
1505                if((ueCfgDb->rlcLcCfg[dbIdx].configType == CONFIG_UNKNOWN)||
1506                      (ueCfgDb->rlcLcCfg[dbIdx].configType == CONFIG_MOD))
1507                {
1508                   /* MOD */
1509                   ueCfgDb->rlcLcCfg[dbIdx].configType = CONFIG_MOD; /* update Db for MOD type */
1510                   memcpy(&rlcUeCfg->rlcLcCfg[dbIdx], &ueCfgDb->rlcLcCfg[dbIdx], sizeof(RlcBearerCfg));
1511                }
1512             }
1513             else
1514                lcIdFound = false;
1515          }
1516          if(!lcIdFound)
1517          {
1518             /* ADD/ DEL Config Type */
1519             memcpy(&rlcUeCfg->rlcLcCfg[dbIdx], &ueCfgDb->rlcLcCfg[dbIdx], sizeof(RlcBearerCfg));
1520          }
1521          rlcUeCfg->numLcs++;
1522       }
1523    }
1524    return ret;
1525 }
1526
1527 /******************************************************************
1528  *
1529  * @brief creates UE context
1530  *
1531  * @details
1532  *
1533  *    Function : duCreateUeCb
1534  *
1535  *    Functionality: Creates UE Conetxt
1536  *
1537  * @params[in] UeCcchCtxt Pointer
1538  *             UeIdx Pointer
1539  *
1540  * @return ROK     - success
1541  *         RFAILED - failure
1542  * ****************************************************************/
1543 uint8_t duCreateUeCb(UeCcchCtxt *ueCcchCtxt, uint32_t gnbCuUeF1apId)
1544 {
1545    uint8_t cellIdx = 0;
1546    uint8_t ret     = ROK;
1547    uint8_t ueIdx;
1548
1549    for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
1550    {
1551       if(ueCcchCtxt->cellId == duCb.actvCellLst[cellIdx]->cellId)
1552       {
1553          GET_UE_IDX(ueCcchCtxt->crnti, ueIdx);
1554          DU_LOG("\nDEBUG   -->  DU_APP: Filling UeCb for ueIdx [%d]", ueIdx);
1555
1556          duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].f1UeDb        = NULLP;
1557          duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].crnti         = ueCcchCtxt->crnti;
1558          duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId = ueCcchCtxt->gnbDuUeF1apId;
1559          duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId = gnbCuUeF1apId;
1560          duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].drbBitMap     = NULLP;
1561          duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].ueState       = UE_ACTIVE;
1562
1563          /* Filling Mac Ue Config */
1564          memset(&duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].macUeCfg, 0, sizeof(MacUeCfg));
1565          ret = duBuildAndSendUeCreateReqToMac(ueCcchCtxt->cellId, ueIdx, ueCcchCtxt->crnti,\
1566                 &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].macUeCfg);
1567          if(ret == RFAILED)
1568             DU_LOG("\nERROR  -->  DU APP : Failed to send UE create request to MAC");
1569
1570          /* Filling Rlc Ue Config */
1571          memset(&duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].rlcUeCfg, 0, sizeof(RlcUeCfg));
1572          ret = duBuildAndSendUeCreateReqToRlc(ueCcchCtxt->cellId, ueIdx, \
1573                 &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].rlcUeCfg);
1574          if(ret == RFAILED)
1575             DU_LOG("\nERROR  -->  DU APP : Failed to send UE create request to RLC");
1576
1577          duCb.actvCellLst[cellIdx]->numActvUes++;
1578          memset(ueCcchCtxt, 0, sizeof(UeCcchCtxt));
1579       }
1580    }
1581    return ret;
1582 }
1583
1584 /******************************************************************
1585  *
1586  * @brief Builds and Send UE Create Request to MAC
1587  *
1588  * @details
1589  *
1590  *    Function : duBuildAndSendUeCreateReqToMac
1591  *
1592  *    Functionality: Builds and Send UE Create Request to MAC
1593  *
1594  * @Params[in]  cellId,
1595  *              ueIdx
1596  * @return ROK     - success
1597  *         RFAILED - failure
1598  *
1599  * ****************************************************************/
1600
1601 uint8_t duBuildAndSendUeCreateReqToMac(uint16_t cellId, uint8_t ueIdx,\
1602    uint16_t crnti, MacUeCfg *duMacUeCfg)
1603 {
1604    uint8_t  ret = ROK;
1605    MacUeCfg *macUeCfg = NULLP;
1606    Pst       pst;
1607    memset(&pst, 0, sizeof(Pst));
1608
1609
1610    ret = fillMacUeCfg(cellId, ueIdx, crnti, NULL, duMacUeCfg);
1611    if(ret == RFAILED)
1612    {
1613       DU_LOG("\nERROR  -->  DU APP : Failed to fill MacUeCfg at duBuildAndSendUeCreateReqToMac()");
1614       return RFAILED;
1615    }
1616    /* Fill Pst */
1617    FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_UE_CREATE_REQ);
1618
1619    /* Copying ueCb to a sharable buffer */
1620    DU_ALLOC_SHRABL_BUF(macUeCfg, sizeof(MacUeCfg));
1621    if(macUeCfg)
1622    {
1623       memset(macUeCfg, 0, sizeof(MacUeCfg));
1624       memcpy(macUeCfg, &duCb.actvCellLst[cellId - 1]->ueCb[ueIdx -1].macUeCfg, sizeof(MacUeCfg));
1625       DU_LOG("\nDEBUG   -->  DU_APP: Sending UE create request to MAC");
1626
1627       /* Processing one Ue at a time to MAC */
1628       ret = (*packMacUeCreateReqOpts[pst.selector])(&pst, macUeCfg);
1629       if(ret == RFAILED)
1630       {
1631          DU_LOG("\nERROR  -->  DU_APP : Failure in sending Ue Create Req to MAC at duBuildAndSendUeCreateReqToMac()");
1632          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, macUeCfg, sizeof(MacUeCfg));
1633       }
1634    }
1635    else
1636    {
1637       DU_LOG("\n ERROR  -->  DU APP : Memory alloc failed at duBuildAndSendUeCreateReqToMac()");
1638       ret = RFAILED;
1639    }
1640    return ret;
1641 }
1642
1643 /*******************************************************************
1644  *
1645  * @brief To update DuUeCb Mac Cfg
1646  *
1647  * @details
1648  *
1649  *    Function : duUpdateMacCfg
1650  *    Functionality:  update DuUeCb MAC Cfg
1651  *
1652  * @params[in] DuUeCb Pointer
1653  *             F1UeContextSetupDb pointer
1654  * @return ROK     - success
1655  *         RFAILED - failure
1656  *
1657  * ****************************************************************/
1658 uint8_t duUpdateMacCfg(MacUeCfg *macUeCfg, F1UeContextSetupDb *f1UeDb)
1659 {
1660    uint8_t ret, lcIdx, dbIdx, numLcs, lcDelIdx;
1661    ret = ROK;
1662
1663    /*Filling Cell Group Cfg*/
1664    ret =  procUeReCfgCellInfo(macUeCfg, f1UeDb->duUeCfg.cellGrpCfg);
1665    if(ret == ROK)
1666    {
1667       if(macUeCfg->spCellCfg.servCellCfg.initDlBwp.pdschPresent)
1668       {
1669          fillStartSymbolAndLen(macUeCfg->spCellCfg.servCellCfg.initDlBwp.pdschCfg.numTimeDomRsrcAlloc,\
1670                &macUeCfg->spCellCfg.servCellCfg.initDlBwp.pdschCfg, NULL);
1671       }
1672       if(macUeCfg->spCellCfg.servCellCfg.initUlBwp.puschPresent)
1673       {
1674          fillStartSymbolAndLen(macUeCfg->spCellCfg.servCellCfg.initUlBwp.puschCfg.numTimeDomRsrcAlloc,\
1675                NULL, &macUeCfg->spCellCfg.servCellCfg.initUlBwp.puschCfg);
1676       }
1677       ret = fillAmbr(&macUeCfg->ambrCfg, f1UeDb->duUeCfg.ambrCfg);
1678    }
1679    /* Filling LC Context */
1680    for(dbIdx = 0; (dbIdx < f1UeDb->duUeCfg.numMacLcs && ret == ROK); dbIdx++)
1681    {
1682       numLcs = macUeCfg->numLcs;
1683       for(lcIdx = 0; lcIdx < numLcs; lcIdx++)
1684       {
1685          if(f1UeDb->duUeCfg.macLcCfg[dbIdx].lcId ==  macUeCfg->lcCfgList[lcIdx].lcId)
1686          {
1687             if(f1UeDb->duUeCfg.macLcCfg[dbIdx].configType == CONFIG_MOD)
1688             {
1689                ret = fillMacLcCfgToAddMod(&macUeCfg->lcCfgList[lcIdx],&f1UeDb->duUeCfg.macLcCfg[dbIdx]);
1690             }
1691             else if(f1UeDb->duUeCfg.macLcCfg[dbIdx].configType == CONFIG_DEL)
1692             {
1693                /* Free memory at matched  lcIdx index */
1694                freeMacLcCfg(&macUeCfg->lcCfgList[lcIdx]);
1695                macUeCfg->numLcs--;
1696                for(lcDelIdx = lcIdx; lcDelIdx < macUeCfg->numLcs; lcDelIdx++)
1697                {
1698                   /* moving all elements one index ahead */
1699                   ret = fillMacLcCfgToAddMod(&macUeCfg->lcCfgList[lcDelIdx], &macUeCfg->lcCfgList[lcDelIdx+1]);
1700                   freeMacLcCfg(&macUeCfg->lcCfgList[lcDelIdx+1]);
1701                   if(ret == RFAILED)
1702                   {
1703                      DU_LOG("\nERROR  -->  DU APP : Failed to delete LC at Idx %d in duUpdateMacCfg()", lcDelIdx);
1704                      break;
1705                   }
1706                }
1707             }
1708          }
1709       }
1710       if(f1UeDb->duUeCfg.macLcCfg[dbIdx].configType == CONFIG_ADD)
1711       {
1712          ret = fillMacLcCfgToAddMod(&macUeCfg->lcCfgList[numLcs], &f1UeDb->duUeCfg.macLcCfg[dbIdx]);
1713          if(ret == RFAILED)
1714          {
1715             DU_LOG("\nERROR  -->  DU APP : Failed to add LC at Idx %d in duUpdateMacCfg()", numLcs);
1716             break;
1717          }
1718          macUeCfg->numLcs++;
1719       }
1720
1721    }
1722    return ret;
1723 }
1724
1725 /******************************************************************
1726  *
1727  * @brief Function to fill the RLC Lc cfg from ueSetupReqDb
1728  *
1729  * @details
1730  *
1731  *    Function : fillRlcCfgToAddMod
1732  *
1733  *    Functionality: Function to fill the RLC Lc cfg from ueSetupReqDb
1734  *
1735  *
1736  *****************************************************************/
1737
1738 uint8_t fillRlcCfgToAddMod(RlcBearerCfg *lcCfg, RlcBearerCfg *f1UeDbLcCfg)
1739 {
1740    lcCfg->configType = f1UeDbLcCfg->configType;
1741    lcCfg->rbId       = f1UeDbLcCfg->rbId;
1742    lcCfg->rbType     = f1UeDbLcCfg->rbType;
1743    lcCfg->lcId       = f1UeDbLcCfg->lcId;
1744    lcCfg->lcType     = f1UeDbLcCfg->lcType;
1745    lcCfg->rlcMode    = f1UeDbLcCfg->rlcMode;
1746    switch(lcCfg->rlcMode)
1747    {
1748       case RLC_AM :
1749       {
1750          if(!lcCfg->u.amCfg)
1751          {
1752             DU_ALLOC_SHRABL_BUF(lcCfg->u.amCfg, sizeof(AmBearerCfg));
1753             if(!lcCfg->u.amCfg)
1754                return RFAILED;
1755          }
1756          /* DL AM */
1757          lcCfg->u.amCfg->dlAmCfg.snLenDl     = f1UeDbLcCfg->u.amCfg->dlAmCfg.snLenDl;
1758          lcCfg->u.amCfg->dlAmCfg.pollRetxTmr = f1UeDbLcCfg->u.amCfg->dlAmCfg.pollRetxTmr;
1759          lcCfg->u.amCfg->dlAmCfg.pollPdu     = f1UeDbLcCfg->u.amCfg->dlAmCfg.pollPdu;
1760          lcCfg->u.amCfg->dlAmCfg.pollByte    = f1UeDbLcCfg->u.amCfg->dlAmCfg.pollByte;
1761          lcCfg->u.amCfg->dlAmCfg.maxRetxTh   = f1UeDbLcCfg->u.amCfg->dlAmCfg.maxRetxTh;
1762
1763          /* UL AM */
1764          lcCfg->u.amCfg->ulAmCfg.snLenUl     = f1UeDbLcCfg->u.amCfg->ulAmCfg.snLenUl;
1765          lcCfg->u.amCfg->ulAmCfg.reAssemTmr  = f1UeDbLcCfg->u.amCfg->ulAmCfg.reAssemTmr;
1766          lcCfg->u.amCfg->ulAmCfg.statProhTmr = f1UeDbLcCfg->u.amCfg->ulAmCfg.statProhTmr;
1767          break;
1768       }
1769       case RLC_UM_BI_DIRECTIONAL :
1770       {
1771          if(!lcCfg->u.umBiDirCfg)
1772          {
1773             DU_ALLOC_SHRABL_BUF(lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
1774             if(!lcCfg->u.umBiDirCfg)
1775                 return RFAILED;
1776          }
1777          /* UL UM BI DIR INFO */
1778          lcCfg->u.umBiDirCfg->ulUmCfg.snLenUlUm  = f1UeDbLcCfg->u.umBiDirCfg->ulUmCfg.snLenUlUm;
1779          lcCfg->u.umBiDirCfg->ulUmCfg.reAssemTmr = f1UeDbLcCfg->u.umBiDirCfg->ulUmCfg.reAssemTmr;
1780          /* DL UM BI DIR INFO */
1781          lcCfg->u.umBiDirCfg->dlUmCfg.snLenDlUm  = f1UeDbLcCfg->u.umBiDirCfg->dlUmCfg.snLenDlUm;
1782          break;
1783       }
1784       case RLC_UM_UNI_DIRECTIONAL_UL :
1785       {
1786          if(!lcCfg->u.umUniDirUlCfg)
1787          {
1788             DU_ALLOC_SHRABL_BUF(lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
1789             if(!lcCfg->u.umUniDirUlCfg)
1790                return RFAILED;
1791          }
1792          lcCfg->u.umUniDirUlCfg->ulUmCfg.snLenUlUm  = f1UeDbLcCfg->u.umUniDirUlCfg->ulUmCfg.snLenUlUm;
1793          lcCfg->u.umUniDirUlCfg->ulUmCfg.reAssemTmr = f1UeDbLcCfg->u.umUniDirUlCfg->ulUmCfg.reAssemTmr;
1794          break;
1795
1796       }
1797       case RLC_UM_UNI_DIRECTIONAL_DL :
1798       {
1799          if(!lcCfg->u.umUniDirDlCfg)
1800          {
1801             DU_ALLOC_SHRABL_BUF(lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
1802             if(!lcCfg->u.umUniDirDlCfg)
1803                return RFAILED;
1804          }
1805          lcCfg->u.umUniDirDlCfg->dlUmCfg.snLenDlUm  = f1UeDbLcCfg->u.umUniDirDlCfg->dlUmCfg.snLenDlUm;
1806          break;
1807       }
1808       default:
1809          DU_LOG("\nERROR  -->  DU_APP: Invalid Rlc Mode %d at fillRlcCfgToAddMod()", lcCfg->rlcMode);
1810          return RFAILED;
1811    }
1812    return ROK;
1813 }
1814
1815 /*******************************************************************
1816  *
1817  * @brief To update DuUeCb Rlc Lc Cfg
1818  *
1819  * @details
1820  *
1821  *    Function : duUpdateRlcLcCfg
1822  *    Functionality:  update DuUeCb Rlc Lc Cfg
1823  *
1824  * @params[in] DuUeCb Pointer
1825  *             F1UeContextSetupDb pointer
1826  * @return ROK     - success
1827  *         RFAILED - failure
1828  *
1829  * ****************************************************************/
1830
1831 uint8_t duUpdateRlcLcCfg(RlcUeCfg *rlcUeCfg, F1UeContextSetupDb *f1UeDb)
1832 {
1833    uint8_t ret, lcIdx, dbIdx, numLcs, lcDelIdx;
1834
1835    ret = ROK;
1836    for(dbIdx = 0; (dbIdx < f1UeDb->duUeCfg.numRlcLcs && ret ==ROK); dbIdx++)
1837    {
1838       numLcs = rlcUeCfg->numLcs;
1839       for(lcIdx = 0; lcIdx < numLcs; lcIdx++)
1840       {
1841          if(f1UeDb->duUeCfg.rlcLcCfg[dbIdx].lcId == rlcUeCfg->rlcLcCfg[lcIdx].lcId)
1842          {
1843             if(f1UeDb->duUeCfg.rlcLcCfg[dbIdx].configType == CONFIG_MOD)
1844             {
1845                ret = fillRlcCfgToAddMod(&rlcUeCfg->rlcLcCfg[lcIdx], &f1UeDb->duUeCfg.rlcLcCfg[dbIdx]);
1846             }
1847             else if(f1UeDb->duUeCfg.rlcLcCfg[dbIdx].configType == CONFIG_DEL)
1848             {
1849                /* Free memory at matched lcIdx index */
1850                freeRlcLcCfg(&rlcUeCfg->rlcLcCfg[lcIdx]);
1851                rlcUeCfg->numLcs--;
1852                for(lcDelIdx = lcIdx; lcDelIdx < rlcUeCfg->numLcs; lcDelIdx++)
1853                {
1854                   ret = fillRlcCfgToAddMod(&rlcUeCfg->rlcLcCfg[lcDelIdx], &rlcUeCfg->rlcLcCfg[lcDelIdx+1]);
1855                   freeRlcLcCfg(&rlcUeCfg->rlcLcCfg[lcDelIdx+1]);
1856                   if(ret == RFAILED)
1857                   {
1858                      DU_LOG("\nERROR  -->  DU APP : Failed to delete LC at Idx %d in duUpdateRlcCfg()", lcDelIdx);
1859                      break;
1860                   }
1861                }
1862             }
1863          }
1864       }
1865       if(f1UeDb->duUeCfg.rlcLcCfg[dbIdx].configType == CONFIG_ADD)
1866       {
1867          ret = fillRlcCfgToAddMod(&rlcUeCfg->rlcLcCfg[lcIdx], &f1UeDb->duUeCfg.rlcLcCfg[dbIdx]);
1868          if(ret == ROK)
1869             rlcUeCfg->numLcs++;
1870       }
1871    }
1872    return ret;
1873 }
1874
1875
1876 /*******************************************************************
1877  *
1878  * @brief Function to fill Tunnel Config to Add/Mod
1879  *
1880  *
1881  * @details
1882  *
1883  *    Function : fillTnlCfgToAddMod
1884  *
1885  *    Functionality: Function to fill tunnel Config to Add/Mod
1886  *
1887  * @params[in] Pointer to tnlCfgDb,
1888  *             pointer to f1TnlCfg
1889  * @return ROK     - success
1890  *         RFAILED - failure
1891  *
1892  * ****************************************************************/
1893 uint8_t fillTnlCfgToAddMod(UpTnlCfg **ueCbTnlCfg, UpTnlCfg *f1TnlCfg)
1894 {
1895    if(*ueCbTnlCfg == NULLP)
1896    {
1897       /* copying to DuCb Tnl Cfg */
1898       DU_ALLOC(*ueCbTnlCfg, sizeof(UpTnlCfg));
1899       if(*ueCbTnlCfg == NULLP)
1900       {
1901          DU_LOG("\nERROR  -->  DU_APP : fillTnlCfgToAddMod: Memory Alloc failed for drbId[%d]", f1TnlCfg->drbId);
1902          return RFAILED;
1903       }
1904    }
1905    memset(*ueCbTnlCfg, 0, sizeof(UpTnlCfg));
1906    (*ueCbTnlCfg)->configType = f1TnlCfg->configType;
1907    (*ueCbTnlCfg)->cellId    = f1TnlCfg->cellId;
1908    (*ueCbTnlCfg)->ueIdx     = f1TnlCfg->ueIdx;
1909    (*ueCbTnlCfg)->drbId     = f1TnlCfg->drbId;
1910    if(f1TnlCfg->tnlCfg1)
1911    {
1912       if((*ueCbTnlCfg)->tnlCfg1 == NULLP)
1913       {
1914          DU_ALLOC((*ueCbTnlCfg)->tnlCfg1, sizeof(GtpTnlCfg));
1915          if((*ueCbTnlCfg)->tnlCfg1 == NULLP)
1916          {
1917             DU_LOG("\nERROR  -->  DU_APP : fillTnlCfgToAddMod: Memory Alloc failed for tnlCfg1 for drbId[%d]", f1TnlCfg->drbId);
1918             return RFAILED;
1919          }
1920       }
1921       memset((*ueCbTnlCfg)->tnlCfg1, 0, sizeof(GtpTnlCfg));
1922       (*ueCbTnlCfg)->tnlCfg1->teId = f1TnlCfg->tnlCfg1->teId;
1923       (*ueCbTnlCfg)->tnlCfg1->ulTnlAddress = f1TnlCfg->tnlCfg1->ulTnlAddress;
1924       (*ueCbTnlCfg)->tnlCfg1->dlTnlAddress = f1TnlCfg->tnlCfg1->dlTnlAddress;
1925    }
1926    return ROK;
1927 }
1928
1929 /*******************************************************************
1930  *
1931  * @brief Processing the tunnel Request to EGTP
1932  *
1933  * @details
1934  *
1935  *    Function : duProcEgtpTunnelCfg
1936  *
1937  *    Functionality: Processing the tunnel Request to EGTP
1938  *
1939  * @params[in] UptnlCfg *duTnlCfg, UpTnlCfg *f1TnlCfg
1940  * @return ROK     - success
1941  *         RFAILED - failure
1942  *
1943  * ****************************************************************/
1944
1945 uint8_t duProcEgtpTunnelCfg(uint8_t ueCbIdx, UpTnlCfg *duTnlCfg, UpTnlCfg *f1TnlCfg)
1946 {
1947    uint8_t ret = RFAILED, delIdx;
1948
1949    if(f1TnlCfg->tnlCfg1 == NULLP)
1950    {
1951       DU_LOG("\nERROR  -->  DU_APP : Tunnel config not found");
1952       return ret;
1953    }
1954
1955    if(f1TnlCfg->configType == CONFIG_ADD)
1956    {
1957       if(duSendEgtpTnlMgmtReq(EGTP_TNL_MGMT_ADD, NULLP, f1TnlCfg->tnlCfg1) == ROK)
1958       {
1959          if(fillTnlCfgToAddMod(&duCb.upTnlCfg[duCb.numDrb], f1TnlCfg) == ROK)
1960          {
1961             duCb.numDrb++;
1962             ret = ROK;
1963          }
1964       }
1965    }
1966    else if(f1TnlCfg->configType == CONFIG_MOD)
1967    {
1968       if(duSendEgtpTnlMgmtReq(EGTP_TNL_MGMT_MOD, duTnlCfg->tnlCfg1->teId, f1TnlCfg->tnlCfg1) == ROK)
1969       {
1970          if(fillTnlCfgToAddMod(&duTnlCfg, f1TnlCfg) == ROK)
1971          {
1972             ret = ROK;
1973          }
1974       }
1975    }
1976    else if(f1TnlCfg->configType == CONFIG_DEL)
1977    {
1978       if(duSendEgtpTnlMgmtReq(EGTP_TNL_MGMT_DEL, duTnlCfg->tnlCfg1->teId, f1TnlCfg->tnlCfg1) == ROK)
1979       {
1980          /* Free memory at drbIdx */
1981          DU_FREE(duTnlCfg->tnlCfg1, sizeof(GtpTnlCfg));
1982          DU_FREE(duTnlCfg, sizeof(UpTnlCfg));
1983          duCb.numDrb--;
1984          for(delIdx = ueCbIdx; delIdx < duCb.numDrb; delIdx++)
1985          {
1986             /* moving all elements one index ahead */
1987             ret = fillTnlCfgToAddMod(&duCb.upTnlCfg[delIdx], duCb.upTnlCfg[delIdx+1]);
1988             if(ret != ROK)
1989             {
1990                return ret;
1991             }
1992          }
1993       }
1994    }
1995    return ret;
1996 }
1997
1998 /***********************************************************************
1999  *
2000  * @brief Function to fill Tunnel Config
2001  *        and sends tunnel Req to EGTP
2002  *
2003  *
2004  * @details
2005  *
2006  *    Function : duUpdateTunnelCfgDb
2007  *
2008  *    Functionality: Function to fill tunnel Config
2009  *                   and sends tunnel Cfg Req to EGTP
2010  *
2011  * @params[in] ueIdx, cellId, DuUeCfg
2012  * @return ROK     - success
2013  *         RFAILED - failure
2014  *
2015  * ****************************************************************/
2016
2017 uint8_t duUpdateTunnelCfgDb(uint8_t ueIdx, uint8_t cellId, DuUeCfg *duUeCfg)
2018 {
2019    uint8_t ret = ROK, drbIdx, duCbDrbIdx;
2020    bool drbFound = false;
2021
2022    /*If Add/Mod tunnels request for that DRB is successful in EGTP */
2023    /*then update drbId and tunnel Info in duCb */
2024    for(drbIdx=0; drbIdx < duUeCfg->numDrb; drbIdx++)
2025    {
2026       duUeCfg->upTnlInfo[drbIdx].cellId = cellId;
2027       duUeCfg->upTnlInfo[drbIdx].ueIdx = ueIdx;
2028       for(duCbDrbIdx = 0; duCbDrbIdx < duCb.numDrb; duCbDrbIdx++)
2029       {
2030          if(duCb.upTnlCfg[duCbDrbIdx]->drbId == duUeCfg->upTnlInfo[drbIdx].drbId)
2031          {
2032             drbFound = true; /* existing DRB */
2033             if(duProcEgtpTunnelCfg(duCbDrbIdx, duCb.upTnlCfg[duCbDrbIdx], &duUeCfg->upTnlInfo[drbIdx]) != ROK)
2034             {
2035                DU_LOG("\nERROR  -> DU_APP : duUpdateTunnelCfgDb: Failed to modify tunnel req for Drb id[%d]",
2036                duUeCfg->upTnlInfo[drbIdx].drbId);
2037                ret = RFAILED;
2038             }
2039             break;
2040          }
2041          else
2042             drbFound = false;
2043       }
2044       if(!drbFound && ret == ROK)/* new DRB to Add */
2045       {
2046          if(duProcEgtpTunnelCfg(NULLP, NULLP, &duUeCfg->upTnlInfo[drbIdx]) != ROK)
2047          {
2048             DU_LOG("\nERROR  -> DU_APP : duUpdateTunnelCfgDb: Failed to add tunnel req for Drb id[%d]",
2049             duUeCfg->upTnlInfo[drbIdx].drbId);
2050             ret = RFAILED;
2051             break;
2052          }
2053       }
2054       else
2055          break;
2056    }
2057    return ret;
2058 }
2059
2060 /*******************************************************************
2061  *
2062  * @brief @brief To update DuUeCb Mac and Rlc Ue Cfg
2063  *
2064  *
2065  * @details
2066  *
2067  *    Function : duUpdateDuUeCbCfg
2068  *
2069  *    Functionality: update DuUeCb Mac and Rlc Ue Cfg
2070  *
2071  * @params[in] ueIdx, cellIdx
2072  * @return ROK     - success
2073  *         RFAILED - failure
2074  *
2075  * ****************************************************************/
2076
2077 uint8_t duUpdateDuUeCbCfg(uint8_t ueIdx, uint8_t cellId)
2078 {
2079    uint8_t ret = ROK, cellIdx = 0, crnti=0;
2080    DuUeCb *ueCb = NULLP;
2081
2082    GET_CELL_IDX(cellId, cellIdx);
2083
2084    if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].macUeCfg. \
2085          macUeCfgState == UE_RECFG_COMPLETE) &&
2086       (duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].rlcUeCfg. \
2087          rlcUeCfgState == UE_RECFG_COMPLETE))
2088    {
2089       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
2090
2091       /*Filling RLC Ue Cfg */
2092       ueCb->rlcUeCfg.cellId = cellId;
2093       ueCb->rlcUeCfg.ueIdx  = ueIdx;
2094       ret = duUpdateRlcLcCfg(&ueCb->rlcUeCfg, ueCb->f1UeDb);
2095       if(ret == ROK)
2096       {
2097          /*Filling MAC Ue Cfg */
2098          GET_CRNTI(crnti, ueIdx);
2099          ueCb->macUeCfg.cellId = cellId;
2100          ueCb->macUeCfg.ueIdx  = ueIdx;
2101          ueCb->macUeCfg.crnti  = crnti;
2102          ret = duUpdateMacCfg(&ueCb->macUeCfg, ueCb->f1UeDb);
2103          if(ret == RFAILED)
2104             DU_LOG("\nERROR  -->  DU APP : Failed while updating MAC LC Config at duUpdateDuUeCbCfg()");
2105          else
2106          {
2107             if(duUpdateTunnelCfgDb(ueIdx, cellId, &ueCb->f1UeDb->duUeCfg) != ROK)
2108             {
2109                DU_LOG("\nERROR  -->  DU_APP : Failed to establish tunnel in duUpdateDuUeCbCfg()");
2110                return RFAILED;
2111             }
2112          }
2113       }
2114       else
2115          DU_LOG("\nERROR  -->  DU APP : Failed while updating RLC LC Config at duUpdateDuUeCbCfg()");
2116    }
2117    else
2118       ret = RFAILED;
2119    return ret;
2120 }
2121
2122 /*******************************************************************
2123  *
2124  * @brief Handle UE config response from MAC
2125  *
2126  * @details
2127  *
2128  *    Function : DuProcMacUeCfgRsp
2129  *
2130  *    Functionality: Handle UE Config response from MAC
2131  *
2132  * @params[in] Pointer to MacUeCfgRsp and Pst
2133  * @return ROK     - success
2134  *         RFAILED - failure
2135  *
2136  * ****************************************************************/
2137 uint8_t DuProcMacUeCfgRsp(Pst *pst, MacUeCfgRsp *cfgRsp)
2138 {
2139    uint8_t ret = ROK;
2140
2141    if(cfgRsp)
2142    {
2143       if(cfgRsp->result == MAC_DU_APP_RSP_OK)
2144       {
2145          if(pst->event == EVENT_MAC_UE_CREATE_RSP)
2146          {
2147             DU_LOG("\nINFO   -->  DU APP : MAC UE Create Response : SUCCESS [UE IDX : %d]", cfgRsp->ueIdx);
2148             duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueIdx -1].\
2149                macUeCfg.macUeCfgState = UE_CREATE_COMPLETE;
2150          }
2151          else if(pst->event == EVENT_MAC_UE_RECONFIG_RSP)
2152          {
2153             DU_LOG("\nINFO   -->  DU APP : MAC UE Reconfig Response : SUCCESS [UE IDX : %d]", cfgRsp->ueIdx);
2154             duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueIdx -1].\
2155                macUeCfg.macUeCfgState = UE_RECFG_COMPLETE;
2156             if((ret = duUpdateDuUeCbCfg(cfgRsp->ueIdx, cfgRsp->cellId)) == ROK)
2157                BuildAndSendUeCtxtRsp(cfgRsp->ueIdx, cfgRsp->cellId);
2158          }
2159       }
2160       else
2161       {
2162          DU_LOG("\nERROR  -->  DU APP : MAC UE CFG Response for EVENT[%d]: FAILURE [UE IDX : %d]", pst->event, cfgRsp->ueIdx);
2163          if(pst->event == EVENT_MAC_UE_RECONFIG_RSP)
2164          {
2165             //TODO: Send the failure case in Ue Context Setup Response
2166          }
2167          ret = RFAILED;
2168       }
2169       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(MacUeCfgRsp));
2170    }
2171    else
2172    {
2173       DU_LOG("\nERROR  -->  DU APP : Received MAC Ue Config Response is NULL at DuProcMacUeCfgRsp()");
2174       ret = RFAILED;
2175    }
2176    return ret;
2177 }
2178
2179
2180 /*******************************************************************
2181  *
2182  * @brief Processes UE create Req to RLC UL
2183  *
2184  * @details
2185  *
2186  *    Function : duBuildAndSendUeCreateReqToRlc
2187  *
2188  *    Functionality:
2189  *     Processes UE create Req to RLC UL
2190  *
2191  *  @params[in]  cellId,
2192  *               ueIdx,
2193  *               Pointer to RlcUeCfg
2194  *  @return ROK     - success
2195  *          RFAILED - failure
2196  *
2197  *****************************************************************/
2198
2199 uint8_t duBuildAndSendUeCreateReqToRlc(uint16_t cellId, uint8_t ueIdx,\
2200    RlcUeCfg *duRlcUeCfg)
2201 {
2202    uint8_t  ret = ROK;
2203    RlcUeCfg *rlcUeCfg = NULLP;
2204    Pst       pst;
2205
2206    ret = fillRlcUeCfg(cellId, ueIdx, NULL, duRlcUeCfg);
2207    if(ret == RFAILED)
2208    {
2209       DU_LOG("\nERROR  -->  DU APP : Failed to fill Rlc Ue Cfg at duBuildAndSendUeCreateReqToRlc()");
2210       return ret;
2211    }
2212
2213    FILL_PST_DUAPP_TO_RLC(pst, RLC_UL_INST, EVENT_RLC_UE_CREATE_REQ);
2214    /* Copying ueCfg to a sharable buffer */
2215    DU_ALLOC_SHRABL_BUF(rlcUeCfg, sizeof(RlcUeCfg));
2216    if(rlcUeCfg)
2217    {
2218       memset(rlcUeCfg, 0, sizeof(RlcUeCfg));
2219       memcpy(rlcUeCfg, duRlcUeCfg, sizeof(RlcUeCfg));
2220       /* Processing one Ue at a time to RLC */
2221       DU_LOG("\nDEBUG   -->  DU_APP: Sending UE create request to RLC UL");
2222       ret = (*packRlcUeCreateReqOpts[pst.selector])(&pst, rlcUeCfg);
2223       if(ret == RFAILED)
2224       {
2225          DU_LOG("\nERROR  -->  DU_APP : Failure in sending Ue Create Req to RLC");
2226          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, rlcUeCfg, sizeof(RlcUeCfg));
2227          ret = RFAILED;
2228       }
2229    }
2230    else
2231    {
2232       DU_LOG("\n ERROR  -->  DU APP : Memory alloc failed at duBuildAndSendUeCreateReqToRlc()");
2233       ret = RFAILED;
2234    }
2235    return ret;
2236 }
2237
2238 /*******************************************************************
2239  *
2240  * @brief Processes UE create Rsp received from RLC UL
2241  *
2242  * @details
2243  *
2244
2245  *    Function : DuProcRlcUeCfgRsp
2246  *
2247  *    Functionality:
2248  *     Processes UE create Rsp received from RLC UL
2249  *
2250  *  @params[in]  Post structure
2251  *               Pointer to RlcCfgCfm
2252  *  @return ROK     - success
2253  *          RFAILED - failure
2254  *
2255  *****************************************************************/
2256 uint8_t DuProcRlcUeCfgRsp(Pst *pst, RlcUeCfgRsp *cfgRsp)
2257 {
2258    uint8_t ret = ROK;
2259
2260    if(cfgRsp)
2261    {
2262       if(cfgRsp->result == RLC_DU_APP_RSP_OK)
2263       {
2264          if(pst->event == EVENT_RLC_UE_CREATE_RSP)
2265          {
2266             DU_LOG("\nINFO   -->  DU_APP: RLC UE Create Response : SUCCESS [UE IDX:%d]", cfgRsp->ueIdx);
2267             duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueIdx -1].\
2268                rlcUeCfg.rlcUeCfgState = UE_CREATE_COMPLETE;
2269          }
2270          else if(pst->event == EVENT_RLC_UE_RECONFIG_RSP)
2271          {
2272             DU_LOG("\nINFO   -->  DU_APP: RLC UE Reconfig Response : SUCCESS [UE IDX:%d]", cfgRsp->ueIdx);
2273             duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueIdx -1].\
2274                rlcUeCfg.rlcUeCfgState = UE_RECFG_COMPLETE;
2275             if((ret = duUpdateDuUeCbCfg(cfgRsp->ueIdx, cfgRsp->cellId)) == ROK)
2276                BuildAndSendUeCtxtRsp(cfgRsp->ueIdx, cfgRsp->cellId);
2277          }
2278       }
2279       else
2280       {
2281          DU_LOG("\nERROR  -->  DU_APP: RLC UE CFG Response for EVENT[%d] : FAILED [UE IDX : %d, REASON :%d]",\
2282             pst->event, cfgRsp->ueIdx, cfgRsp->reason);
2283          if((pst->event == EVENT_RLC_UE_RECONFIG_RSP))
2284          {
2285             //TODO: update failure case in ue Context setup Response
2286          }
2287          ret = RFAILED;
2288       }
2289       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(RlcUeCfgRsp));
2290    }
2291    else
2292    {
2293       DU_LOG("\nERROR  -->  DU_APP: Received RLC Ue Config Response is NULL at DuProcRlcUeCfgRsp()");
2294       ret = RFAILED;
2295    }
2296    return ret;
2297 }
2298
2299
2300
2301 /*******************************************************************
2302  *
2303  * @brief Builds and Send Ue Reconfig Req to RLC
2304  *
2305  * @details
2306  *
2307  *    Function : duBuildAndSendUeReCfgReqToRLC
2308  *
2309  *    Functionality: Builds and Send Ue Reconfig Req to RLC
2310  *
2311  * @params[in] cellId, crnti
2312  *             DuUeCfg *ueCfgDb
2313  *             RlcUeCfg *rlcUeCfg
2314  * @return ROK     - success
2315  *         RFAILED - failure
2316  *
2317  * ****************************************************************/
2318
2319 uint8_t duBuildAndSendUeReCfgReqToRlc(uint8_t cellId, uint8_t crnti, DuUeCfg *ueCfgDb)
2320 {
2321    uint8_t ret = ROK, ueIdx = 0;
2322    RlcUeCfg *rlcUeCfg = NULLP;
2323
2324    GET_UE_IDX(crnti, ueIdx);
2325    DU_ALLOC_SHRABL_BUF(rlcUeCfg, sizeof(RlcUeCfg));
2326    if(rlcUeCfg)
2327    {
2328       memset(rlcUeCfg, 0, sizeof(RlcUeCfg));
2329       ret = fillRlcUeCfg(cellId, ueIdx, ueCfgDb, rlcUeCfg);
2330       if(ret == RFAILED)
2331          DU_LOG("\nERROR  -->  DU APP : Failed at duBuildAndSendUeReCfgReqToRlc()");
2332       else
2333          ret = sendUeReCfgReqToRlc(rlcUeCfg);
2334    }
2335    else
2336    {
2337       DU_LOG("\nERROR  -->  DU APP : Memory Alloc failed at duBuildAndSendUeReCfgReqToRlc()");
2338       ret = RFAILED;
2339    }
2340    return ret;
2341 }
2342
2343 /*******************************************************************
2344  *
2345  * @brief Builds and Send Ue Reconfig Req to MAC
2346  *
2347  * @details
2348  *
2349  *    Function : duBuildAndSendUeReCfgReqToMac
2350  *
2351  *    Functionality: Builds and Send Ue Reconfig Req to MAC
2352  *
2353  * @params[in] CellGroupConfigRrc_t *macCellGrpCfg
2354  *             DuUeCfg *ueCfgDb
2355  *             MacUeCfg    *macUeCfg
2356  * @return ROK     - success
2357  *         RFAILED - failure
2358  *
2359  * ****************************************************************/
2360
2361 uint8_t duBuildAndSendUeReCfgReqToMac(uint8_t cellId, uint8_t crnti, DuUeCfg *ueCfgDb)
2362 {
2363    uint8_t ret, ueIdx = 0;
2364    MacUeCfg *macUeCfg = NULLP;
2365
2366    ret = ROK;
2367    GET_UE_IDX(crnti, ueIdx);
2368
2369    DU_ALLOC_SHRABL_BUF(macUeCfg, sizeof(MacUeCfg));
2370    if(macUeCfg)
2371    {
2372       memset(macUeCfg, 0, sizeof(MacUeCfg));
2373       ret = fillMacUeCfg(cellId, ueIdx, crnti, ueCfgDb, macUeCfg);
2374       if(ret == RFAILED)
2375          DU_LOG("\nERROR  -->  DU APP : Failed to fill Mac Ue Cfg at duBuildAndSendUeReCfgReqToMac()");
2376       else
2377          ret = sendUeReCfgReqToMac(macUeCfg);
2378    }
2379    else
2380    {
2381       DU_LOG("\nERROR  -->  DU APP : Memory alloc failed for macUeCfg at duBuildAndSendUeReCfgReqToMac()");
2382       ret = RFAILED;
2383    }
2384    return ret;
2385 }
2386
2387 /*******************************************************************
2388  *
2389  * @brief Build and Send Ue context setup request
2390  *
2391  * @details
2392  *
2393
2394  *    Function : duBuildAndSendUeContextSetupReq
2395  *
2396  *    Functionality:
2397  *     Build and Send Ue context setup request
2398  *
2399  *  @params[in]  cellId, crnti, DuUeCfg pointer
2400  *  @return ROK     - success
2401  *          RFAILED - failure
2402  *
2403  *****************************************************************/
2404
2405 uint8_t duBuildAndSendUeContextSetupReq(uint16_t cellId, uint16_t crnti, DuUeCfg *duUeCfg)
2406 {
2407    uint8_t ret = ROK;
2408
2409    DU_LOG("\nDEBUG   -->  DU_APP: Processing Ue Context Setup Request for cellId [%d]", cellId);
2410    /* Filling RLC Ue Reconfig */
2411    ret = duBuildAndSendUeReCfgReqToRlc(cellId, crnti, duUeCfg);
2412    if(ret == RFAILED)
2413       DU_LOG("\nERROR  -->  DU APP : Failed to build ctxt setup req for RLC at duBuildAndSendUeContextSetupReq()");
2414
2415    /* Filling MAC Ue Reconfig */
2416    ret = duBuildAndSendUeReCfgReqToMac(cellId, crnti, duUeCfg);
2417    if(ret == RFAILED)
2418       DU_LOG("\nERROR  -->  DU APP : Failed at build ctxt setup req for MAC at duBuildAndSendUeContextSetupReq()");
2419
2420    return ret;
2421 }
2422
2423 /*******************************************************************
2424  *
2425  * @brief Processes DL Rsp received from RLC DL
2426  *
2427  * @details
2428  *
2429
2430  *    Function : DuProcRlcDlRrcMsgRsp
2431  *
2432  *    Functionality:
2433  *     Processes UE Rsp received from RLC DL
2434  *
2435  *  @params[in]  Post structure
2436  *               Pointer to RlcCfgCfm
2437  *  @return ROK     - success
2438  *          RFAILED - failure
2439  *
2440  *****************************************************************/
2441 uint8_t DuProcRlcDlRrcMsgRsp(Pst *pst, RlcDlRrcMsgRsp *dlRrcMsg)
2442 {
2443    uint8_t ret = ROK, ueIdx = 0;
2444    DuUeCb *ueCb = NULLP;
2445
2446    if(dlRrcMsg->state == TRANSMISSION_COMPLETE)
2447    {
2448       GET_UE_IDX(dlRrcMsg->crnti, ueIdx);
2449       ueCb = &duCb.actvCellLst[dlRrcMsg->cellId -1]->ueCb[ueIdx -1];
2450       if(ueCb->f1UeDb)
2451       {
2452         ret = duBuildAndSendUeContextSetupReq(dlRrcMsg->cellId, dlRrcMsg->crnti, &ueCb->f1UeDb->duUeCfg);
2453         if(ret == RFAILED)
2454            DU_LOG("\nERROR  -->  DU APP : Failed to process UE Context Setup Request in DuProcRlcDlRrcMsgRsp()");
2455       }
2456    }
2457    else
2458       DU_LOG("\nERROR  -->  DU APP : Failed to transmit DL RRC Msg");
2459
2460    DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, dlRrcMsg, sizeof(RlcDlRrcMsgRsp));
2461    return ret;
2462 }
2463 /*******************************************************************
2464  *
2465  * @brief Process UE context setup request from CU
2466  *
2467  * @details
2468  *
2469  *    Function : duProcUeContextSetupRequest
2470  *
2471  *    Functionality: Process UE context setup request from CU
2472  *
2473  * @params[in] F1AP message
2474  * @return ROK     - success
2475  *         RFAILED - failure
2476  *
2477  * ****************************************************************/
2478
2479 uint8_t duProcUeContextSetupRequest(DuUeCb *ueCb)
2480 {
2481    uint8_t ret, cellId;
2482
2483    ret = ROK;
2484    if(ueCb)
2485    {
2486       cellId = duCb.actvCellLst[ueCb->f1UeDb->cellIdx]->cellId;
2487       /* Send DL RRC msg for security Mode */
2488       if(ueCb->f1UeDb->dlRrcMsg)
2489       {
2490          if(ueCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
2491          {
2492             /* Sending DL RRC Message to RLC */
2493             ret = duBuildAndSendDlRrcMsgToRlc(cellId, ueCb->rlcUeCfg, ueCb->f1UeDb->dlRrcMsg);
2494             if(ret == RFAILED)
2495             {
2496                DU_LOG("\nERROR  -->  DU APP : Failed to send DL RRC msg in duProcUeContextSetupRequest()");
2497                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCb->f1UeDb->dlRrcMsg->rrcMsgPdu,\
2498                   ueCb->f1UeDb->dlRrcMsg->rrcMsgSize);
2499                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
2500             }
2501          }
2502       }
2503       else
2504       {
2505          ret = duBuildAndSendUeContextSetupReq(cellId, ueCb->crnti, &ueCb->f1UeDb->duUeCfg);
2506          if(ret == RFAILED)
2507          {
2508             DU_LOG("\nERROR  -->  DU APP : Failed to build ue context setup Req in duProcUeContextSetupRequest()");
2509          }
2510       }
2511    }
2512    else
2513    {
2514       //TODO: To send the failure cause in UeContextSetupRsp
2515       DU_LOG("ERROR  -->  DU APP : Failed to process UE CNTXT SETUP REQ at duProcUeContextSetupRequest()");
2516    }
2517    return ret;
2518 }
2519
2520 /**********************************************************************
2521   End of file
2522  ***********************************************************************/