X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2Fdu_app%2Fdu_ue_mgr.c;h=818724add38c6f324c5cf0dab660af72f8714b7a;hb=def50dc175cebc67238db5f1acd5ff322a2279bd;hp=aed5cc026c0169d7de8e6744ae7036e638919464;hpb=aee73991f728cc127d1ed76d5a52571d916235a4;p=o-du%2Fl2.git diff --git a/src/du_app/du_ue_mgr.c b/src/du_app/du_ue_mgr.c index aed5cc026..818724add 100644 --- a/src/du_app/du_ue_mgr.c +++ b/src/du_app/du_ue_mgr.c @@ -37,7 +37,7 @@ #include "du_ue_mgr.h" #ifdef EGTP_TEST -U32 sduId = 0; +uint32_t sduId = 0; #endif DuMacDlCcchInd packMacDlCcchIndOpts[] = @@ -51,16 +51,36 @@ DuMacUeCreateReq packMacUeCreateReqOpts[] = { packDuMacUeCreateReq, /* Loose coupling */ MacProcUeCreateReq, /* TIght coupling */ - packDuMacUeCreateReq, /* Light weight-loose coupling */ + packDuMacUeCreateReq /* Light weight-loose coupling */ }; -DuRlcUlUeCreateReq packRlcUlUeCreateReqOpts[] = +DuRlcUeCreateReq packRlcUeCreateReqOpts[] = { - packDuRlcUlUeCreateReq, /* Loose coupling */ - RlcUlProcUeCreateReq, /* TIght coupling */ - packDuRlcUlUeCreateReq, /* Light weight-loose coupling */ + packDuRlcUeCreateReq, /* Loose coupling */ + RlcProcUeCreateReq, /* TIght coupling */ + packDuRlcUeCreateReq /* Light weight-loose coupling */ }; +DuDlRrcMsgToRlcFunc duSendDlRrcMsgToRlcOpts[] = +{ + packDlRrcMsgToRlc, /* Loose coupling */ + RlcProcDlRrcMsgTransfer, /* Tight coupling */ + packDlRrcMsgToRlc /* Light weight-loose coupling */ +}; + +DuRlcUeReconfigReq packRlcUeReconfigReqOpts[] = +{ + packDuRlcUeReconfigReq, /* Loose coupling */ + RlcProcUeReconfigReq, /* TIght coupling */ + packDuRlcUeReconfigReq /* Light weight-loose coupling */ +}; + +DuMacUeReconfigReq packMacUeReconfigReqOpts[] = +{ + packDuMacUeReconfigReq, /* Loose coupling */ + MacProcUeReconfigReq, /* TIght coupling */ + packDuMacUeReconfigReq /* Light weight-loose coupling */ +}; /******************************************************************* * * @brief Handles EGTP data from CU @@ -79,15 +99,15 @@ DuRlcUlUeCreateReq packRlcUlUeCreateReqOpts[] = * ****************************************************************/ uint8_t duHdlEgtpDlData(EgtpMsg *egtpMsg) { + /* TODO : Extract RbId/UeID/CellID/SduId from database using tunnel id in egtp header */ DU_LOG("\nDU_APP : Processing DL data"); - +#ifdef EGTP_TEST Pst pst; KwuDatReqInfo datReqInfo; -#ifdef EGTP_TEST datReqInfo.rlcId.rbId = RB_ID; datReqInfo.rlcId.rbType = CM_LTE_DRB; datReqInfo.rlcId.ueId = UE_ID; @@ -95,45 +115,20 @@ uint8_t duHdlEgtpDlData(EgtpMsg *egtpMsg) datReqInfo.sduId = ++sduId; datReqInfo.lcType = CM_LTE_LCH_DTCH; -#endif + /* Filling pst and Sending to RLC DL */ pst.selector = ODU_SELECTOR_LWLC; pst.srcEnt = ENTDUAPP; - pst.dstEnt = ENTKW; + pst.dstEnt = ENTRLC; pst.dstInst = RLC_DL_INST; pst.dstProcId = DU_PROC; pst.srcProcId = DU_PROC; pst.region = duCb.init.region; cmPkKwuDatReq(&pst, &datReqInfo, egtpMsg->msg); - return ROK; -} - -/******************************************************************* - * - * @brief Handles UL data and send to CU - * - * @details - * - * Function : duHdlRlcUlData - * - * Functionality: - * Processes UL Data from RLC and sends to CU - * - * @params[in] Pointer to EGTP Message - * @return ROK - success - * RFAILED - failure - * - *****************************************************************/ - -uint8_t duHdlRlcUlData(Pst *pst, KwuDatIndInfo* datInd, Buffer *mBuf) -{ - DU_LOG("\nDU_APP : Received UL Data at DU_APP"); - - /* Send UL data to CU via EGTP */ - duSendEgtpDatInd(mBuf); - ODU_PUT_MSG(mBuf); - +#else + //duBuildAndSendDlRrcMsgToRlc(); +#endif return ROK; } @@ -153,13 +148,12 @@ uint8_t duHdlRlcUlData(Pst *pst, KwuDatIndInfo* datInd, Buffer *mBuf) * * ****************************************************************/ uint8_t duBuildAndSendDlCcchInd(uint16_t *cellId, uint16_t *crnti, \ - DlCcchMsgType msgType, uint8_t *dlCcchMsg, uint16_t dlCcchMsgSize) + DlCcchMsgType msgType, uint16_t dlCcchMsgSize, uint8_t *dlCcchMsg) { - uint8_t ret = ROK; + uint8_t ret = ROK; uint16_t idx2; DlCcchIndInfo *dlCcchIndInfo = NULLP; Pst pst; - memset(&pst, 0, sizeof(Pst)); DU_LOG("\nDU APP : Building and Sending DL CCCH Ind to MAC"); @@ -206,6 +200,77 @@ uint8_t duBuildAndSendDlCcchInd(uint16_t *cellId, uint16_t *crnti, \ } +/******************************************************************* + * + * @brief Build and Send DL RRC Message transfer to RLC + * + * @details + * + * Function : duBuildAndSendDlRrcMsgToRlc + * + * Functionality: + * Build and Send DL RRC Message transfer to RLC + * + * @params[in] Cell ID + * UE Index + * Logical Channgel ID + * RRC Message + * RRC Message Length + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t duBuildAndSendDlRrcMsgToRlc(uint16_t cellId, RlcUeCfg ueCfg, \ + uint8_t lcId, bool execDup, bool deliveryStaReq, uint16_t rrcMsgLen, uint8_t *rrcMsg) +{ + Pst pst; + uint8_t ret; + uint8_t lcIdx; + RlcDlRrcMsgInfo *dlRrcMsgInfo; + + DU_ALLOC_SHRABL_BUF(dlRrcMsgInfo, sizeof(RlcDlRrcMsgInfo)); + if(!dlRrcMsgInfo) + { + DU_LOG("\nDU APP : Memory allocation failed for dlRrcMsgInfo in \ + duBuildAndSendDlRrcMsgToRlc"); + DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, rrcMsg, rrcMsgLen); + return RFAILED; + } + + /* Filling up the RRC msg info */ + dlRrcMsgInfo->cellId = cellId; + dlRrcMsgInfo->ueIdx = ueCfg.ueIdx; + for(lcIdx = 0; lcIdx <= MAX_NUM_LC; lcIdx++) + { + if(ueCfg.rlcLcCfg[lcIdx].lcId == lcId) + { + dlRrcMsgInfo->rbType = ueCfg.rlcLcCfg[lcIdx].rbType; + dlRrcMsgInfo->rbId = ueCfg.rlcLcCfg[lcIdx].rbId; + dlRrcMsgInfo->lcType = ueCfg.rlcLcCfg[lcIdx].lcType; + dlRrcMsgInfo->lcId = ueCfg.rlcLcCfg[lcIdx].lcId; + break; + } + } + dlRrcMsgInfo->execDup = execDup; + dlRrcMsgInfo->deliveryStaRpt = deliveryStaReq; + dlRrcMsgInfo->rrcMsg = rrcMsg; + dlRrcMsgInfo->msgLen = rrcMsgLen; + + /* Filling post structure and sending msg */ + FILL_PST_DUAPP_TO_RLC(pst, RLC_DL_INST, EVENT_DL_RRC_MSG_TRANS_TO_RLC); + ret = (*duSendDlRrcMsgToRlcOpts[pst.selector])(&pst, dlRrcMsgInfo); + if(ret != ROK) + { + DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, rrcMsg, rrcMsgLen); + DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, dlRrcMsgInfo, sizeof(RlcDlRrcMsgInfo)); + return RFAILED; + } + + return ROK; +} + + + /****************************************************************** * * @brief Processes DL RRC Message Transfer sent by CU @@ -224,99 +289,143 @@ uint8_t duBuildAndSendDlCcchInd(uint16_t *cellId, uint16_t *crnti, \ uint8_t procDlRrcMsgTrans(F1AP_PDU_t *f1apMsg) { DLRRCMessageTransfer_t *dlRrcMsg = NULLP; - uint8_t *dlCcchMsg = NULLP; - uint8_t idx, ret, srbId; - uint16_t idx2, crnti, cellId, dlCcchMsgSize; + uint8_t *rrcMsgPdu = NULLP; + uint8_t ieIdx, ueIdx, cellIdx; + uint8_t ret, srbId; + uint16_t byteIdx, crnti, cellId, rrcMsgSize; uint32_t gnbCuUeF1apId, gnbDuUeF1apId; - + bool execDup = false; + bool deliveryStaRpt = false; + bool ueFound = false; + bool ueCcchCtxtFound = false; DU_LOG("\nDU_APP : DL RRC message transfer Recevied"); + dlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer; ret = ROK; - for(idx=0; idxprotocolIEs.list.count; idx++) + for(ieIdx=0; ieIdxprotocolIEs.list.count; ieIdx++) { - switch(dlRrcMsg->protocolIEs.list.array[idx]->id) + switch(dlRrcMsg->protocolIEs.list.array[ieIdx]->id) { case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID: { - gnbCuUeF1apId = dlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID; + gnbCuUeF1apId = dlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID; break; } case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID: { - gnbDuUeF1apId = dlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID; + gnbDuUeF1apId = dlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID; break; } case ProtocolIE_ID_id_SRBID: { - srbId = dlRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID; + srbId = dlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.SRBID; break; } case ProtocolIE_ID_id_ExecuteDuplication: - break; - + { + execDup = true; + break; + } case ProtocolIE_ID_id_RRCContainer: { - if(dlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size > 0) + if(dlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size > 0) { - dlCcchMsgSize = dlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size; - DU_ALLOC(dlCcchMsg, dlCcchMsgSize); - for(idx2 = 0; idx2 < dlCcchMsgSize; idx2++) + rrcMsgSize = dlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size; + DU_ALLOC(rrcMsgPdu, rrcMsgSize); + if(!rrcMsgPdu) + { + DU_LOG("\nDU_APP : Memory allocation failed in procDlRrcMsgTrans"); + return RFAILED; + } + for(byteIdx = 0; byteIdx < rrcMsgSize; byteIdx++) { - dlCcchMsg[idx2] = \ - dlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf[idx2]; + rrcMsgPdu[byteIdx] = \ + dlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf[byteIdx]; } } else { DU_LOG("\nDU_APP : RRC Container Size is invalid:%ld",\ - dlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size); + dlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size); + return RFAILED; } break; } - + case ProtocolIE_ID_id_RRCDeliveryStatusRequest: + { + deliveryStaRpt = true; + break; + } default: DU_LOG("\nDU_APP : Invalid IE received in DL RRC Msg Transfer:%ld", - dlRrcMsg->protocolIEs.list.array[idx]->id); + dlRrcMsg->protocolIEs.list.array[ieIdx]->id); } } - for(idx=0; idxnumActvUes < MAX_NUM_UE) { - ret = duCreateUeCb(&duCb.ueCcchCtxt[idx], gnbCuUeF1apId); - if(ret) + ret = duCreateUeCb(&duCb.ueCcchCtxt[ueIdx], gnbCuUeF1apId); + if(ret == RFAILED) { - DU_LOG("\nDU_APP: Failed at duCreateUeCb for cellId [%d]", duCb.ueCcchCtxt[idx].cellId); + DU_LOG("\nDU_APP: Failed to createUeCb for cellId [%d] at procDlRrcMsgTrans()", \ + duCb.ueCcchCtxt[ueIdx].cellId); ret = RFAILED; } } else { - DU_LOG("\nDU_APP: Max Active UEs has reached"); + DU_LOG("\nDU_APP: Max Active UEs has reached at procDlRrcMsgTrans()"); ret = RFAILED; } } - } + } + else + { + for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++) + { + for(ueIdx = 0 ; ueIdx < MAX_NUM_UE; ueIdx++) + { + if((gnbCuUeF1apId == duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId) + && (gnbDuUeF1apId == duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId)) + { + ueFound = true; + ret = duBuildAndSendDlRrcMsgToRlc(duCb.actvCellLst[cellIdx]->cellId, \ + duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg, srbId, \ + execDup, deliveryStaRpt, rrcMsgSize, rrcMsgPdu); + break; + } + } + if(ueFound) + break; + } + if(!ueFound) + ret = RFAILED; + } return ret; } @@ -385,19 +494,43 @@ uint8_t duProcUlCcchInd(UlCcchIndInfo *ulCcchIndInfo) } +/****************************************************************** + * + * @brief Fills Default UL LC Cfg + * + * @details + * + * Function : fillDefaultUlLcCfg + * + * Functionality: Fills Default UL LC Cfg + * + * @params[in] UlLcCfg *ulLcCfg + * @return void + *****************************************************************/ +void fillDefaultUlLcCfg(UlLcCfg *ulLcCfg) +{ + ulLcCfg->priority = LC_PRIORITY_1; + ulLcCfg->lcGroup = 0; + ulLcCfg->schReqId = 0; + ulLcCfg->pbr = PBR_KBPS_INFINITY; + ulLcCfg->bsd = BSD_MS_1000; +} + /****************************************************************** * * @brief Fills Initial DL Bandwidth Part * * @details * - * Function : fillInitDlBwp + * Function : fillDefaultInitDlBwp * * Functionality: Fills Initial DL Bandwidth Part * + * @params[in] InitialDlBwp *initDlBwp + * @return void * *****************************************************************/ -void fillInitDlBwp(InitialDlBwp *initDlBwp) +void fillDefaultInitDlBwp(InitialDlBwp *initDlBwp) { uint8_t idx = 0; uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0}; @@ -422,7 +555,7 @@ void fillInitDlBwp(InitialDlBwp *initDlBwp) coreset1StartPrb = coreset0EndPrb +6; coreset1NumPrb = CORESET1_NUM_PRB; /* calculate the PRBs */ - schAllocFreqDomRscType0(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource); + freqDomRscAllocType0(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource); memcpy(initDlBwp->pdcchCfg.cRSetToAddModList[idx].freqDomainRsrc, freqDomainResource, FREQ_DOM_RSRC_SIZE); @@ -486,6 +619,7 @@ void fillInitDlBwp(InitialDlBwp *initDlBwp) initDlBwp->pdschCfg.rbgSize = RBG_SIZE_CONFIG1; initDlBwp->pdschCfg.numCodeWordsSchByDci = CODEWORDS_SCHED_BY_DCI_N1; initDlBwp->pdschCfg.bundlingType = TYPE_STATIC_BUNDLING; + initDlBwp->pdschCfg.bundlingInfo.StaticBundling.size = 0; } } @@ -497,13 +631,15 @@ void fillInitDlBwp(InitialDlBwp *initDlBwp) * * @details * - * Function : fillInitUlBwp + * Function : fillDefaultInitUlBwp * * Functionality: Fills Initial UL Bandwidth Part * + * @params[in] InitialUlBwp *initUlBwp + * @return void * *****************************************************************/ -void fillInitUlBwp(InitialUlBwp *initUlBwp) +void fillDefaultInitUlBwp(InitialUlBwp *initUlBwp) { uint8_t idx; if(initUlBwp) @@ -514,6 +650,7 @@ void fillInitUlBwp(InitialUlBwp *initUlBwp) initUlBwp->puschPresent = TRUE; if(initUlBwp->puschPresent) { + initUlBwp->puschCfg.dataScramblingId = SCRAMBLING_ID; initUlBwp->puschCfg.dmrsUlCfgForPuschMapTypeA.addPos = ADDITIONALPOSITION_POS0; initUlBwp->puschCfg.dmrsUlCfgForPuschMapTypeA.transPrecodDisabled. \ scramblingId0 = SCRAMBLING_ID; @@ -545,19 +682,21 @@ void fillInitUlBwp(InitialUlBwp *initUlBwp) * * @details * - * Function : fillSpCellGrpInfo + * Function : fillDefaultSpCellGrpInfo * * Functionality: Fills Sp Cell Group Info * + * @params[in] SpCellCfg *spCell + * @return void * *****************************************************************/ -void fillSpCellGrpInfo(SpCellCfg *spCell) +void fillDefaultSpCellGrpInfo(SpCellCfg *spCell) { if(spCell) { spCell->servCellIdx = SERV_CELL_IDX; /* Filling Initial Dl Bwp */ - fillInitDlBwp(&spCell->servCellCfg.initDlBwp); + fillDefaultInitDlBwp(&spCell->servCellCfg.initDlBwp); spCell->servCellCfg.numDlBwpToAdd = 0; spCell->servCellCfg.firstActvDlBwpId = ACTIVE_DL_BWP_ID; @@ -570,7 +709,7 @@ void fillSpCellGrpInfo(SpCellCfg *spCell) spCell->servCellCfg.pdschServCellCfg.numHarqProcForPdsch =\ NUM_HARQ_PROC_FOR_PDSCH_N_16; /* Filling Initial UL Bwp*/ - fillInitUlBwp(&spCell->servCellCfg.initUlBwp); + fillDefaultInitUlBwp(&spCell->servCellCfg.initUlBwp); spCell->servCellCfg.numUlBwpToAdd = 0; spCell->servCellCfg.firstActvUlBwpId = ACTIVE_DL_BWP_ID; } @@ -586,13 +725,15 @@ void fillSpCellGrpInfo(SpCellCfg *spCell) * * @details * - * Function : fillPhyCellGrpInfo + * Function : fillDefaultPhyCellGrpInfo * * Functionality: Fills Physical Cell Group Info * + * @params[in] PhyCellGrpCfg *cellGrp + * @return void * *****************************************************************/ -void fillPhyCellGrpInfo(PhyCellGrpCfg *cellGrp) +void fillDefaultPhyCellGrpInfo(PhyCellGrpCfg *cellGrp) { if(cellGrp) { @@ -611,13 +752,15 @@ void fillPhyCellGrpInfo(PhyCellGrpCfg *cellGrp) * * @details * - * Function : fillMacCellGrpInfo + * Function : fillDefaultMacCellGrpInfo * * Functionality: Fills Mac Cell Group Info * + * @params[in] MacCellGrpCfg *cellGrp + * @return void * *****************************************************************/ -void fillMacCellGrpInfo(MacCellGrpCfg *cellGrp) +void fillDefaultMacCellGrpInfo(MacCellGrpCfg *cellGrp) { uint8_t idx; @@ -649,9 +792,9 @@ void fillMacCellGrpInfo(MacCellGrpCfg *cellGrp) cellGrp->tagCfg.relListCount = 0; /* Filling BSR config */ - cellGrp->bsrTmrCfg.periodicTimer = PERIODIC_BSR_TMR; - cellGrp->bsrTmrCfg.retxTimer = RETX_BSR_TMR; - cellGrp->bsrTmrCfg.srDelayTimer = SR_DELAY_TMR; + cellGrp->bsrTmrCfg.periodicTimer = BSR_PERIODIC_TIMER_SF_10; + cellGrp->bsrTmrCfg.retxTimer = BSR_RETX_TIMER_SF_320; + cellGrp->bsrTmrCfg.srDelayTimer = BSR_SR_DELAY_TMR_2560; /* Filling PHR config */ cellGrp->phrCfgSetupPres = true; @@ -672,65 +815,221 @@ void fillMacCellGrpInfo(MacCellGrpCfg *cellGrp) /****************************************************************** * - * @brief Fills Logical Channel Config List + * @brief Function to fill Mac Lc Cfg for SRB1 + * + * @details + * + * Function : fillMacSrb1LcCfg + * + * Functionality: Function to fill Mac Lc cfg for SRB1 + * + * @params[in] LcCfg *lcCfg, LcCfg *ueSetReqDb + * @return void + *****************************************************************/ + +void fillMacSrb1LcCfg(LcCfg *macLcCfg) +{ + macLcCfg->lcId = SRB1_LCID; + macLcCfg->configType = CONFIG_ADD; + macLcCfg->drbQos = NULLP; + macLcCfg->snssai = NULLP; + macLcCfg->ulLcCfgPres = true; + fillDefaultUlLcCfg(&macLcCfg->ulLcCfg); +} + +/****************************************************************** + * + * @brief Function to fill the Lc cfg from ueSetupReqDb * * @details * - * Function : fillLcCfgList + * Function : fillMacLcCfgToAddMod * - * Functionality: Fills Logical channel Config List + * Functionality: Function to fill the Lc cfg from ueSetupReqDb * + * @params[in] LcCfg *lcCfg, LcCfg *ueSetReqDb + * @return ROK/RFAILED * *****************************************************************/ -void fillLcCfgList(LcCfg *lcCfgInfo) + +uint8_t fillMacLcCfgToAddMod(LcCfg *lcCfg, LcCfg *ueSetReqDb) { - if(lcCfgInfo) + uint8_t ret = ROK; + lcCfg->lcId = ueSetReqDb->lcId; + lcCfg->configType = ueSetReqDb->configType; + /* Filling DRBQOS */ + if(ueSetReqDb->drbQos) { - lcCfgInfo->lcId = SRB_ID_1; - lcCfgInfo->drbQos = NULLP; - lcCfgInfo->snssai = NULLP; - lcCfgInfo->ulLcCfg = NULLP; - lcCfgInfo->dlLcCfg.lcp = LC_PRIORITY_1; - -#if 0 - /* TODO: To be filled on receving UE CONTEXT SETUP from CU */ - /* Filling Qos characteristics */ - lcCfgInfo->drbQos.fiveQiType = QoS_Characteristics_PR_non_Dynamic_5QI; - lcCfgInfo->drbQos.u.nonDyn5Qi.fiveQi = 0; - lcCfgInfo->drbQos.u.nonDyn5Qi.priorLevel = 0; - lcCfgInfo->drbQos.u.nonDyn5Qi.avgWindow = 0; - lcCfgInfo->drbQos.u.nonDyn5Qi.maxDataBurstVol = 0; - - /* Filling NgRAN */ - lcCfgInfo->drbQos.ngRanRetPri.priorityLevel = PriorityLevel_highest; - lcCfgInfo->drbQos.ngRanRetPri.preEmptionCap = \ - Pre_emptionCapability_may_trigger_pre_emption; - lcCfgInfo->drbQos.ngRanRetPri.preEmptionVul = \ - Pre_emptionVulnerability_not_pre_emptable; - - /* Filling Grb Qos */ - lcCfgInfo->drbQos.grbQosInfo.maxFlowBitRateDl = 0; - lcCfgInfo->drbQos.grbQosInfo.maxFlowBitRateUl = 0; - lcCfgInfo->drbQos.grbQosInfo.guarFlowBitRateDl = 0; - lcCfgInfo->drbQos.grbQosInfo.guarFlowBitRateUl = 0; - - /* Filling S-NSSAI */ - /* TODO :To be filled when UE Context Setup Request is sent from CU */ - /* Filling UL Logical Channel Config */ - lcCfgInfo->ulLcCfg.priority = 0; - lcCfgInfo->ulLcCfg.lcGroup = 0; - lcCfgInfo->ulLcCfg.schReqId = 0; - lcCfgInfo->ulLcCfg.pbr = 0; - lcCfgInfo->ulLcCfg.bsd = 0; - - /* Filling DL Logical Channel Config */ - lcCfgInfo->dlLcCfg.lcp = 0; -#endif + if(!lcCfg->drbQos) + { + DU_ALLOC_SHRABL_BUF(lcCfg->drbQos, sizeof(DrbQosInfo)); + if(!lcCfg->drbQos) + { + DU_LOG("\nDU APP: Memory Alloc failed at drQos at fillMacLcCfgToAddMod()"); + return RFAILED; + } + } + if(ret == ROK) + { + memcpy(lcCfg->drbQos, ueSetReqDb->drbQos, sizeof(DrbQosInfo)); + } + } + else + { + lcCfg->drbQos = NULLP; + } + + if(ret == ROK) + { + if(ueSetReqDb->snssai) + { + if(!lcCfg->snssai) + { + DU_ALLOC_SHRABL_BUF(lcCfg->snssai, sizeof(Snssai)); + if(!lcCfg->snssai) + { + DU_LOG("\nDU APP: Memory Alloc failed at snnsai at fillMacLcCfgToAddMod()"); + ret = RFAILED; + } + } + if(ret == ROK) + { + /* Filling SNSSAI */ + memcpy(lcCfg->snssai, ueSetReqDb->snssai, sizeof(Snssai)); + } + else + { + lcCfg->snssai = NULLP; + if(lcCfg->drbQos) + { + DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo)); + lcCfg->drbQos = NULLP; + } + return ret; + } + } + else + lcCfg->snssai = NULLP; + } + lcCfg->ulLcCfgPres = ueSetReqDb->ulLcCfgPres; + memcpy(&lcCfg->ulLcCfg, &ueSetReqDb->ulLcCfg, sizeof(UlLcCfg)); + memcpy(&lcCfg->dlLcCfg, &ueSetReqDb->dlLcCfg, sizeof(DlLcCfg)); + return ret; +} + +/****************************************************************** + * + * @brief Function to copy the Bit rate from ueSetupReqDb + * + * @details + * + * Function : getMaxAggrBitRate + * + * Functionality: Function to copy bit Rate from ueSetupReqDb + * + * @params[in] MaxAggrBitRate *macBitRate, MaxAggrBitRate *ueDbBitRate + * @return ROK/RFAILED + * + *****************************************************************/ + +uint8_t getMaxAggrBitRate(MaxAggrBitRate *macBitRate, MaxAggrBitRate *ueDbBitRate) +{ + if(ueDbBitRate) + { + if(!macBitRate) + { + DU_ALLOC_SHRABL_BUF(macBitRate, sizeof(MaxAggrBitRate)); + if(!macBitRate) + { + DU_LOG("\nDUAPP: Memory Alloc Failed at getMaxAggrBitRate()"); + return RFAILED; + } + } + memcpy(macBitRate, ueDbBitRate, sizeof(MaxAggrBitRate)); + } + else + { + macBitRate = NULLP; + } + return ROK; +} + +/****************************************************************** + * + * @brief Builds and Send UE ReConfig Request to MAC + * + * @details + * + * Function : sendUeReCfgReqToMac + * + * Functionality: Builds and Send UE ReConfig Request to MAC + * + * @Params[in] MacUeCfg pointer + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ + +uint8_t sendUeReCfgReqToMac(MacUeCfg *macUeCfg) +{ + uint8_t ret = ROK; + Pst pst; + + /* Fill Pst */ + FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_UE_RECONFIG_REQ); + + if(macUeCfg) + { + /* Processing one Ue at a time to MAC */ + DU_LOG("\nDU_APP: Sending Reconfig Request to MAC"); + ret = (*packMacUeReconfigReqOpts[pst.selector])(&pst, macUeCfg); + if(ret == RFAILED) + { + DU_LOG("\nDU_APP: Failed to send Reconfig Request to MAC at sendUeReCfgReqToMac()"); + DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, macUeCfg, sizeof(MacUeCfg)); + } } else { - DU_LOG("\n Memory is null for LcCfgList"); + DU_LOG("\n DU_APP: Received macUeCfg is NULLP at sendUeReCfgReqToMac()"); + ret = RFAILED; + } + return ret; +} + +/****************************************************************** + * + * @brief Function to return Drb LcId + * + * @details + * + * Function : getDrbLcId + * + * Functionality: Function to return Drb LcId + * + * Returns: lcId - SUCCESS + * RFAILED - FAILURE + *****************************************************************/ + +uint8_t getDrbLcId(uint32_t *drbBitMap) +{ + uint8_t bitMask = 1, bitPos = 0; + bitPos = MIN_DRB_LCID; + + while(bitPos <= MAX_DRB_LCID) + { + if((*drbBitMap & (bitMask << bitPos)) == 0) + { + *drbBitMap = ((bitMask << bitPos)| *drbBitMap); + return bitPos; + } + else + { + bitPos++; + } } + DU_LOG("\nDU_APP: Max LC Reached in getDrbLcId()"); + return RFAILED; } /****************************************************************** @@ -743,33 +1042,89 @@ void fillLcCfgList(LcCfg *lcCfgInfo) * * Functionality: Fills MacUeCfg * + * @params[in] cellId, ueIdx, crnti, + * UeContextSetupDb pointer, + * MacUeCfg pointer + * @return ROK/RFAILED * *****************************************************************/ -void fillMacUeCfg(uint16_t cellId, uint8_t ueIdx,\ - uint16_t crnti, MacUeCfg *ueCfg) +uint8_t fillMacUeCfg(uint16_t cellId, uint8_t ueIdx, uint16_t crnti, \ + UeContextSetupDb *ueCfgDb, MacUeCfg *macUeCfg) { - uint8_t idx; - ueCfg->cellId = cellId; - ueCfg->ueIdx = ueIdx; - ueCfg->crnti = crnti; - /* Filling MacCellGroup Config */ - fillMacCellGrpInfo(&ueCfg->macCellGrpCfg); - /* Filling PhyCellGroup Config */ - fillPhyCellGrpInfo(&ueCfg->phyCellGrpCfg); - /* Filling SpCellGroup Config */ - fillSpCellGrpInfo(&ueCfg->spCellCfg); - /* Filling AMBR for UL and DL */ - ueCfg->maxAggrBitRate = NULLP; - /* Filling LC Context */ - ueCfg->numLcs = SRB_ID_1; - if(ueCfg->numLcs < MAX_NUM_LOGICAL_CHANNELS) + uint8_t ret, dbIdx, lcIdx, cellIdx; + bool lcIdFound = false; + MacUeCfg *duMacDb = NULLP; + + ret =ROK; + + if(!ueCfgDb) { - for(idx = 0; idx < ueCfg->numLcs; idx++) - { - fillLcCfgList(&ueCfg->lcCfgList[idx]); - } + macUeCfg->cellId = cellId; + macUeCfg->ueIdx = ueIdx; + macUeCfg->crnti = crnti; + fillDefaultMacCellGrpInfo(&macUeCfg->macCellGrpCfg); + fillDefaultPhyCellGrpInfo(&macUeCfg->phyCellGrpCfg); + fillDefaultSpCellGrpInfo(&macUeCfg->spCellCfg); + macUeCfg->maxAggrBitRate = NULLP; + fillMacSrb1LcCfg(&macUeCfg->lcCfgList[0]); + macUeCfg->numLcs++; } + else + { + /* Fetching MacDb from DuUeCb */ + GET_CELL_IDX(cellId, cellIdx); + duMacDb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].macUeCfg; + /* Fetching MaUeCfg List for ADD/MOD/DEL */ + macUeCfg->cellId = cellId; + macUeCfg->ueIdx = ueIdx; + macUeCfg->crnti = crnti; + ret = procUeReCfgCellInfo(macUeCfg, ueCfgDb->cellGrpCfg); + if(ret == ROK) + { + ret = getMaxAggrBitRate(macUeCfg->maxAggrBitRate, ueCfgDb->duUeCfg.maxAggrBitRate); + } + /* Filling LC Context */ + for(dbIdx = 0; (dbIdx < ueCfgDb->duUeCfg.numMacLcs && ret == ROK); dbIdx++) + { + if(!ueCfgDb->duUeCfg.macLcCfg[dbIdx].ulLcCfgPres) + { + /* Filling default UL LC config in MAC if not present */ + ueCfgDb->duUeCfg.macLcCfg[dbIdx].ulLcCfgPres = true; + fillDefaultUlLcCfg(&ueCfgDb->duUeCfg.macLcCfg[dbIdx].ulLcCfg); + } + for(lcIdx = 0; lcIdx < duMacDb->numLcs; lcIdx++) + { + if(ueCfgDb->duUeCfg.macLcCfg[dbIdx].lcId == duMacDb->lcCfgList[lcIdx].lcId) + { + lcIdFound = true; + if((ueCfgDb->duUeCfg.macLcCfg[dbIdx].configType == CONFIG_UNKNOWN) || + (ueCfgDb->duUeCfg.macLcCfg[dbIdx].configType == CONFIG_MOD)) + { + ueCfgDb->duUeCfg.macLcCfg[dbIdx].configType = CONFIG_MOD; + ret = fillMacLcCfgToAddMod(&macUeCfg->lcCfgList[dbIdx], &ueCfgDb->duUeCfg.macLcCfg[dbIdx]); + } + } + else + lcIdFound = false; + } + if(!lcIdFound) + { + /* ADD/DEL CONFIG */ + ret = fillMacLcCfgToAddMod(&macUeCfg->lcCfgList[dbIdx], &ueCfgDb->duUeCfg.macLcCfg[dbIdx]); + } + if(ret == ROK) + { + macUeCfg->numLcs++; + } + else + { + DU_LOG("\n DU_APP: Failed to add Lc at Idx %d in fillMacUeCfg()", dbIdx); + break; + } + }/*End of Outer FOR loop */ + } + return ret; } /****************************************************************** @@ -778,13 +1133,15 @@ void fillMacUeCfg(uint16_t cellId, uint8_t ueIdx,\ * * @details * - * Function : fillAmInfo + * Function : fillDefaultAmInfo * * Functionality: Fills Rlc AM Information * + * @params[in] AmBearerCfg *amCfg + * @return void * *****************************************************************/ -void fillAmInfo(AmBearerCfg *amCfg) +void fillDefaultAmInfo(AmBearerCfg *amCfg) { /* DL AM */ amCfg->dlAmCfg.snLenDl = AM_SIZE_12; @@ -797,7 +1154,6 @@ void fillAmInfo(AmBearerCfg *amCfg) amCfg->ulAmCfg.snLenUl = AM_SIZE_12; amCfg->ulAmCfg.reAssemTmr = RE_ASM_40MS; amCfg->ulAmCfg.statProhTmr = PROH_35MS; - } /****************************************************************** @@ -806,13 +1162,15 @@ void fillAmInfo(AmBearerCfg *amCfg) * * @details * - * Function : fillUmBiDirInfo + * Function : fillDefaultUmBiInfo * * Functionality: Fills RLC UM Bi Directional Information * + * @params[in] UmBiDirBearerCfg *umBiDirCfg + * @return void * *****************************************************************/ -void fillUmBiDirInfo(UmBiDirBearerCfg *umBiDirCfg) +void fillDefaultUmBiInfo(UmBiDirBearerCfg *umBiDirCfg) { /* UL UM BI DIR INFO */ umBiDirCfg->ulUmCfg.snLenUlUm = UM_SIZE_12; @@ -820,7 +1178,6 @@ void fillUmBiDirInfo(UmBiDirBearerCfg *umBiDirCfg) /* DL UM BI DIR INFO */ umBiDirCfg->dlUmCfg.snLenDlUm = UM_SIZE_12; - } /****************************************************************** @@ -829,16 +1186,18 @@ void fillUmBiDirInfo(UmBiDirBearerCfg *umBiDirCfg) * * @details * - * Function : fillUmUniDirUlInfo + * Function : fillDefaultUmUlInfo * * Functionality: Fills RLC UM Uni Directional Info * + * @params[in] UmUniDirUlBearerCfg *UmUlCfg + * @return void * *****************************************************************/ -void fillUmUniDirUlInfo(UmUniDirUlBearerCfg *umUniDirUlCfg) +void fillDefaultUmUlInfo(UmUniDirUlBearerCfg *UmUlCfg) { - umUniDirUlCfg->ulUmCfg.snLenUlUm = UM_SIZE_12; - umUniDirUlCfg->ulUmCfg.reAssemTmr = RE_ASM_40MS; + UmUlCfg->ulUmCfg.snLenUlUm = UM_SIZE_12; + UmUlCfg->ulUmCfg.reAssemTmr = RE_ASM_40MS; } /****************************************************************** @@ -847,69 +1206,264 @@ void fillUmUniDirUlInfo(UmUniDirUlBearerCfg *umUniDirUlCfg) * * @details * - * Function : fillUmUniDirDlInfo + * Function : fillDefaultUmDlInfo * * Functionality: Fills RLC UM Uni Directional DL Info * + * @params[in] UmUniDirDlBearerCfg *UmDlCfg + * @return void * *****************************************************************/ -void fillUmUniDirDlInfo(UmUniDirDlBearerCfg *umUniDirDlCfg) +void fillDefaultUmDlInfo(UmUniDirDlBearerCfg *UmDlCfg) { - umUniDirDlCfg->dlUmCfg.snLenDlUm = UM_SIZE_12; + UmDlCfg->dlUmCfg.snLenDlUm = UM_SIZE_12; } /****************************************************************** * - * @brief Fills RlcBearerCfg structure + * @brief Builds Rlc Mode Default Configuration * * @details * - * Function : fillRlcBearerCfg + * Function : fillDefaultRlcModeCfg * - * Functionality: Fills Rlc Bearer Cfg + * Functionality: Builds Rlc Mode Default Configuration * + * @params[in] rlcMode, RlcBearerCfg *lcCfg + * @return ROK/RFAILED * *****************************************************************/ -void fillRlcBearerCfg(uint16_t cellId, uint8_t ueIdx, RlcUeCfg *ueCfg) + +uint8_t fillDefaultRlcModeCfg(uint8_t rlcMode, RlcBearerCfg *lcCfg) { - uint8_t idx; - ueCfg->cellId = cellId; - ueCfg->ueIdx = ueIdx; - ueCfg->numLcs = SRB_ID_1; - for(idx = 0; idx < ueCfg->numLcs; idx++) + if(lcCfg) { - ueCfg->rlcBearerCfg[idx].rbId = RB_ID_SRB; - ueCfg->rlcBearerCfg[idx].rbType = RB_TYPE_SRB; - ueCfg->rlcBearerCfg[idx].lcId = SRB_ID_1; - ueCfg->rlcBearerCfg[idx].lcType = LCH_DCCH; - ueCfg->rlcBearerCfg[idx].rlcMode = RLC_AM; - switch(ueCfg->rlcBearerCfg[idx].rlcMode) + switch(rlcMode) { - case RLC_AM: - memset(&ueCfg->rlcBearerCfg[idx].u.amCfg, 0, sizeof(AmBearerCfg)); - fillAmInfo(&ueCfg->rlcBearerCfg[idx].u.amCfg); - break; - case RLC_UM_BI_DIRECTIONAL: - memset(&ueCfg->rlcBearerCfg[idx].u.umBiDirCfg, 0, sizeof(UmBiDirBearerCfg)); - fillUmBiDirInfo(&ueCfg->rlcBearerCfg[idx].u.umBiDirCfg); - break; - case RLC_UM_UNI_DIRECTIONAL_UL: - memset(&ueCfg->rlcBearerCfg[idx].u.umUniDirUlCfg, 0, sizeof(UmUniDirUlBearerCfg)); - fillUmUniDirUlInfo(&ueCfg->rlcBearerCfg[idx].u.umUniDirUlCfg); - break; - case RLC_UM_UNI_DIRECTIONAL_DL: - memset(&ueCfg->rlcBearerCfg[idx].u.umUniDirDlCfg, 0, sizeof(UmUniDirDlBearerCfg)); - fillUmUniDirDlInfo(&ueCfg->rlcBearerCfg[idx].u.umUniDirDlCfg); - break; - default : - DU_LOG("\nDU_APP: Rlc Mode invalid %d", ueCfg->rlcBearerCfg[idx].rlcMode); - break; + case RLC_AM : + { + if(!lcCfg->u.amCfg) + { + DU_ALLOC_SHRABL_BUF(lcCfg->u.amCfg, sizeof(AmBearerCfg)); + if(lcCfg->u.amCfg) + fillDefaultAmInfo(lcCfg->u.amCfg); + else + { + DU_LOG("\n DU_APP: Memory Alloc failed at AmCfg at fillDefaultRlcModeCfg()"); + return RFAILED; + } + } + break; + } + case RLC_UM_BI_DIRECTIONAL : + { + if(!lcCfg->u.umBiDirCfg) + { + DU_ALLOC_SHRABL_BUF(lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg)); + if(lcCfg->u.umBiDirCfg) + fillDefaultUmBiInfo(lcCfg->u.umBiDirCfg); + else + { + DU_LOG("\n DU_APP: Memory Alloc failed at UmBiDirCfg at fillDefaultRlcModeCfg()"); + return RFAILED; + } + } + break; + } + case RLC_UM_UNI_DIRECTIONAL_UL : + { + if(!lcCfg->u.umUniDirUlCfg) + { + DU_ALLOC_SHRABL_BUF(lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg)); + if(lcCfg->u.umUniDirUlCfg) + fillDefaultUmUlInfo(lcCfg->u.umUniDirUlCfg); + else + { + DU_LOG("\n DU_APP: Memory Alloc failed at UmUniDirUlCfg at fillDefaultRlcModeCfg()"); + return RFAILED; + } + } + break; + } + case RLC_UM_UNI_DIRECTIONAL_DL : + { + if(!lcCfg->u.umUniDirDlCfg) + { + DU_ALLOC_SHRABL_BUF(lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg)); + if(lcCfg->u.umUniDirDlCfg) + fillDefaultUmDlInfo(lcCfg->u.umUniDirDlCfg); + else + { + DU_LOG("\n DU_APP: Memory Alloc failed at UmUniDirDlCfg at fillDefaultRlcModeCfg()"); + return RFAILED; + } + } + break; + } + default: + DU_LOG("\nDUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode); + return RFAILED; } + + } + else + { + DU_LOG("\nDUAPP: Received Lc Config is NULL"); + return RFAILED; } + return ROK; } -/****************************************************************** +/******************************************************************* + * + * @brief Function to fill Rlc Lc Cfg for SRB1 + * + * @details + * + * Function : fillRlcSrb1LcCfg + * + * Functionality: + * Function to fill Rlc Lc Cfg for SRB1 + * + * @params[in] Pointer to RlcBearerCfg + * @return ROK/RFAILED + * + *****************************************************************/ + +uint8_t fillRlcSrb1LcCfg(RlcBearerCfg *rlcLcCfg) +{ + uint8_t ret = ROK; + + rlcLcCfg->rbId = SRB1_LCID; + rlcLcCfg->rbType = RB_TYPE_SRB; + rlcLcCfg->lcId = SRB1_LCID; + rlcLcCfg->lcType = LCH_DCCH; + rlcLcCfg->rlcMode = RLC_AM; + rlcLcCfg->configType = CONFIG_ADD; + ret = fillDefaultRlcModeCfg(rlcLcCfg->rlcMode, rlcLcCfg); + return ret; +} + +/******************************************************************* + * + * @brief Processes UE ReConfig Req to RLC UL + * + * @details + * + * Function : sendUeReCfgReqToRlc + * + * Functionality: + * Processes UE Reconfig Req to RLC UL + * + * @params[in] Pointer to RlcUeCfg + * @return ROK - success + * RFAILED - failure + * + *****************************************************************/ + +uint8_t sendUeReCfgReqToRlc(RlcUeCfg *rlcUeCfg) +{ + uint8_t ret; + Pst pst; + + FILL_PST_DUAPP_TO_RLC(pst, RLC_UL_INST, EVENT_RLC_UE_RECONFIG_REQ); + if(rlcUeCfg) + { + /* Processing one Ue at a time to RLC */ + DU_LOG("\nDU_APP: Sending Reconfig Request to RLC UL"); + ret = (*packRlcUeReconfigReqOpts[pst.selector])(&pst, rlcUeCfg); + if(ret == RFAILED) + { + DU_LOG("\nDU_APP : Failed to send Ue Reconfig Req to RLC at sendUeReCfgReqToRlc()"); + DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, rlcUeCfg, sizeof(RlcUeCfg)); + } + } + else + { + DU_LOG("\n DU_APP: Received RlcUeCfg is NULL at sendUeReCfgReqToRlc()"); + ret = RFAILED; + } + return ret; +} + +/****************************************************************** + * + * @brief Fills RlcBearerCfg structure + * + * @details + * + * Function : fillRlcUeCfg + * + * Functionality: Fills Rlc Bearer Cfg + * + * + *****************************************************************/ +uint8_t fillRlcUeCfg(uint16_t cellId, uint8_t ueIdx,\ + DuUeCfg *ueCfgDb, RlcUeCfg *rlcUeCfg) +{ + uint8_t ret, dbIdx, lcIdx, cellIdx; + bool lcIdFound = false; + RlcUeCfg *duRlcDb = NULLP; + + ret = ROK; + if(!ueCfgDb) + { + /* Initial RB being Added */ + rlcUeCfg->cellId = cellId; + rlcUeCfg->ueIdx = ueIdx; + ret = fillRlcSrb1LcCfg(&rlcUeCfg->rlcLcCfg[0]); + if(ret == ROK) + rlcUeCfg->numLcs++; + else + memset(rlcUeCfg, 0, sizeof(RlcUeCfg)); + } + else + { + /* Fetch RlcDb from DuUeCb */ + GET_CELL_IDX(cellId, cellIdx); + duRlcDb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].rlcUeCfg; + /*Filling RlcUeCfg */ + rlcUeCfg->cellId = cellId; + rlcUeCfg->ueIdx = ueIdx; + for(dbIdx = 0; (dbIdx < ueCfgDb->numRlcLcs && ret == ROK); dbIdx++) + { + ret = fillDefaultRlcModeCfg(ueCfgDb->rlcLcCfg[dbIdx].rlcMode, &ueCfgDb->rlcLcCfg[dbIdx]); + if(ret == RFAILED) + { + DU_LOG("\n DU_APP: Failed to fill Rlc Mode at fillRlcUeCfg()"); + memset(rlcUeCfg, 0, sizeof(RlcUeCfg)); + return ret; + } + /* Fill Rlc Ue Cfg List for ADD/MOD/DEL */ + for(lcIdx = 0; lcIdx < duRlcDb->numLcs; lcIdx++) + { + if(ueCfgDb->rlcLcCfg[dbIdx].lcId == duRlcDb->rlcLcCfg[lcIdx].lcId) + { + lcIdFound = true; + if((ueCfgDb->rlcLcCfg[dbIdx].configType == CONFIG_UNKNOWN)|| + (ueCfgDb->rlcLcCfg[dbIdx].configType == CONFIG_MOD)) + { + /* MOD */ + ueCfgDb->rlcLcCfg[dbIdx].configType = CONFIG_MOD; /* update Db for MOD type */ + memcpy(&rlcUeCfg->rlcLcCfg[dbIdx], &ueCfgDb->rlcLcCfg[dbIdx], sizeof(RlcBearerCfg)); + } + } + else + lcIdFound = false; + } + if(!lcIdFound) + { + /* ADD/ DEL Config Type */ + memcpy(&rlcUeCfg->rlcLcCfg[dbIdx], &ueCfgDb->rlcLcCfg[dbIdx], sizeof(RlcBearerCfg)); + } + rlcUeCfg->numLcs++; + } + } + return ret; +} + +/****************************************************************** * * @brief creates UE context * @@ -938,22 +1492,25 @@ uint8_t duCreateUeCb(UeCcchCtxt *ueCcchCtxt, uint32_t gnbCuUeF1apId) GET_UE_IDX(ueCcchCtxt->crnti, ueIdx); DU_LOG("\nDU_APP: Filling UeCb for ueIdx [%d]", ueIdx); + duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].crnti = ueCcchCtxt->crnti; duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId = ueCcchCtxt->gnbDuUeF1apId; duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId = gnbCuUeF1apId; + duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].drbBitMap = NULLP; duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].ueState = UE_ACTIVE; + duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].f1UeDb = NULLP; /* Filling Mac Ue Config */ memset(&duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].macUeCfg, 0, sizeof(MacUeCfg)); ret = duBuildAndSendUeCreateReqToMac(ueCcchCtxt->cellId, ueIdx, ueCcchCtxt->crnti,\ &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].macUeCfg); - if(ret) + if(ret == RFAILED) DU_LOG("\nDU_APP: Failed to send UE create request to MAC"); /* Filling Rlc Ue Config */ memset(&duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].rlcUeCfg, 0, sizeof(RlcUeCfg)); ret = duBuildAndSendUeCreateReqToRlc(ueCcchCtxt->cellId, ueIdx, \ &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].rlcUeCfg); - if(ret) + if(ret == RFAILED) DU_LOG("\nDU_APP: Failed to send UE create request to RLC"); duCb.actvCellLst[cellIdx]->numActvUes++; @@ -983,13 +1540,18 @@ uint8_t duCreateUeCb(UeCcchCtxt *ueCcchCtxt, uint32_t gnbCuUeF1apId) uint8_t duBuildAndSendUeCreateReqToMac(uint16_t cellId, uint8_t ueIdx,\ uint16_t crnti, MacUeCfg *duMacUeCfg) { - uint8_t ret = ROK; + uint8_t ret = ROK; MacUeCfg *macUeCfg = NULLP; - Pst pst; + Pst pst; memset(&pst, 0, sizeof(Pst)); - fillMacUeCfg(cellId, ueIdx, crnti, duMacUeCfg); + ret = fillMacUeCfg(cellId, ueIdx, crnti, NULL, duMacUeCfg); + if(ret == RFAILED) + { + DU_LOG("\nDU APP: Failed to fill MacUeCfg at duBuildAndSendUeCreateReqToMac()"); + return RFAILED; + } /* Fill Pst */ FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_UE_CREATE_REQ); @@ -1003,11 +1565,10 @@ uint8_t duBuildAndSendUeCreateReqToMac(uint16_t cellId, uint8_t ueIdx,\ /* Processing one Ue at a time to MAC */ ret = (*packMacUeCreateReqOpts[pst.selector])(&pst, macUeCfg); - if(ret) + if(ret == RFAILED) { - DU_LOG("\nDU_APP : Failure in sending Ue Create Req to MAC"); + DU_LOG("\nDU_APP : Failure in sending Ue Create Req to MAC at duBuildAndSendUeCreateReqToMac()"); DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, macUeCfg, sizeof(MacUeCfg)); - ret = RFAILED; } } else @@ -1020,32 +1581,339 @@ uint8_t duBuildAndSendUeCreateReqToMac(uint16_t cellId, uint8_t ueIdx,\ /******************************************************************* * - * @brief Handle UE create response from MAC + * @brief To update DuUeCb Mac Cfg + * + * @details + * + * Function : duUpdateMacCfg + * Functionality: update DuUeCb MAC Cfg + * + * @params[in] DuUeCb Pointer + * UeContextSetupDb pointer + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t duUpdateMacCfg(MacUeCfg *macUeCfg, UeContextSetupDb *f1UeDb) +{ + uint8_t ret, lcIdx, dbIdx, numLcs, lcDelIdx; + ret = ROK; + + /*Filling Cell Group Cfg*/ + ret = procUeReCfgCellInfo(macUeCfg, f1UeDb->cellGrpCfg); + if(ret == ROK) + { + ret = getMaxAggrBitRate(macUeCfg->maxAggrBitRate, f1UeDb->duUeCfg.maxAggrBitRate); + } + /* Filling LC Context */ + for(dbIdx = 0; (dbIdx < f1UeDb->duUeCfg.numMacLcs && ret == ROK); dbIdx++) + { + numLcs = macUeCfg->numLcs; + for(lcIdx = 0; lcIdx < numLcs; lcIdx++) + { + if(f1UeDb->duUeCfg.macLcCfg[dbIdx].lcId == macUeCfg->lcCfgList[lcIdx].lcId) + { + if(f1UeDb->duUeCfg.macLcCfg[dbIdx].configType == CONFIG_MOD) + { + ret = fillMacLcCfgToAddMod(&macUeCfg->lcCfgList[lcIdx],&f1UeDb->duUeCfg.macLcCfg[dbIdx]); + } + else if(f1UeDb->duUeCfg.macLcCfg[dbIdx].configType == CONFIG_DEL) + { + /* Free memory at matched lcIdx index */ + freeMacLcCfg(&macUeCfg->lcCfgList[lcIdx]); + macUeCfg->numLcs--; + for(lcDelIdx = lcIdx; lcDelIdx < macUeCfg->numLcs; lcDelIdx++) + { + /* moving all elements one index ahead */ + ret = fillMacLcCfgToAddMod(&macUeCfg->lcCfgList[lcDelIdx], &macUeCfg->lcCfgList[lcDelIdx+1]); + freeMacLcCfg(&macUeCfg->lcCfgList[lcDelIdx+1]); + if(ret == RFAILED) + { + DU_LOG("\nDU_APP: Failed to delete LC at Idx %d in duUpdateMacCfg()", lcDelIdx); + break; + } + } + } + } + } + if(f1UeDb->duUeCfg.macLcCfg[dbIdx].configType == CONFIG_ADD) + { + ret = fillMacLcCfgToAddMod(&macUeCfg->lcCfgList[numLcs], &f1UeDb->duUeCfg.macLcCfg[dbIdx]); + if(ret == RFAILED) + { + DU_LOG("\nDU_APP: Failed to add LC at Idx %d in duUpdateMacCfg()", numLcs); + break; + } + macUeCfg->numLcs++; + } + + } + return ret; +} + +/****************************************************************** + * + * @brief Function to fill the RLC Lc cfg from ueSetupReqDb + * + * @details + * + * Function : fillRlcCfgToAddMod + * + * Functionality: Function to fill the RLC Lc cfg from ueSetupReqDb + * + * + *****************************************************************/ + +uint8_t fillRlcCfgToAddMod(RlcBearerCfg *lcCfg, RlcBearerCfg *f1UeDbLcCfg) +{ + lcCfg->configType = f1UeDbLcCfg->configType; + lcCfg->rbId = f1UeDbLcCfg->rbId; + lcCfg->rbType = f1UeDbLcCfg->rbType; + lcCfg->lcId = f1UeDbLcCfg->lcId; + lcCfg->lcType = f1UeDbLcCfg->lcType; + lcCfg->rlcMode = f1UeDbLcCfg->rlcMode; + switch(lcCfg->rlcMode) + { + case RLC_AM : + { + if(!lcCfg->u.amCfg) + { + DU_ALLOC_SHRABL_BUF(lcCfg->u.amCfg, sizeof(AmBearerCfg)); + if(!lcCfg->u.amCfg) + return RFAILED; + } + /* DL AM */ + lcCfg->u.amCfg->dlAmCfg.snLenDl = f1UeDbLcCfg->u.amCfg->dlAmCfg.snLenDl; + lcCfg->u.amCfg->dlAmCfg.pollRetxTmr = f1UeDbLcCfg->u.amCfg->dlAmCfg.pollRetxTmr; + lcCfg->u.amCfg->dlAmCfg.pollPdu = f1UeDbLcCfg->u.amCfg->dlAmCfg.pollPdu; + lcCfg->u.amCfg->dlAmCfg.pollByte = f1UeDbLcCfg->u.amCfg->dlAmCfg.pollByte; + lcCfg->u.amCfg->dlAmCfg.maxRetxTh = f1UeDbLcCfg->u.amCfg->dlAmCfg.maxRetxTh; + + /* UL AM */ + lcCfg->u.amCfg->ulAmCfg.snLenUl = f1UeDbLcCfg->u.amCfg->ulAmCfg.snLenUl; + lcCfg->u.amCfg->ulAmCfg.reAssemTmr = f1UeDbLcCfg->u.amCfg->ulAmCfg.reAssemTmr; + lcCfg->u.amCfg->ulAmCfg.statProhTmr = f1UeDbLcCfg->u.amCfg->ulAmCfg.statProhTmr; + break; + } + case RLC_UM_BI_DIRECTIONAL : + { + if(!lcCfg->u.umBiDirCfg) + { + DU_ALLOC_SHRABL_BUF(lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg)); + if(!lcCfg->u.umBiDirCfg) + return RFAILED; + } + /* UL UM BI DIR INFO */ + lcCfg->u.umBiDirCfg->ulUmCfg.snLenUlUm = f1UeDbLcCfg->u.umBiDirCfg->ulUmCfg.snLenUlUm; + lcCfg->u.umBiDirCfg->ulUmCfg.reAssemTmr = f1UeDbLcCfg->u.umBiDirCfg->ulUmCfg.reAssemTmr; + /* DL UM BI DIR INFO */ + lcCfg->u.umBiDirCfg->dlUmCfg.snLenDlUm = f1UeDbLcCfg->u.umBiDirCfg->dlUmCfg.snLenDlUm; + break; + } + case RLC_UM_UNI_DIRECTIONAL_UL : + { + if(!lcCfg->u.umUniDirUlCfg) + { + DU_ALLOC_SHRABL_BUF(lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg)); + if(!lcCfg->u.umUniDirUlCfg) + return RFAILED; + } + lcCfg->u.umUniDirUlCfg->ulUmCfg.snLenUlUm = f1UeDbLcCfg->u.umUniDirUlCfg->ulUmCfg.snLenUlUm; + lcCfg->u.umUniDirUlCfg->ulUmCfg.reAssemTmr = f1UeDbLcCfg->u.umUniDirUlCfg->ulUmCfg.reAssemTmr; + break; + + } + case RLC_UM_UNI_DIRECTIONAL_DL : + { + if(!lcCfg->u.umUniDirDlCfg) + { + DU_ALLOC_SHRABL_BUF(lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg)); + if(!lcCfg->u.umUniDirDlCfg) + return RFAILED; + } + lcCfg->u.umUniDirDlCfg->dlUmCfg.snLenDlUm = f1UeDbLcCfg->u.umUniDirDlCfg->dlUmCfg.snLenDlUm; + break; + } + default: + DU_LOG("\nDU_APP: Invalid Rlc Mode %d at fillRlcCfgToAddMod()", lcCfg->rlcMode); + return RFAILED; + } + return ROK; +} + +/******************************************************************* + * + * @brief To update DuUeCb Rlc Lc Cfg + * + * @details + * + * Function : duUpdateRlcLcCfg + * Functionality: update DuUeCb Rlc Lc Cfg + * + * @params[in] DuUeCb Pointer + * UeContextSetupDb pointer + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ + +uint8_t duUpdateRlcLcCfg(RlcUeCfg *rlcUeCfg, UeContextSetupDb *f1UeDb) +{ + uint8_t ret, lcIdx, dbIdx, numLcs, lcDelIdx; + + ret = ROK; + for(dbIdx = 0; (dbIdx < f1UeDb->duUeCfg.numRlcLcs && ret ==ROK); dbIdx++) + { + numLcs = rlcUeCfg->numLcs; + for(lcIdx = 0; lcIdx < numLcs; lcIdx++) + { + if(f1UeDb->duUeCfg.rlcLcCfg[dbIdx].lcId == rlcUeCfg->rlcLcCfg[lcIdx].lcId) + { + if(f1UeDb->duUeCfg.rlcLcCfg[dbIdx].configType == CONFIG_MOD) + { + ret = fillRlcCfgToAddMod(&rlcUeCfg->rlcLcCfg[lcIdx], &f1UeDb->duUeCfg.rlcLcCfg[dbIdx]); + } + else if(f1UeDb->duUeCfg.rlcLcCfg[dbIdx].configType == CONFIG_DEL) + { + /* Free memory at matched lcIdx index */ + freeRlcLcCfg(&rlcUeCfg->rlcLcCfg[lcIdx]); + rlcUeCfg->numLcs--; + for(lcDelIdx = lcIdx; lcDelIdx < rlcUeCfg->numLcs; lcDelIdx++) + { + ret = fillRlcCfgToAddMod(&rlcUeCfg->rlcLcCfg[lcDelIdx], &rlcUeCfg->rlcLcCfg[lcDelIdx+1]); + freeRlcLcCfg(&rlcUeCfg->rlcLcCfg[lcDelIdx+1]); + if(ret == RFAILED) + { + DU_LOG("\nDU_APP: Failed to delete LC at Idx %d in duUpdateRlcCfg()", lcDelIdx); + break; + } + } + } + } + } + if(f1UeDb->duUeCfg.rlcLcCfg[dbIdx].configType == CONFIG_ADD) + { + ret = fillRlcCfgToAddMod(&rlcUeCfg->rlcLcCfg[lcIdx], &f1UeDb->duUeCfg.rlcLcCfg[dbIdx]); + if(ret == ROK) + rlcUeCfg->numLcs++; + } + } + return ret; +} + + +/******************************************************************* + * + * @brief @brief To update DuUeCb Mac and Rlc Ue Cfg + * + * + * @details + * + * Function : duUpdateDuUeCbCfg + * + * Functionality: update DuUeCb Mac and Rlc Ue Cfg + * + * @params[in] ueIdx, cellIdx + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ + +uint8_t duUpdateDuUeCbCfg(uint8_t ueIdx, uint8_t cellId) +{ + uint8_t ret = ROK, cellIdx = 0, crnti=0; + DuUeCb *ueCb = NULLP; + + GET_CELL_IDX(cellId, cellIdx); + + if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].macUeCfg. \ + macUeCfgState == UE_RECFG_COMPLETE) && + (duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].rlcUeCfg. \ + rlcUeCfgState == UE_RECFG_COMPLETE)) + { + ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1]; + + /*Filling RLC Ue Cfg */ + ueCb->rlcUeCfg.cellId = cellId; + ueCb->rlcUeCfg.ueIdx = ueIdx; + ret = duUpdateRlcLcCfg(&ueCb->rlcUeCfg, ueCb->f1UeDb); + if(ret == ROK) + { + /*Filling MAC Ue Cfg */ + GET_CRNTI(crnti, ueIdx); + ueCb->macUeCfg.cellId = cellId; + ueCb->macUeCfg.ueIdx = ueIdx; + ueCb->macUeCfg.crnti = crnti; + ret = duUpdateMacCfg(&ueCb->macUeCfg, ueCb->f1UeDb); + if(ret == RFAILED) + DU_LOG("\nDU APP: Failed while updating MAC LC Config at duUpdateDuUeCbCfg()"); + } + else + DU_LOG("\nDU APP: Failed while updating RLC LC Config at duUpdateDuUeCbCfg()"); + } + else + ret = RFAILED; + return ret; +} + +/******************************************************************* + * + * @brief Handle UE config response from MAC * * @details * - * Function : DuHandleMacUeCreateRsp + * Function : DuProcMacUeCfgRsp * - * Functionality: Handle UE create response from MAC + * Functionality: Handle UE Config response from MAC * * @params[in] Pointer to MacUeCfgRsp and Pst * @return ROK - success * RFAILED - failure * * ****************************************************************/ -uint8_t DuHandleMacUeCreateRsp(Pst *pst, MacUeCfgRsp *cfgRsp) +uint8_t DuProcMacUeCfgRsp(Pst *pst, MacUeCfgRsp *cfgRsp) { - if(cfgRsp->result == MAC_DU_APP_RSP_OK) + uint8_t ret = ROK; + + if(cfgRsp) { - DU_LOG("\nDU APP : MAC UE Create Response : SUCCESS [UE IDX : %d]", cfgRsp->ueIdx); + if(cfgRsp->result == MAC_DU_APP_RSP_OK) + { + if(pst->event == EVENT_MAC_UE_CREATE_RSP) + { + DU_LOG("\nDU APP : MAC UE Create Response : SUCCESS [UE IDX : %d]", cfgRsp->ueIdx); + duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueIdx -1].\ + macUeCfg.macUeCfgState = UE_CREATE_COMPLETE; + } + else if(pst->event == EVENT_MAC_UE_RECONFIG_RSP) + { + DU_LOG("\nDU APP : MAC UE Reconfig Response : SUCCESS [UE IDX : %d]", cfgRsp->ueIdx); + duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueIdx -1].\ + macUeCfg.macUeCfgState = UE_RECFG_COMPLETE; + if((ret = duUpdateDuUeCbCfg(cfgRsp->ueIdx, cfgRsp->cellId)) == ROK) + BuildAndSendUeCtxtRsp(cfgRsp->ueIdx, cfgRsp->cellId); + } + } + else + { + DU_LOG("\nDU APP : MAC UE CFG Response for EVENT[%d]: FAILURE [UE IDX : %d]", pst->event, cfgRsp->ueIdx); + if(pst->event == EVENT_MAC_UE_RECONFIG_RSP) + { + //TODO: Send the failure case in Ue Context Setup Response + } + ret = RFAILED; + } + DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(MacUeCfgRsp)); } else { - DU_LOG("\nDU APP : MAC UE Create Response : FAILURE [UE IDX : %d]", cfgRsp->ueIdx); + DU_LOG("\nDU APP : Received MAC Ue Config Response is NULL at DuProcMacUeCfgRsp()"); + ret = RFAILED; } - return ROK; + return ret; } + /******************************************************************* * * @brief Processes UE create Req to RLC UL @@ -1065,16 +1933,21 @@ uint8_t DuHandleMacUeCreateRsp(Pst *pst, MacUeCfgRsp *cfgRsp) * *****************************************************************/ -uint8_t duBuildAndSendUeCreateReqToRlc(uint16_t cellId, uint8_t ueIdx, RlcUeCfg *duRlcUeCfg) +uint8_t duBuildAndSendUeCreateReqToRlc(uint16_t cellId, uint8_t ueIdx,\ + RlcUeCfg *duRlcUeCfg) { - uint8_t ret = ROK; + uint8_t ret = ROK; RlcUeCfg *rlcUeCfg = NULLP; - Pst pst; - memset(&pst, 0, sizeof(Pst)); + Pst pst; - fillRlcBearerCfg(cellId, ueIdx, duRlcUeCfg); - FILL_PST_DUAPP_TO_RLC(pst, RLC_UL_INST, EVENT_RLC_UL_UE_CREATE_REQ); + ret = fillRlcUeCfg(cellId, ueIdx, NULL, duRlcUeCfg); + if(ret == RFAILED) + { + DU_LOG("\nDU_APP: Failed to fill Rlc Ue Cfg at duBuildAndSendUeCreateReqToRlc()"); + return ret; + } + FILL_PST_DUAPP_TO_RLC(pst, RLC_UL_INST, EVENT_RLC_UE_CREATE_REQ); /* Copying ueCfg to a sharable buffer */ DU_ALLOC_SHRABL_BUF(rlcUeCfg, sizeof(RlcUeCfg)); if(rlcUeCfg) @@ -1083,8 +1956,8 @@ uint8_t duBuildAndSendUeCreateReqToRlc(uint16_t cellId, uint8_t ueIdx, RlcUeCfg memcpy(rlcUeCfg, duRlcUeCfg, sizeof(RlcUeCfg)); /* Processing one Ue at a time to RLC */ DU_LOG("\nDU_APP: Sending UE create request to RLC UL"); - ret = (*packRlcUlUeCreateReqOpts[pst.selector])(&pst, rlcUeCfg); - if(ret) + ret = (*packRlcUeCreateReqOpts[pst.selector])(&pst, rlcUeCfg); + if(ret == RFAILED) { DU_LOG("\nDU_APP : Failure in sending Ue Create Req to RLC"); DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, rlcUeCfg, sizeof(RlcUeCfg)); @@ -1099,15 +1972,14 @@ uint8_t duBuildAndSendUeCreateReqToRlc(uint16_t cellId, uint8_t ueIdx, RlcUeCfg return ret; } - - /******************************************************************* * * @brief Processes UE create Rsp received from RLC UL * * @details * - * Function : DuProcRlcUlUeCfgRsp + + * Function : DuProcRlcUeCfgRsp * * Functionality: * Processes UE create Rsp received from RLC UL @@ -1118,8 +1990,7 @@ uint8_t duBuildAndSendUeCreateReqToRlc(uint16_t cellId, uint8_t ueIdx, RlcUeCfg * RFAILED - failure * *****************************************************************/ - -uint8_t DuProcRlcUlUeCreateRsp(Pst *pst, RlcUeCfgRsp *cfgRsp) +uint8_t DuProcRlcUeCfgRsp(Pst *pst, RlcUeCfgRsp *cfgRsp) { uint8_t ret = ROK; @@ -1127,23 +1998,188 @@ uint8_t DuProcRlcUlUeCreateRsp(Pst *pst, RlcUeCfgRsp *cfgRsp) { if(cfgRsp->result == RLC_DU_APP_RSP_OK) { - DU_LOG("\nDU_APP: RLC UE Create Response : SUCCESS [UE IDX:%d]", cfgRsp->ueIdx); + if(pst->event == EVENT_RLC_UE_CREATE_RSP) + { + DU_LOG("\nDU_APP: RLC UE Create Response : SUCCESS [UE IDX:%d]", cfgRsp->ueIdx); + duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueIdx -1].\ + rlcUeCfg.rlcUeCfgState = UE_CREATE_COMPLETE; + } + else if(pst->event == EVENT_RLC_UE_RECONFIG_RSP) + { + DU_LOG("\nDU_APP: RLC UE Reconfig Response : SUCCESS [UE IDX:%d]", cfgRsp->ueIdx); + duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueIdx -1].\ + rlcUeCfg.rlcUeCfgState = UE_RECFG_COMPLETE; + if((ret = duUpdateDuUeCbCfg(cfgRsp->ueIdx, cfgRsp->cellId)) == ROK) + BuildAndSendUeCtxtRsp(cfgRsp->ueIdx, cfgRsp->cellId); + + } } else { - DU_LOG("\nDU_APP: RLC UE Create Response : FAILED [UE IDX:%d, REASON :%d]",\ - cfgRsp->ueIdx, cfgRsp->reason); + DU_LOG("\nDU_APP: RLC UE CFG Response for EVENT[%d] : FAILED [UE IDX : %d, REASON :%d]",\ + pst->event, cfgRsp->ueIdx, cfgRsp->reason); + if((pst->event == EVENT_RLC_UE_RECONFIG_RSP)) + { + //TODO: update failure case in ue Context setup Response + } ret = RFAILED; } DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(RlcUeCfgRsp)); } else { - DU_LOG("\nDU_APP: Received RLC Ue Create Response is NULL"); + DU_LOG("\nDU_APP: Received RLC Ue Config Response is NULL at DuProcRlcUeCfgRsp()"); + ret = RFAILED; + } + return ret; +} + +/******************************************************************* + * + * @brief Builds and Send Ue Reconfig Req to RLC + * + * @details + * + * Function : duBuildAndSendUeReCfgReqToRLC + * + * Functionality: Builds and Send Ue Reconfig Req to RLC + * + * @params[in] cellId, crnti + * DuUeCfg *ueCfgDb + * RlcUeCfg *rlcUeCfg + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ + +uint8_t duBuildAndSendUeReCfgReqToRlc(uint8_t cellId, uint8_t crnti, DuUeCfg *ueCfgDb) +{ + uint8_t ret = ROK, ueIdx = 0; + RlcUeCfg *rlcUeCfg = NULLP; + + GET_UE_IDX(crnti, ueIdx); + DU_ALLOC_SHRABL_BUF(rlcUeCfg, sizeof(RlcUeCfg)); + if(rlcUeCfg) + { + memset(rlcUeCfg, 0, sizeof(RlcUeCfg)); + ret = fillRlcUeCfg(cellId, ueIdx, ueCfgDb, rlcUeCfg); + if(ret == RFAILED) + DU_LOG("\nDU APP: Failed at duBuildAndSendUeReCfgReqToRlc()"); + else + ret = sendUeReCfgReqToRlc(rlcUeCfg); + } + else + { + DU_LOG("\nDU APP: Memory Alloc failed at duBuildAndSendUeReCfgReqToRlc()"); + ret = RFAILED; + } + return ret; +} + +/******************************************************************* + * + * @brief Builds and Send Ue Reconfig Req to MAC + * + * @details + * + * Function : duBuildAndSendUeReCfgReqToMac + * + * Functionality: Builds and Send Ue Reconfig Req to MAC + * + * @params[in] CellGroupConfigRrc_t *macCellGrpCfg + * DuUeCfg *ueCfgDb + * MacUeCfg *macUeCfg + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ + +uint8_t duBuildAndSendUeReCfgReqToMac(uint8_t cellId, uint8_t crnti, UeContextSetupDb *ueCfgDb) +{ + uint8_t ret, ueIdx = 0; + MacUeCfg *macUeCfg = NULLP; + + ret = ROK; + GET_UE_IDX(crnti, ueIdx); + + DU_ALLOC_SHRABL_BUF(macUeCfg, sizeof(MacUeCfg)); + if(macUeCfg) + { + memset(macUeCfg, 0, sizeof(MacUeCfg)); + ret = fillMacUeCfg(cellId, ueIdx, crnti, ueCfgDb, macUeCfg); + if(ret == RFAILED) + DU_LOG("\nDU_APP: Failed to fill Mac Ue Cfg at duBuildAndSendUeReCfgReqToMac()"); + else + ret = sendUeReCfgReqToMac(macUeCfg); + } + else + { + DU_LOG("\nDU_APP: Memory alloc failed for macUeCfg at duBuildAndSendUeReCfgReqToMac()"); ret = RFAILED; } return ret; } + +/******************************************************************* + * + * @brief Process UE context setup request from CU + * + * @details + * + * Function : duProcUeContextSetupRequest + * + * Functionality: Process UE context setup request from CU + * + * @params[in] F1AP message + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ + +uint8_t duProcUeContextSetupRequest(DuUeCb *ueCb) +{ + uint8_t ret, cellId; + + ret = ROK; + if(ueCb) + { + cellId = duCb.actvCellLst[ueCb->f1UeDb->cellIdx]->cellId; + + if(ueCb->f1UeDb->rrcMsg) + { + /* Sending DL RRC Message to RLC */ + ret = duBuildAndSendDlRrcMsgToRlc(cellId, ueCb->rlcUeCfg, SRB1_LCID, false, \ + ueCb->f1UeDb->deliveryStaReq, ueCb->f1UeDb->rrcMsgLen, ueCb->f1UeDb->rrcMsg); + if(ret == RFAILED) + { + DU_LOG("\nDU APP : Failed to send DL RRC msg in duProcUeContextSetupRequest()"); + DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCb->f1UeDb->rrcMsg, ueCb->f1UeDb->rrcMsgLen); + } + } + + if(ret == ROK) + { + DU_LOG("\nDU_APP: Processing Ue Context Setup Request for cellId [%d]", cellId); + /* Filling RLC Ue Reconfig */ + ret = duBuildAndSendUeReCfgReqToRlc(cellId, ueCb->crnti, &ueCb->f1UeDb->duUeCfg); + if(ret == RFAILED) + DU_LOG("\nDU_APP: Failed to build ctxt setup req for RLC at duBuildAndSendUeReCfgReqToRlc()"); + + /* Filling MAC Ue Reconfig */ + ret = duBuildAndSendUeReCfgReqToMac(cellId, ueCb->crnti, ueCb->f1UeDb); + if(ret == RFAILED) + DU_LOG("\nDU_APP: Failed at build ctxt setup req for MAC at duBuildAndSendUeReCfgReqToMac()"); + } + + } + else + { + //TODO: To send the failure cause in UeContextSetupRsp + DU_LOG("DU_APP: Failed to process UE CNTXT SETUP REQ at duProcUeContextSetupRequest()"); + } + return ret; +} + /********************************************************************** End of file ***********************************************************************/