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          ret = getMaxAggrBitRate(macUeCfg->maxAggrBitRate, ueCfgDb->maxAggrBitRate);
1018       }
1019
1020       /* Filling LC Context */
1021       for(dbIdx = 0; (dbIdx < ueCfgDb->numMacLcs && ret == ROK); dbIdx++)
1022       {
1023          if(!ueCfgDb->macLcCfg[dbIdx].ulLcCfgPres)
1024          {
1025             /* Filling default UL LC config in MAC if not present */
1026             ueCfgDb->macLcCfg[dbIdx].ulLcCfgPres = true;
1027             fillDefaultUlLcCfg(&ueCfgDb->macLcCfg[dbIdx].ulLcCfg);
1028          }
1029          for(lcIdx = 0; lcIdx < duMacDb->numLcs; lcIdx++)
1030          {
1031             if(ueCfgDb->macLcCfg[dbIdx].lcId == duMacDb->lcCfgList[lcIdx].lcId)
1032             {
1033                lcIdFound = true;
1034                if((ueCfgDb->macLcCfg[dbIdx].configType == CONFIG_UNKNOWN) ||
1035                      (ueCfgDb->macLcCfg[dbIdx].configType == CONFIG_MOD))
1036                {
1037                   ueCfgDb->macLcCfg[dbIdx].configType = CONFIG_MOD;
1038                   ret = fillMacLcCfgToAddMod(&macUeCfg->lcCfgList[dbIdx], &ueCfgDb->macLcCfg[dbIdx]);
1039                }
1040             }
1041             else
1042                lcIdFound = false;
1043          }
1044          if(!lcIdFound)
1045          {
1046             /* ADD/DEL CONFIG */
1047             ret = fillMacLcCfgToAddMod(&macUeCfg->lcCfgList[dbIdx], &ueCfgDb->macLcCfg[dbIdx]);
1048          }
1049          if(ret == ROK)
1050          {
1051             macUeCfg->numLcs++;
1052          }
1053          else
1054          {
1055             DU_LOG("\n DU_APP: Failed to add Lc at Idx %d in fillMacUeCfg()", dbIdx);
1056             break;
1057          }
1058       }/*End of Outer FOR loop */
1059    }
1060    return ret;
1061 }
1062
1063 /******************************************************************
1064  *
1065  * @brief Fills Rlc AM Information
1066  *
1067  * @details
1068  *
1069  *    Function : fillDefaultAmInfo
1070  *
1071  *    Functionality: Fills Rlc AM Information
1072  *
1073  * @params[in]  AmBearerCfg *amCfg
1074  * @return void
1075  *
1076  *****************************************************************/
1077 void fillDefaultAmInfo(AmBearerCfg *amCfg)
1078 {
1079    /* DL AM */
1080    amCfg->dlAmCfg.snLenDl     = AM_SIZE_12;
1081    amCfg->dlAmCfg.pollRetxTmr = POLL_RETX_TMR_45MS;
1082    amCfg->dlAmCfg.pollPdu     = POLL_PDU_TMR_INFINITY;
1083    amCfg->dlAmCfg.pollByte    = POLL_BYTES_INFINITY;
1084    amCfg->dlAmCfg.maxRetxTh   = RETX_TH_8;
1085
1086    /* UL AM */
1087    amCfg->ulAmCfg.snLenUl     = AM_SIZE_12;
1088    amCfg->ulAmCfg.reAssemTmr  = RE_ASM_40MS;
1089    amCfg->ulAmCfg.statProhTmr = PROH_35MS;
1090 }
1091
1092 /******************************************************************
1093  *
1094  * @brief Fills RLC UM Bi Directional Information
1095  *
1096  * @details
1097  *
1098  *    Function : fillDefaultUmBiInfo
1099  *
1100  *    Functionality: Fills RLC UM Bi Directional Information
1101  *
1102  * @params[in]  UmBiDirBearerCfg *umBiDirCfg
1103  * @return void
1104  *
1105  *****************************************************************/
1106 void fillDefaultUmBiInfo(UmBiDirBearerCfg *umBiDirCfg)
1107 {
1108    /* UL UM BI DIR INFO */
1109    umBiDirCfg->ulUmCfg.snLenUlUm = UM_SIZE_12;
1110    umBiDirCfg->ulUmCfg.reAssemTmr = RE_ASM_40MS;
1111
1112    /* DL UM BI DIR INFO */
1113    umBiDirCfg->dlUmCfg.snLenDlUm  = UM_SIZE_12;
1114 }
1115
1116 /******************************************************************
1117  *
1118  * @brief Fills RLC UM Uni Directional UL Information
1119  *
1120  * @details
1121  *
1122  *    Function : fillDefaultUmUlInfo
1123  *
1124  *    Functionality: Fills RLC UM Uni Directional Info
1125  *
1126  * @params[in]  UmUniDirUlBearerCfg *UmUlCfg
1127  * @return void
1128  *
1129  *****************************************************************/
1130 void fillDefaultUmUlInfo(UmUniDirUlBearerCfg *UmUlCfg)
1131 {
1132    UmUlCfg->ulUmCfg.snLenUlUm = UM_SIZE_12;
1133    UmUlCfg->ulUmCfg.reAssemTmr = RE_ASM_40MS;
1134 }
1135
1136 /******************************************************************
1137  *
1138  * @brief Fills RLC UM Uni Directional DL Information
1139  *
1140  * @details
1141  *
1142  *    Function : fillDefaultUmDlInfo
1143  *
1144  *    Functionality: Fills RLC UM Uni Directional DL Info
1145  *
1146  * @params[in]  UmUniDirDlBearerCfg *UmDlCfg
1147  * @return void
1148  *
1149  *****************************************************************/
1150 void fillDefaultUmDlInfo(UmUniDirDlBearerCfg *UmDlCfg)
1151 {
1152    UmDlCfg->dlUmCfg.snLenDlUm  = UM_SIZE_12;
1153 }
1154
1155 /******************************************************************
1156  *
1157  * @brief Builds Rlc Mode Default Configuration
1158  *
1159  * @details
1160  *
1161  *    Function : fillDefaultRlcModeCfg
1162  *
1163  *    Functionality: Builds Rlc Mode Default Configuration
1164  *
1165  * @params[in]  rlcMode, RlcBearerCfg *lcCfg
1166  * @return ROK/RFAILED
1167  *
1168  *****************************************************************/
1169
1170 uint8_t fillDefaultRlcModeCfg(uint8_t rlcMode, RlcBearerCfg *lcCfg)
1171 {
1172
1173    if(lcCfg)
1174    {
1175       switch(rlcMode)
1176       {
1177          case RLC_AM :
1178             {
1179                if(!lcCfg->u.amCfg)
1180                {
1181                  DU_ALLOC_SHRABL_BUF(lcCfg->u.amCfg, sizeof(AmBearerCfg));
1182                  if(lcCfg->u.amCfg)
1183                     fillDefaultAmInfo(lcCfg->u.amCfg);
1184                  else
1185                  {
1186                     DU_LOG("\n DU_APP: Memory Alloc failed at AmCfg at fillDefaultRlcModeCfg()");
1187                     return RFAILED;
1188                  }
1189                }
1190                break;
1191             }
1192          case RLC_UM_BI_DIRECTIONAL :
1193             {
1194                if(!lcCfg->u.umBiDirCfg)
1195                {
1196                  DU_ALLOC_SHRABL_BUF(lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
1197                  if(lcCfg->u.umBiDirCfg)
1198                     fillDefaultUmBiInfo(lcCfg->u.umBiDirCfg);
1199                  else
1200                  {
1201                     DU_LOG("\n DU_APP: Memory Alloc failed at UmBiDirCfg at fillDefaultRlcModeCfg()");
1202                     return RFAILED;
1203                  }
1204                }
1205                break;
1206             }
1207          case RLC_UM_UNI_DIRECTIONAL_UL :
1208             {
1209                if(!lcCfg->u.umUniDirUlCfg)
1210                {
1211                   DU_ALLOC_SHRABL_BUF(lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
1212                   if(lcCfg->u.umUniDirUlCfg)
1213                     fillDefaultUmUlInfo(lcCfg->u.umUniDirUlCfg);
1214                   else
1215                   {
1216                      DU_LOG("\n DU_APP: Memory Alloc failed at UmUniDirUlCfg at fillDefaultRlcModeCfg()");
1217                      return RFAILED;
1218                   }
1219                }
1220                break;
1221             }
1222          case RLC_UM_UNI_DIRECTIONAL_DL :
1223             {
1224                if(!lcCfg->u.umUniDirDlCfg)
1225                {
1226                   DU_ALLOC_SHRABL_BUF(lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
1227                   if(lcCfg->u.umUniDirDlCfg)
1228                    fillDefaultUmDlInfo(lcCfg->u.umUniDirDlCfg);
1229                   else
1230                   {
1231                      DU_LOG("\n DU_APP: Memory Alloc failed at UmUniDirDlCfg at fillDefaultRlcModeCfg()");
1232                      return RFAILED;
1233                   }
1234                }
1235                break;
1236             }
1237          default:
1238             DU_LOG("\nDUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
1239             return RFAILED;
1240       }
1241
1242    }
1243    else
1244    {
1245       DU_LOG("\nDUAPP: Received Lc Config is NULL");
1246       return RFAILED;
1247    }
1248    return ROK;
1249 }
1250
1251 /*******************************************************************
1252  *
1253  * @brief Function to fill Rlc Lc Cfg for SRB1
1254  *
1255  * @details
1256  *
1257  *    Function : fillRlcSrb1LcCfg
1258  *
1259  *    Functionality:
1260  *     Function to fill Rlc Lc Cfg for SRB1
1261  *
1262  *  @params[in]     Pointer to RlcBearerCfg
1263  *  @return ROK/RFAILED
1264  *
1265  *****************************************************************/
1266
1267 uint8_t fillRlcSrb1LcCfg(RlcBearerCfg *rlcLcCfg)
1268 {
1269    uint8_t ret = ROK;
1270
1271    rlcLcCfg->rbId   = SRB1_LCID;
1272    rlcLcCfg->rbType = RB_TYPE_SRB;
1273    rlcLcCfg->lcId   = SRB1_LCID;
1274    rlcLcCfg->lcType = LCH_DCCH;
1275    rlcLcCfg->rlcMode = RLC_AM;
1276    rlcLcCfg->configType = CONFIG_ADD;
1277    ret = fillDefaultRlcModeCfg(rlcLcCfg->rlcMode, rlcLcCfg);
1278    return ret;
1279 }
1280
1281 /*******************************************************************
1282  *
1283  * @brief Processes UE ReConfig Req to RLC UL
1284  *
1285  * @details
1286  *
1287  *    Function : sendUeReCfgReqToRlc
1288  *
1289  *    Functionality:
1290  *     Processes UE Reconfig Req to RLC UL
1291  *
1292  *  @params[in]     Pointer to RlcUeCfg
1293  *  @return ROK     - success
1294  *          RFAILED - failure
1295  *
1296  *****************************************************************/
1297
1298 uint8_t sendUeReCfgReqToRlc(RlcUeCfg *rlcUeCfg)
1299 {
1300    uint8_t ret;
1301    Pst pst;
1302
1303    FILL_PST_DUAPP_TO_RLC(pst, RLC_UL_INST, EVENT_RLC_UE_RECONFIG_REQ);
1304    if(rlcUeCfg)
1305    {
1306       /* Processing one Ue at a time to RLC */
1307       DU_LOG("\nDU_APP: Sending Reconfig Request to RLC UL");
1308       ret = (*packRlcUeReconfigReqOpts[pst.selector])(&pst, rlcUeCfg);
1309       if(ret == RFAILED)
1310       {
1311          DU_LOG("\nDU_APP : Failed to send Ue Reconfig Req to RLC at sendUeReCfgReqToRlc()");
1312          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, rlcUeCfg, sizeof(RlcUeCfg));
1313       }
1314    }
1315    else
1316    {
1317       DU_LOG("\n DU_APP: Received RlcUeCfg is NULL at sendUeReCfgReqToRlc()");
1318       ret = RFAILED;
1319    }
1320    return ret;
1321 }
1322
1323 /******************************************************************
1324  *
1325  * @brief Fills RlcBearerCfg structure
1326  *
1327  * @details
1328  *
1329  *    Function : fillRlcUeCfg
1330  *
1331  *    Functionality: Fills Rlc Bearer Cfg
1332  *
1333  *
1334  *****************************************************************/
1335 uint8_t fillRlcUeCfg(uint16_t cellId, uint8_t ueIdx,\
1336    DuUeCfg *ueCfgDb, RlcUeCfg *rlcUeCfg)
1337 {
1338    uint8_t ret, dbIdx, lcIdx, cellIdx;
1339    bool lcIdFound = false;
1340    RlcUeCfg *duRlcDb = NULLP;
1341
1342    ret = ROK;
1343    if(!ueCfgDb)
1344    {
1345       /* Initial RB being Added */
1346       rlcUeCfg->cellId       = cellId;
1347       rlcUeCfg->ueIdx        = ueIdx;
1348       ret = fillRlcSrb1LcCfg(&rlcUeCfg->rlcLcCfg[0]);
1349       if(ret == ROK)
1350          rlcUeCfg->numLcs++;
1351       else
1352          memset(rlcUeCfg, 0, sizeof(RlcUeCfg));
1353    }
1354    else
1355    {
1356       /* Fetch RlcDb from DuUeCb */
1357       GET_CELL_IDX(cellId, cellIdx);
1358       duRlcDb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].rlcUeCfg;
1359       /*Filling RlcUeCfg */
1360       rlcUeCfg->cellId       = cellId;
1361       rlcUeCfg->ueIdx        = ueIdx;
1362       for(dbIdx = 0; (dbIdx < ueCfgDb->numRlcLcs && ret == ROK); dbIdx++)
1363       {
1364          ret = fillDefaultRlcModeCfg(ueCfgDb->rlcLcCfg[dbIdx].rlcMode, &ueCfgDb->rlcLcCfg[dbIdx]);
1365          if(ret == RFAILED)
1366          {
1367             DU_LOG("\n DU_APP: Failed to fill Rlc Mode at fillRlcUeCfg()");
1368             memset(rlcUeCfg, 0, sizeof(RlcUeCfg));
1369             return ret;
1370          }
1371          /* Fill Rlc Ue Cfg List for ADD/MOD/DEL */
1372          for(lcIdx = 0; lcIdx < duRlcDb->numLcs; lcIdx++)
1373          {
1374             if(ueCfgDb->rlcLcCfg[dbIdx].lcId == duRlcDb->rlcLcCfg[lcIdx].lcId)
1375             {
1376                lcIdFound = true;
1377                if((ueCfgDb->rlcLcCfg[dbIdx].configType == CONFIG_UNKNOWN)||
1378                      (ueCfgDb->rlcLcCfg[dbIdx].configType == CONFIG_MOD))
1379                {
1380                   /* MOD */
1381                   ueCfgDb->rlcLcCfg[dbIdx].configType = CONFIG_MOD; /* update Db for MOD type */
1382                   memcpy(&rlcUeCfg->rlcLcCfg[dbIdx], &ueCfgDb->rlcLcCfg[dbIdx], sizeof(RlcBearerCfg));
1383                }
1384             }
1385             else
1386                lcIdFound = false;
1387          }
1388          if(!lcIdFound)
1389          {
1390             /* ADD/ DEL Config Type */
1391             memcpy(&rlcUeCfg->rlcLcCfg[dbIdx], &ueCfgDb->rlcLcCfg[dbIdx], sizeof(RlcBearerCfg));
1392          }
1393          rlcUeCfg->numLcs++;
1394       }
1395    }
1396    return ret;
1397 }
1398
1399 /******************************************************************
1400  *
1401  * @brief creates UE context
1402  *
1403  * @details
1404  *
1405  *    Function : duCreateUeCb
1406  *
1407  *    Functionality: Creates UE Conetxt
1408  *
1409  * @params[in] UeCcchCtxt Pointer
1410  *             UeIdx Pointer
1411  *
1412  * @return ROK     - success
1413  *         RFAILED - failure
1414  * ****************************************************************/
1415 uint8_t duCreateUeCb(UeCcchCtxt *ueCcchCtxt, uint32_t gnbCuUeF1apId)
1416 {
1417    uint8_t cellIdx = 0;
1418    uint8_t ret     = ROK;
1419    uint8_t ueIdx;
1420
1421    for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
1422    {
1423       if(ueCcchCtxt->cellId == duCb.actvCellLst[cellIdx]->cellId)
1424       {
1425          GET_UE_IDX(ueCcchCtxt->crnti, ueIdx);
1426          DU_LOG("\nDU_APP: Filling UeCb for ueIdx [%d]", ueIdx);
1427
1428          duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].f1UeDb        = NULLP;
1429          duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].crnti         = ueCcchCtxt->crnti;
1430          duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId = ueCcchCtxt->gnbDuUeF1apId;
1431          duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId = gnbCuUeF1apId;
1432          duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].drbBitMap     = NULLP;
1433          duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].ueState       = UE_ACTIVE;
1434
1435          /* Filling Mac Ue Config */
1436          memset(&duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].macUeCfg, 0, sizeof(MacUeCfg));
1437          ret = duBuildAndSendUeCreateReqToMac(ueCcchCtxt->cellId, ueIdx, ueCcchCtxt->crnti,\
1438                 &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].macUeCfg);
1439          if(ret == RFAILED)
1440             DU_LOG("\nDU_APP: Failed to send UE create request to MAC");
1441
1442          /* Filling Rlc Ue Config */
1443          memset(&duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].rlcUeCfg, 0, sizeof(RlcUeCfg));
1444          ret = duBuildAndSendUeCreateReqToRlc(ueCcchCtxt->cellId, ueIdx, \
1445                 &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].rlcUeCfg);
1446          if(ret == RFAILED)
1447             DU_LOG("\nDU_APP: Failed to send UE create request to RLC");
1448
1449          duCb.actvCellLst[cellIdx]->numActvUes++;
1450          memset(ueCcchCtxt, 0, sizeof(UeCcchCtxt));
1451       }
1452    }
1453    return ret;
1454 }
1455
1456 /******************************************************************
1457  *
1458  * @brief Builds and Send UE Create Request to MAC
1459  *
1460  * @details
1461  *
1462  *    Function : duBuildAndSendUeCreateReqToMac
1463  *
1464  *    Functionality: Builds and Send UE Create Request to MAC
1465  *
1466  * @Params[in]  cellId,
1467  *              ueIdx
1468  * @return ROK     - success
1469  *         RFAILED - failure
1470  *
1471  * ****************************************************************/
1472
1473 uint8_t duBuildAndSendUeCreateReqToMac(uint16_t cellId, uint8_t ueIdx,\
1474    uint16_t crnti, MacUeCfg *duMacUeCfg)
1475 {
1476    uint8_t  ret = ROK;
1477    MacUeCfg *macUeCfg = NULLP;
1478    Pst       pst;
1479    memset(&pst, 0, sizeof(Pst));
1480
1481
1482    ret = fillMacUeCfg(cellId, ueIdx, crnti, NULL, duMacUeCfg);
1483    if(ret == RFAILED)
1484    {
1485       DU_LOG("\nDU APP: Failed to fill MacUeCfg at duBuildAndSendUeCreateReqToMac()");
1486       return RFAILED;
1487    }
1488    /* Fill Pst */
1489    FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_UE_CREATE_REQ);
1490
1491    /* Copying ueCb to a sharable buffer */
1492    DU_ALLOC_SHRABL_BUF(macUeCfg, sizeof(MacUeCfg));
1493    if(macUeCfg)
1494    {
1495       memset(macUeCfg, 0, sizeof(MacUeCfg));
1496       memcpy(macUeCfg, &duCb.actvCellLst[cellId - 1]->ueCb[ueIdx -1].macUeCfg, sizeof(MacUeCfg));
1497       DU_LOG("\nDU_APP: Sending UE create request to MAC");
1498
1499       /* Processing one Ue at a time to MAC */
1500       ret = (*packMacUeCreateReqOpts[pst.selector])(&pst, macUeCfg);
1501       if(ret == RFAILED)
1502       {
1503          DU_LOG("\nDU_APP : Failure in sending Ue Create Req to MAC at duBuildAndSendUeCreateReqToMac()");
1504          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, macUeCfg, sizeof(MacUeCfg));
1505       }
1506    }
1507    else
1508    {
1509       DU_LOG("\n DU_APP: Memory alloc failed at duBuildAndSendUeCreateReqToMac()");
1510       ret = RFAILED;
1511    }
1512    return ret;
1513 }
1514
1515 /*******************************************************************
1516  *
1517  * @brief To update DuUeCb Mac Cfg
1518  *
1519  * @details
1520  *
1521  *    Function : duUpdateMacCfg
1522  *    Functionality:  update DuUeCb MAC Cfg
1523  *
1524  * @params[in] DuUeCb Pointer
1525  *             F1UeContextSetupDb pointer
1526  * @return ROK     - success
1527  *         RFAILED - failure
1528  *
1529  * ****************************************************************/
1530 uint8_t duUpdateMacCfg(MacUeCfg *macUeCfg, F1UeContextSetupDb *f1UeDb)
1531 {
1532    uint8_t ret, lcIdx, dbIdx, numLcs, lcDelIdx;
1533    ret = ROK;
1534
1535    /*Filling Cell Group Cfg*/
1536    ret =  procUeReCfgCellInfo(macUeCfg, f1UeDb->duUeCfg.cellGrpCfg);
1537    if(ret == ROK)
1538    {
1539       ret = getMaxAggrBitRate(macUeCfg->maxAggrBitRate, f1UeDb->duUeCfg.maxAggrBitRate);
1540    }
1541    /* Filling LC Context */
1542    for(dbIdx = 0; (dbIdx < f1UeDb->duUeCfg.numMacLcs && ret == ROK); dbIdx++)
1543    {
1544       numLcs = macUeCfg->numLcs;
1545       for(lcIdx = 0; lcIdx < numLcs; lcIdx++)
1546       {
1547          if(f1UeDb->duUeCfg.macLcCfg[dbIdx].lcId ==  macUeCfg->lcCfgList[lcIdx].lcId)
1548          {
1549             if(f1UeDb->duUeCfg.macLcCfg[dbIdx].configType == CONFIG_MOD)
1550             {
1551                ret = fillMacLcCfgToAddMod(&macUeCfg->lcCfgList[lcIdx],&f1UeDb->duUeCfg.macLcCfg[dbIdx]);
1552             }
1553             else if(f1UeDb->duUeCfg.macLcCfg[dbIdx].configType == CONFIG_DEL)
1554             {
1555                /* Free memory at matched  lcIdx index */
1556                freeMacLcCfg(&macUeCfg->lcCfgList[lcIdx]);
1557                macUeCfg->numLcs--;
1558                for(lcDelIdx = lcIdx; lcDelIdx < macUeCfg->numLcs; lcDelIdx++)
1559                {
1560                   /* moving all elements one index ahead */
1561                   ret = fillMacLcCfgToAddMod(&macUeCfg->lcCfgList[lcDelIdx], &macUeCfg->lcCfgList[lcDelIdx+1]);
1562                   freeMacLcCfg(&macUeCfg->lcCfgList[lcDelIdx+1]);
1563                   if(ret == RFAILED)
1564                   {
1565                      DU_LOG("\nDU_APP: Failed to delete LC at Idx %d in duUpdateMacCfg()", lcDelIdx);
1566                      break;
1567                   }
1568                }
1569             }
1570          }
1571       }
1572       if(f1UeDb->duUeCfg.macLcCfg[dbIdx].configType == CONFIG_ADD)
1573       {
1574          ret = fillMacLcCfgToAddMod(&macUeCfg->lcCfgList[numLcs], &f1UeDb->duUeCfg.macLcCfg[dbIdx]);
1575          if(ret == RFAILED)
1576          {
1577             DU_LOG("\nDU_APP: Failed to add LC at Idx %d in duUpdateMacCfg()", numLcs);
1578             break;
1579          }
1580          macUeCfg->numLcs++;
1581       }
1582
1583    }
1584    return ret;
1585 }
1586
1587 /******************************************************************
1588  *
1589  * @brief Function to fill the RLC Lc cfg from ueSetupReqDb
1590  *
1591  * @details
1592  *
1593  *    Function : fillRlcCfgToAddMod
1594  *
1595  *    Functionality: Function to fill the RLC Lc cfg from ueSetupReqDb
1596  *
1597  *
1598  *****************************************************************/
1599
1600 uint8_t fillRlcCfgToAddMod(RlcBearerCfg *lcCfg, RlcBearerCfg *f1UeDbLcCfg)
1601 {
1602    lcCfg->configType = f1UeDbLcCfg->configType;
1603    lcCfg->rbId       = f1UeDbLcCfg->rbId;
1604    lcCfg->rbType     = f1UeDbLcCfg->rbType;
1605    lcCfg->lcId       = f1UeDbLcCfg->lcId;
1606    lcCfg->lcType     = f1UeDbLcCfg->lcType;
1607    lcCfg->rlcMode    = f1UeDbLcCfg->rlcMode;
1608    switch(lcCfg->rlcMode)
1609    {
1610       case RLC_AM :
1611       {
1612          if(!lcCfg->u.amCfg)
1613          {
1614             DU_ALLOC_SHRABL_BUF(lcCfg->u.amCfg, sizeof(AmBearerCfg));
1615             if(!lcCfg->u.amCfg)
1616                return RFAILED;
1617          }
1618          /* DL AM */
1619          lcCfg->u.amCfg->dlAmCfg.snLenDl     = f1UeDbLcCfg->u.amCfg->dlAmCfg.snLenDl;
1620          lcCfg->u.amCfg->dlAmCfg.pollRetxTmr = f1UeDbLcCfg->u.amCfg->dlAmCfg.pollRetxTmr;
1621          lcCfg->u.amCfg->dlAmCfg.pollPdu     = f1UeDbLcCfg->u.amCfg->dlAmCfg.pollPdu;
1622          lcCfg->u.amCfg->dlAmCfg.pollByte    = f1UeDbLcCfg->u.amCfg->dlAmCfg.pollByte;
1623          lcCfg->u.amCfg->dlAmCfg.maxRetxTh   = f1UeDbLcCfg->u.amCfg->dlAmCfg.maxRetxTh;
1624
1625          /* UL AM */
1626          lcCfg->u.amCfg->ulAmCfg.snLenUl     = f1UeDbLcCfg->u.amCfg->ulAmCfg.snLenUl;
1627          lcCfg->u.amCfg->ulAmCfg.reAssemTmr  = f1UeDbLcCfg->u.amCfg->ulAmCfg.reAssemTmr;
1628          lcCfg->u.amCfg->ulAmCfg.statProhTmr = f1UeDbLcCfg->u.amCfg->ulAmCfg.statProhTmr;
1629          break;
1630       }
1631       case RLC_UM_BI_DIRECTIONAL :
1632       {
1633          if(!lcCfg->u.umBiDirCfg)
1634          {
1635             DU_ALLOC_SHRABL_BUF(lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
1636             if(!lcCfg->u.umBiDirCfg)
1637                 return RFAILED;
1638          }
1639          /* UL UM BI DIR INFO */
1640          lcCfg->u.umBiDirCfg->ulUmCfg.snLenUlUm  = f1UeDbLcCfg->u.umBiDirCfg->ulUmCfg.snLenUlUm;
1641          lcCfg->u.umBiDirCfg->ulUmCfg.reAssemTmr = f1UeDbLcCfg->u.umBiDirCfg->ulUmCfg.reAssemTmr;
1642          /* DL UM BI DIR INFO */
1643          lcCfg->u.umBiDirCfg->dlUmCfg.snLenDlUm  = f1UeDbLcCfg->u.umBiDirCfg->dlUmCfg.snLenDlUm;
1644          break;
1645       }
1646       case RLC_UM_UNI_DIRECTIONAL_UL :
1647       {
1648          if(!lcCfg->u.umUniDirUlCfg)
1649          {
1650             DU_ALLOC_SHRABL_BUF(lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
1651             if(!lcCfg->u.umUniDirUlCfg)
1652                return RFAILED;
1653          }
1654          lcCfg->u.umUniDirUlCfg->ulUmCfg.snLenUlUm  = f1UeDbLcCfg->u.umUniDirUlCfg->ulUmCfg.snLenUlUm;
1655          lcCfg->u.umUniDirUlCfg->ulUmCfg.reAssemTmr = f1UeDbLcCfg->u.umUniDirUlCfg->ulUmCfg.reAssemTmr;
1656          break;
1657
1658       }
1659       case RLC_UM_UNI_DIRECTIONAL_DL :
1660       {
1661          if(!lcCfg->u.umUniDirDlCfg)
1662          {
1663             DU_ALLOC_SHRABL_BUF(lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
1664             if(!lcCfg->u.umUniDirDlCfg)
1665                return RFAILED;
1666          }
1667          lcCfg->u.umUniDirDlCfg->dlUmCfg.snLenDlUm  = f1UeDbLcCfg->u.umUniDirDlCfg->dlUmCfg.snLenDlUm;
1668          break;
1669       }
1670       default:
1671          DU_LOG("\nDU_APP: Invalid Rlc Mode %d at fillRlcCfgToAddMod()", lcCfg->rlcMode);
1672          return RFAILED;
1673    }
1674    return ROK;
1675 }
1676
1677 /*******************************************************************
1678  *
1679  * @brief To update DuUeCb Rlc Lc Cfg
1680  *
1681  * @details
1682  *
1683  *    Function : duUpdateRlcLcCfg
1684  *    Functionality:  update DuUeCb Rlc Lc Cfg
1685  *
1686  * @params[in] DuUeCb Pointer
1687  *             F1UeContextSetupDb pointer
1688  * @return ROK     - success
1689  *         RFAILED - failure
1690  *
1691  * ****************************************************************/
1692
1693 uint8_t duUpdateRlcLcCfg(RlcUeCfg *rlcUeCfg, F1UeContextSetupDb *f1UeDb)
1694 {
1695    uint8_t ret, lcIdx, dbIdx, numLcs, lcDelIdx;
1696
1697    ret = ROK;
1698    for(dbIdx = 0; (dbIdx < f1UeDb->duUeCfg.numRlcLcs && ret ==ROK); dbIdx++)
1699    {
1700       numLcs = rlcUeCfg->numLcs;
1701       for(lcIdx = 0; lcIdx < numLcs; lcIdx++)
1702       {
1703          if(f1UeDb->duUeCfg.rlcLcCfg[dbIdx].lcId == rlcUeCfg->rlcLcCfg[lcIdx].lcId)
1704          {
1705             if(f1UeDb->duUeCfg.rlcLcCfg[dbIdx].configType == CONFIG_MOD)
1706             {
1707                ret = fillRlcCfgToAddMod(&rlcUeCfg->rlcLcCfg[lcIdx], &f1UeDb->duUeCfg.rlcLcCfg[dbIdx]);
1708             }
1709             else if(f1UeDb->duUeCfg.rlcLcCfg[dbIdx].configType == CONFIG_DEL)
1710             {
1711                /* Free memory at matched lcIdx index */
1712                freeRlcLcCfg(&rlcUeCfg->rlcLcCfg[lcIdx]);
1713                rlcUeCfg->numLcs--;
1714                for(lcDelIdx = lcIdx; lcDelIdx < rlcUeCfg->numLcs; lcDelIdx++)
1715                {
1716                   ret = fillRlcCfgToAddMod(&rlcUeCfg->rlcLcCfg[lcDelIdx], &rlcUeCfg->rlcLcCfg[lcDelIdx+1]);
1717                   freeRlcLcCfg(&rlcUeCfg->rlcLcCfg[lcDelIdx+1]);
1718                   if(ret == RFAILED)
1719                   {
1720                      DU_LOG("\nDU_APP: Failed to delete LC at Idx %d in duUpdateRlcCfg()", lcDelIdx);
1721                      break;
1722                   }
1723                }
1724             }
1725          }
1726       }
1727       if(f1UeDb->duUeCfg.rlcLcCfg[dbIdx].configType == CONFIG_ADD)
1728       {
1729          ret = fillRlcCfgToAddMod(&rlcUeCfg->rlcLcCfg[lcIdx], &f1UeDb->duUeCfg.rlcLcCfg[dbIdx]);
1730          if(ret == ROK)
1731             rlcUeCfg->numLcs++;
1732       }
1733    }
1734    return ret;
1735 }
1736
1737
1738 /*******************************************************************
1739  *
1740  * @brief @brief To update DuUeCb Mac and Rlc Ue Cfg
1741  *
1742  *
1743  * @details
1744  *
1745  *    Function : duUpdateDuUeCbCfg
1746  *
1747  *    Functionality: update DuUeCb Mac and Rlc Ue Cfg
1748  *
1749  * @params[in] ueIdx, cellIdx
1750  * @return ROK     - success
1751  *         RFAILED - failure
1752  *
1753  * ****************************************************************/
1754
1755 uint8_t duUpdateDuUeCbCfg(uint8_t ueIdx, uint8_t cellId)
1756 {
1757    uint8_t ret = ROK, cellIdx = 0, crnti=0;
1758    DuUeCb *ueCb = NULLP;
1759
1760    GET_CELL_IDX(cellId, cellIdx);
1761
1762    if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].macUeCfg. \
1763          macUeCfgState == UE_RECFG_COMPLETE) &&
1764       (duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].rlcUeCfg. \
1765          rlcUeCfgState == UE_RECFG_COMPLETE))
1766    {
1767       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
1768
1769       /*Filling RLC Ue Cfg */
1770       ueCb->rlcUeCfg.cellId = cellId;
1771       ueCb->rlcUeCfg.ueIdx  = ueIdx;
1772       ret = duUpdateRlcLcCfg(&ueCb->rlcUeCfg, ueCb->f1UeDb);
1773       if(ret == ROK)
1774       {
1775          /*Filling MAC Ue Cfg */
1776          GET_CRNTI(crnti, ueIdx);
1777          ueCb->macUeCfg.cellId = cellId;
1778          ueCb->macUeCfg.ueIdx  = ueIdx;
1779          ueCb->macUeCfg.crnti  = crnti;
1780          ret = duUpdateMacCfg(&ueCb->macUeCfg, ueCb->f1UeDb);
1781          if(ret == RFAILED)
1782             DU_LOG("\nDU APP: Failed while updating MAC LC Config at duUpdateDuUeCbCfg()");
1783       }
1784       else
1785          DU_LOG("\nDU APP: Failed while updating RLC LC Config at duUpdateDuUeCbCfg()");
1786    }
1787    else
1788       ret = RFAILED;
1789    return ret;
1790 }
1791
1792 /*******************************************************************
1793  *
1794  * @brief Handle UE config response from MAC
1795  *
1796  * @details
1797  *
1798  *    Function : DuProcMacUeCfgRsp
1799  *
1800  *    Functionality: Handle UE Config response from MAC
1801  *
1802  * @params[in] Pointer to MacUeCfgRsp and Pst
1803  * @return ROK     - success
1804  *         RFAILED - failure
1805  *
1806  * ****************************************************************/
1807 uint8_t DuProcMacUeCfgRsp(Pst *pst, MacUeCfgRsp *cfgRsp)
1808 {
1809    uint8_t ret = ROK;
1810
1811    if(cfgRsp)
1812    {
1813       if(cfgRsp->result == MAC_DU_APP_RSP_OK)
1814       {
1815          if(pst->event == EVENT_MAC_UE_CREATE_RSP)
1816          {
1817             DU_LOG("\nDU APP : MAC UE Create Response : SUCCESS [UE IDX : %d]", cfgRsp->ueIdx);
1818             duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueIdx -1].\
1819                macUeCfg.macUeCfgState = UE_CREATE_COMPLETE;
1820          }
1821          else if(pst->event == EVENT_MAC_UE_RECONFIG_RSP)
1822          {
1823             DU_LOG("\nDU APP : MAC UE Reconfig Response : SUCCESS [UE IDX : %d]", cfgRsp->ueIdx);
1824             duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueIdx -1].\
1825                macUeCfg.macUeCfgState = UE_RECFG_COMPLETE;
1826             if((ret = duUpdateDuUeCbCfg(cfgRsp->ueIdx, cfgRsp->cellId)) == ROK)
1827                BuildAndSendUeCtxtRsp(cfgRsp->ueIdx, cfgRsp->cellId);
1828          }
1829       }
1830       else
1831       {
1832          DU_LOG("\nDU APP : MAC UE CFG Response for EVENT[%d]: FAILURE [UE IDX : %d]", pst->event, cfgRsp->ueIdx);
1833          if(pst->event == EVENT_MAC_UE_RECONFIG_RSP)
1834          {
1835             //TODO: Send the failure case in Ue Context Setup Response
1836          }
1837          ret = RFAILED;
1838       }
1839       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(MacUeCfgRsp));
1840    }
1841    else
1842    {
1843       DU_LOG("\nDU APP : Received MAC Ue Config Response is NULL at DuProcMacUeCfgRsp()");
1844       ret = RFAILED;
1845    }
1846    return ret;
1847 }
1848
1849
1850 /*******************************************************************
1851  *
1852  * @brief Processes UE create Req to RLC UL
1853  *
1854  * @details
1855  *
1856  *    Function : duBuildAndSendUeCreateReqToRlc
1857  *
1858  *    Functionality:
1859  *     Processes UE create Req to RLC UL
1860  *
1861  *  @params[in]  cellId,
1862  *               ueIdx,
1863  *               Pointer to RlcUeCfg
1864  *  @return ROK     - success
1865  *          RFAILED - failure
1866  *
1867  *****************************************************************/
1868
1869 uint8_t duBuildAndSendUeCreateReqToRlc(uint16_t cellId, uint8_t ueIdx,\
1870    RlcUeCfg *duRlcUeCfg)
1871 {
1872    uint8_t  ret = ROK;
1873    RlcUeCfg *rlcUeCfg = NULLP;
1874    Pst       pst;
1875
1876    ret = fillRlcUeCfg(cellId, ueIdx, NULL, duRlcUeCfg);
1877    if(ret == RFAILED)
1878    {
1879       DU_LOG("\nDU_APP: Failed to fill Rlc Ue Cfg at duBuildAndSendUeCreateReqToRlc()");
1880       return ret;
1881    }
1882
1883    FILL_PST_DUAPP_TO_RLC(pst, RLC_UL_INST, EVENT_RLC_UE_CREATE_REQ);
1884    /* Copying ueCfg to a sharable buffer */
1885    DU_ALLOC_SHRABL_BUF(rlcUeCfg, sizeof(RlcUeCfg));
1886    if(rlcUeCfg)
1887    {
1888       memset(rlcUeCfg, 0, sizeof(RlcUeCfg));
1889       memcpy(rlcUeCfg, duRlcUeCfg, sizeof(RlcUeCfg));
1890       /* Processing one Ue at a time to RLC */
1891       DU_LOG("\nDU_APP: Sending UE create request to RLC UL");
1892       ret = (*packRlcUeCreateReqOpts[pst.selector])(&pst, rlcUeCfg);
1893       if(ret == RFAILED)
1894       {
1895          DU_LOG("\nDU_APP : Failure in sending Ue Create Req to RLC");
1896          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, rlcUeCfg, sizeof(RlcUeCfg));
1897          ret = RFAILED;
1898       }
1899    }
1900    else
1901    {
1902       DU_LOG("\n DU_APP: Memory alloc failed at duBuildAndSendUeCreateReqToRlc()");
1903       ret = RFAILED;
1904    }
1905    return ret;
1906 }
1907
1908 /*******************************************************************
1909  *
1910  * @brief Processes UE create Rsp received from RLC UL
1911  *
1912  * @details
1913  *
1914
1915  *    Function : DuProcRlcUeCfgRsp
1916  *
1917  *    Functionality:
1918  *     Processes UE create Rsp received from RLC UL
1919  *
1920  *  @params[in]  Post structure
1921  *               Pointer to RlcCfgCfm
1922  *  @return ROK     - success
1923  *          RFAILED - failure
1924  *
1925  *****************************************************************/
1926 uint8_t DuProcRlcUeCfgRsp(Pst *pst, RlcUeCfgRsp *cfgRsp)
1927 {
1928    uint8_t ret = ROK;
1929
1930    if(cfgRsp)
1931    {
1932       if(cfgRsp->result == RLC_DU_APP_RSP_OK)
1933       {
1934          if(pst->event == EVENT_RLC_UE_CREATE_RSP)
1935          {
1936             DU_LOG("\nDU_APP: RLC UE Create Response : SUCCESS [UE IDX:%d]", cfgRsp->ueIdx);
1937             duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueIdx -1].\
1938                rlcUeCfg.rlcUeCfgState = UE_CREATE_COMPLETE;
1939          }
1940          else if(pst->event == EVENT_RLC_UE_RECONFIG_RSP)
1941          {
1942             DU_LOG("\nDU_APP: RLC UE Reconfig Response : SUCCESS [UE IDX:%d]", cfgRsp->ueIdx);
1943             duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueIdx -1].\
1944                rlcUeCfg.rlcUeCfgState = UE_RECFG_COMPLETE;
1945             if((ret = duUpdateDuUeCbCfg(cfgRsp->ueIdx, cfgRsp->cellId)) == ROK)
1946                BuildAndSendUeCtxtRsp(cfgRsp->ueIdx, cfgRsp->cellId);
1947
1948          }
1949       }
1950       else
1951       {
1952          DU_LOG("\nDU_APP: RLC UE CFG Response for EVENT[%d] : FAILED [UE IDX : %d, REASON :%d]",\
1953             pst->event, cfgRsp->ueIdx, cfgRsp->reason);
1954          if((pst->event == EVENT_RLC_UE_RECONFIG_RSP))
1955          {
1956             //TODO: update failure case in ue Context setup Response
1957          }
1958          ret = RFAILED;
1959       }
1960       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(RlcUeCfgRsp));
1961    }
1962    else
1963    {
1964       DU_LOG("\nDU_APP: Received RLC Ue Config Response is NULL at DuProcRlcUeCfgRsp()");
1965       ret = RFAILED;
1966    }
1967    return ret;
1968 }
1969
1970 /*******************************************************************
1971  *
1972  * @brief Builds and Send Ue Reconfig Req to RLC
1973  *
1974  * @details
1975  *
1976  *    Function : duBuildAndSendUeReCfgReqToRLC
1977  *
1978  *    Functionality: Builds and Send Ue Reconfig Req to RLC
1979  *
1980  * @params[in] cellId, crnti
1981  *             DuUeCfg *ueCfgDb
1982  *             RlcUeCfg *rlcUeCfg
1983  * @return ROK     - success
1984  *         RFAILED - failure
1985  *
1986  * ****************************************************************/
1987
1988 uint8_t duBuildAndSendUeReCfgReqToRlc(uint8_t cellId, uint8_t crnti, DuUeCfg *ueCfgDb)
1989 {
1990    uint8_t ret = ROK, ueIdx = 0;
1991    RlcUeCfg *rlcUeCfg = NULLP;
1992
1993    GET_UE_IDX(crnti, ueIdx);
1994    DU_ALLOC_SHRABL_BUF(rlcUeCfg, sizeof(RlcUeCfg));
1995    if(rlcUeCfg)
1996    {
1997       memset(rlcUeCfg, 0, sizeof(RlcUeCfg));
1998       ret = fillRlcUeCfg(cellId, ueIdx, ueCfgDb, rlcUeCfg);
1999       if(ret == RFAILED)
2000          DU_LOG("\nDU APP: Failed at duBuildAndSendUeReCfgReqToRlc()");
2001       else
2002          ret = sendUeReCfgReqToRlc(rlcUeCfg);
2003    }
2004    else
2005    {
2006       DU_LOG("\nDU APP: Memory Alloc failed at duBuildAndSendUeReCfgReqToRlc()");
2007       ret = RFAILED;
2008    }
2009    return ret;
2010 }
2011
2012 /*******************************************************************
2013  *
2014  * @brief Builds and Send Ue Reconfig Req to MAC
2015  *
2016  * @details
2017  *
2018  *    Function : duBuildAndSendUeReCfgReqToMac
2019  *
2020  *    Functionality: Builds and Send Ue Reconfig Req to MAC
2021  *
2022  * @params[in] CellGroupConfigRrc_t *macCellGrpCfg
2023  *             DuUeCfg *ueCfgDb
2024  *             MacUeCfg    *macUeCfg
2025  * @return ROK     - success
2026  *         RFAILED - failure
2027  *
2028  * ****************************************************************/
2029
2030 uint8_t duBuildAndSendUeReCfgReqToMac(uint8_t cellId, uint8_t crnti, DuUeCfg *ueCfgDb)
2031 {
2032    uint8_t ret, ueIdx = 0;
2033    MacUeCfg *macUeCfg = NULLP;
2034
2035    ret = ROK;
2036    GET_UE_IDX(crnti, ueIdx);
2037
2038    DU_ALLOC_SHRABL_BUF(macUeCfg, sizeof(MacUeCfg));
2039    if(macUeCfg)
2040    {
2041       memset(macUeCfg, 0, sizeof(MacUeCfg));
2042       ret = fillMacUeCfg(cellId, ueIdx, crnti, ueCfgDb, macUeCfg);
2043       if(ret == RFAILED)
2044          DU_LOG("\nDU_APP: Failed to fill Mac Ue Cfg at duBuildAndSendUeReCfgReqToMac()");
2045       else
2046          ret = sendUeReCfgReqToMac(macUeCfg);
2047    }
2048    else
2049    {
2050       DU_LOG("\nDU_APP: Memory alloc failed for macUeCfg at duBuildAndSendUeReCfgReqToMac()");
2051       ret = RFAILED;
2052    }
2053    return ret;
2054 }
2055
2056 /*******************************************************************
2057  *
2058  * @brief Process UE context setup request from CU
2059  *
2060  * @details
2061  *
2062  *    Function : duProcUeContextSetupRequest
2063  *
2064  *    Functionality: Process UE context setup request from CU
2065  *
2066  * @params[in] F1AP message
2067  * @return ROK     - success
2068  *         RFAILED - failure
2069  *
2070  * ****************************************************************/
2071
2072 uint8_t duProcUeContextSetupRequest(DuUeCb *ueCb)
2073 {
2074    uint8_t ret, cellId;
2075
2076    ret = ROK;
2077    if(ueCb)
2078    {
2079       cellId = duCb.actvCellLst[ueCb->f1UeDb->cellIdx]->cellId;
2080       if(ueCb->f1UeDb->dlRrcMsg)
2081       {
2082          if(ueCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
2083          {
2084             /* Sending DL RRC Message to RLC */
2085             ret = duBuildAndSendDlRrcMsgToRlc(cellId, ueCb->rlcUeCfg, ueCb->f1UeDb->dlRrcMsg);
2086             if(ret == RFAILED)
2087             {
2088                DU_LOG("\nDU APP : Failed to send DL RRC msg in duProcUeContextSetupRequest()");
2089                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCb->f1UeDb->dlRrcMsg->rrcMsgPdu,\
2090                ueCb->f1UeDb->dlRrcMsg->rrcMsgSize);
2091                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
2092             }
2093          }
2094       }
2095
2096       if(ret == ROK)
2097       {
2098          DU_LOG("\nDU_APP: Processing Ue Context Setup Request for cellId [%d]", cellId);
2099          /* Filling RLC Ue Reconfig */
2100          ret = duBuildAndSendUeReCfgReqToRlc(cellId, ueCb->crnti, &ueCb->f1UeDb->duUeCfg);
2101          if(ret == RFAILED)
2102             DU_LOG("\nDU_APP: Failed to build ctxt setup req for RLC at duBuildAndSendUeReCfgReqToRlc()");
2103
2104          /* Filling MAC Ue Reconfig */
2105          ret = duBuildAndSendUeReCfgReqToMac(cellId, ueCb->crnti, &ueCb->f1UeDb->duUeCfg);
2106          if(ret == RFAILED)
2107             DU_LOG("\nDU_APP: Failed at build ctxt setup req for MAC at duBuildAndSendUeReCfgReqToMac()");
2108       }
2109
2110    }
2111    else
2112    {
2113       //TODO: To send the failure cause in UeContextSetupRsp
2114       DU_LOG("DU_APP: Failed to process UE CNTXT SETUP REQ at duProcUeContextSetupRequest()");
2115    }
2116    return ret;
2117 }
2118
2119 /**********************************************************************
2120   End of file
2121  ***********************************************************************/