src/du_app/du_ue_mgr.c

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