X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2Fdu_app%2Fdu_ue_mgr.c;h=5d790bd4a1f555bca1e7397261a0bb42db71cefc;hb=088bb8763eaf91c139ede025faf2fac7e57d25ed;hp=e738d6aab6b071ad23fc07b8803ab1720302d90f;hpb=4e803fe4bcf3a446b7082675d25d35ad102f16f6;p=o-du%2Fl2.git diff --git a/src/du_app/du_ue_mgr.c b/src/du_app/du_ue_mgr.c index e738d6aab..5d790bd4a 100644 --- a/src/du_app/du_ue_mgr.c +++ b/src/du_app/du_ue_mgr.c @@ -19,12 +19,22 @@ #include "common_def.h" #include "lrg.h" #include "lrg.x" +#include "ckw.h" +#include "ckw.x" +#include "kwu.h" +#include "kwu.x" +#include "lkw.h" #include "lkw.x" #include "legtp.h" +#include "du_app_mac_inf.h" +#include "du_app_rlc_inf.h" #include "du_cfg.h" -#include "du_ue_mgr.h" +#include "du_utils.h" #include #include "F1AP-PDU.h" +#include "du_mgr.h" +#include "du_f1ap_msg_hdl.h" +#include "du_ue_mgr.h" #ifdef EGTP_TEST U32 sduId = 0; @@ -33,97 +43,30 @@ U32 sduId = 0; DuMacDlCcchInd packMacDlCcchIndOpts[] = { packMacDlCcchInd, /* Loose coupling */ - MacHdlDlCcchInd, /* TIght coupling */ + MacProcDlCcchInd, /* TIght coupling */ packMacDlCcchInd /* Light weight-loose coupling */ }; DuMacUeCreateReq packMacUeCreateReqOpts[] = { packDuMacUeCreateReq, /* Loose coupling */ - MacHdlUeCreateReq, /* TIght coupling */ + MacProcUeCreateReq, /* TIght coupling */ packDuMacUeCreateReq, /* Light weight-loose coupling */ }; -/****************************************************************** - * - * @brief Send UE configuration to RLC - * - * @details - * - * Function : duSendUeCreateReqToRlc - * - * Functionality: Send UeCreateReqToRlc - * - * @return ROK - success - * RFAILED - failure - * - * ****************************************************************/ -S16 duSendUeCreateReqToRlc() +DuRlcUlUeCreateReq packRlcUlUeCreateReqOpts[] = { - U8 idx; - Pst pst; - CkwCfgInfo *ueCfg; - - DU_SET_ZERO(&ueCfg, sizeof(ueCfg)); - DU_SET_ZERO(&pst, sizeof(Pst)); - - DU_ALLOC(ueCfg, sizeof(CkwCfgInfo)); - -#ifdef EGTP_TEST - ueCfg->ueId = UE_ID; -#endif - ueCfg->cellId = NR_CELL_ID; - ueCfg->numEnt = 1; - - for(idx = 0; idx < ueCfg->numEnt; idx++) - { -#ifdef EGTP_TEST - ueCfg->entCfg[idx].rbId = RB_ID; - ueCfg->entCfg[idx].rbType = CM_LTE_DRB; - ueCfg->entCfg[idx].lCh[0].lChId = LC_ID; - ueCfg->entCfg[idx].lCh[0].type = CM_LTE_LCH_DTCH; -#endif - ueCfg->entCfg[idx].entMode = CM_LTE_MODE_UM; - ueCfg->entCfg[idx].dir = CKW_CFG_DIR_BOTH; - switch(ueCfg->entCfg[idx].entMode) - { - case CM_LTE_MODE_TM: - { - break; - } - - case CM_LTE_MODE_UM: - { - ueCfg->entCfg[idx].m.umInfo.dl.snLen = 1; /* For 12 bit SN */ - ueCfg->entCfg[idx].m.umInfo.ul.snLen = 1; /* For 12 bit SN */ - ueCfg->entCfg[idx].m.umInfo.ul.reOrdTmr = 10; /* in msec */ - break; - } - - case CM_LTE_MODE_AM: - { - break; - } - - default: - break; - } /* End of switch(entMode) */ - } /* End of entity configuration for loop */ - - /* Fill Pst */ - pst.selector = ODU_SELECTOR_LWLC; - pst.srcEnt = ENTDUAPP; - pst.dstEnt = ENTKW; - pst.dstInst = RLC_UL_INST; - pst.dstProcId = DU_PROC; - pst.srcProcId = DU_PROC; - pst.region = duCb.init.region; - - /* Sending to RLC */ - packUeCreateReq(&pst, ueCfg); + packDuRlcUlUeCreateReq, /* Loose coupling */ + RlcUlProcUeCreateReq, /* TIght coupling */ + packDuRlcUlUeCreateReq, /* Light weight-loose coupling */ +}; - RETVALUE(ROK); -} /* End of duSendUeCreateReqToRlc */ +DuDlRrcMsgToRlcFunc duSendDlRrcMsgToRlcOpts[] = +{ + packDlRrcMsgToRlc, /* Loose coupling */ + RlcProcDlRrcMsgTransfer, /* Tight coupling */ + packDlRrcMsgToRlc /* Light weight-loose coupling */ +}; /******************************************************************* * @@ -141,17 +84,17 @@ S16 duSendUeCreateReqToRlc() * RFAILED - failure * * ****************************************************************/ -S16 duHdlEgtpDlData(EgtpMsg *egtpMsg) +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; @@ -159,17 +102,20 @@ S16 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); +#else + //duBuildAndSendDlRrcMsgToRlc(); +#endif return ROK; } @@ -190,13 +136,13 @@ S16 duHdlEgtpDlData(EgtpMsg *egtpMsg) * *****************************************************************/ -PUBLIC S16 duHdlRlcUlData(Pst *pst, KwuDatIndInfo* datInd, Buffer *mBuf) +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); - SPutMsg(mBuf); + ODU_PUT_MSG_BUF(mBuf); return ROK; } @@ -216,15 +162,15 @@ PUBLIC S16 duHdlRlcUlData(Pst *pst, KwuDatIndInfo* datInd, Buffer *mBuf) * RFAILED - failure * * ****************************************************************/ -uint8_t duBuildAndSendDlCcchInd(uint16_t cellId, uint16_t crnti, \ +uint8_t duBuildAndSendDlCcchInd(uint16_t *cellId, uint16_t *crnti, \ DlCcchMsgType msgType, uint8_t *dlCcchMsg, uint16_t dlCcchMsgSize) { 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"); DU_ALLOC_SHRABL_BUF(dlCcchIndInfo, sizeof(DlCcchIndInfo)); @@ -235,8 +181,8 @@ uint8_t duBuildAndSendDlCcchInd(uint16_t cellId, uint16_t crnti, \ return RFAILED; } - dlCcchIndInfo->cellId = cellId; - dlCcchIndInfo->crnti = crnti; + dlCcchIndInfo->cellId = *cellId; + dlCcchIndInfo->crnti = *crnti; dlCcchIndInfo->msgType = msgType; dlCcchIndInfo->dlCcchMsgLen = dlCcchMsgSize; @@ -254,17 +200,7 @@ uint8_t duBuildAndSendDlCcchInd(uint16_t cellId, uint16_t crnti, \ DU_FREE(dlCcchMsg, dlCcchMsgSize); /* Fill Pst */ - pst.selector = ODU_SELECTOR_LWLC; - pst.srcEnt = ENTDUAPP; - pst.dstEnt = ENTRG; - pst.dstInst = 0; - pst.srcInst = 0; - pst.dstProcId = DU_PROC; - pst.srcProcId = DU_PROC; - pst.region = DU_APP_MEM_REGION; - pst.pool = DU_POOL; - pst.event = EVENT_MAC_DL_CCCH_IND; - + FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_DL_CCCH_IND); ret = (*packMacDlCcchIndOpts[pst.selector])(&pst, dlCcchIndInfo); if(ret != ROK) { @@ -280,6 +216,182 @@ 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 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_LOGICAL_CHANNELS; lcIdx++) + { + if(ueCfg.rlcBearerCfg[lcIdx].lcId == lcId) + { + dlRrcMsgInfo->rbType = ueCfg.rlcBearerCfg[lcIdx].rbType; + dlRrcMsgInfo->rbId = ueCfg.rlcBearerCfg[lcIdx].rbId; + dlRrcMsgInfo->lcType = ueCfg.rlcBearerCfg[lcIdx].lcType; + dlRrcMsgInfo->lcId = ueCfg.rlcBearerCfg[lcIdx].lcId; + break; + } + } + dlRrcMsgInfo->execDup = false; + dlRrcMsgInfo->deliveryStaRpt = deliveryStaReq; + dlRrcMsgInfo->rrcMsg = rrcMsg; + dlRrcMsgInfo->msgLen = rrcMsgLen; + + /* Filling post structure and sending msg */ + memset(&pst, 0, sizeof(Pst)); + 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 Process UE context setup request from CU + * + * @details + * + * Function : procUeCintextSetupReq + * + * Functionality: Process UE context setup request from CU + * + * @params[in] F1AP message + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t procUeContextSetupReq(F1AP_PDU_t *f1apMsg) +{ + uint8_t ret = ROK; + uint8_t ieIdx, byteIdx, ueIdx; + uint8_t *rrcMsg = NULLP; + uint16_t rrcMsgLen; + uint16_t cellId, cellIdx; + uint32_t gnbDuUeF1apId; /* GNB DU UE F1AP ID */ + uint32_t gnbCuUeF1apId; /* GNB CU UE F1AP ID */ + bool deliveryStaReq = false; /* RRC msg delivery status request */ + DuUeCb *ueCb = NULLP; + UEContextSetupRequest_t *ueSetReq = NULLP; + + ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest; + + /* TODO : fetch remaining values from f1ap msg */ + for(ieIdx=0; ieIdx < ueSetReq->protocolIEs.list.count; ieIdx++) + { + switch(ueSetReq->protocolIEs.list.array[ieIdx]->id) + { + case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID: + { + gnbCuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID; + break; + } + case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID: + { + gnbDuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID; + break; + } + case ProtocolIE_ID_id_ServCellIndex: + { + cellIdx = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.ServCellIndex; + break; + } + case ProtocolIE_ID_id_RRCContainer: + { + rrcMsgLen = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size; + DU_ALLOC_SHRABL_BUF(rrcMsg, rrcMsgLen); + if(!rrcMsg) + { + DU_LOG("\nDU APP : Memory allocation failed for RRC Msg in procUeCtxtSetupReq"); + return RFAILED; + } + memcpy(rrcMsg, ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,\ + rrcMsgLen); + break; + } + case ProtocolIE_ID_id_RRCDeliveryStatusRequest: + { + deliveryStaReq = true; + break; + } + default: + { + break; + } + } + } + + cellId = duCb.actvCellLst[cellIdx]->cellId; + for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++) + { + if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId) && + (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId && + duCb.actvCellLst[cellIdx]->ueCb[ueIdx].ueState == UE_ACTIVE)) + { + ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx]; + break; + } + } + + /* TODO : send RB config to MAC/RLC */ + + /* Sending DL RRC Message to RLC */ + if(ueIdx != MAX_NUM_UE) + { + ret = duBuildAndSendDlRrcMsgToRlc(cellId, ueCb->rlcUeCfg, SRB_ID_1, \ + deliveryStaReq, rrcMsgLen, rrcMsg); + } + else + { + DU_LOG("\nDU APP : No UE found for CuUeF1apId[%d] and DuUeF1apId[%d]", \ + gnbCuUeF1apId, gnbDuUeF1apId); + DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, rrcMsg, rrcMsgLen); + ret = RFAILED; + } + + return ret; +} + /****************************************************************** * * @brief Processes DL RRC Message Transfer sent by CU @@ -368,14 +480,14 @@ uint8_t procDlRrcMsgTrans(F1AP_PDU_t *f1apMsg) } if(srbId == SRB_ID_1) //RRC connection setup { - ret = duBuildAndSendDlCcchInd(cellId, crnti, RRC_SETUP, dlCcchMsg, dlCcchMsgSize); + ret = duBuildAndSendDlCcchInd(&cellId, &crnti, RRC_SETUP, dlCcchMsg, dlCcchMsgSize); if(ret) { DU_LOG("\nDU_APP: Falied at duBuildAndSendDlCcchInd()"); } else { - if(duCb.actvCellLst[cellId-1]->numActvUes < DU_MAX_UE) + if(duCb.actvCellLst[cellId-1]->numActvUes < MAX_NUM_UE) { ret = duCreateUeCb(&duCb.ueCcchCtxt[idx], gnbCuUeF1apId); if(ret) @@ -445,15 +557,15 @@ uint8_t duProcUlCcchInd(UlCcchIndInfo *ulCcchIndInfo) duCb.numUe++; - ret = (BuildAndSendInitialRrcMsgTransfer(gnbDuUeF1apId, ulCcchIndInfo->crnti, + ret = (BuildAndSendInitialRrcMsgTransfer(gnbDuUeF1apId, ulCcchIndInfo->crnti, ulCcchIndInfo->ulCcchMsgLen, ulCcchIndInfo->ulCcchMsg)); if(ret != ROK) { DU_LOG("\nDU_APP : BuildAndSendInitialRrcMsgTransfer failed"); } - DU_FREE_SHRABL_BUF(MAC_MEM_REGION, RG_POOL, ulCcchIndInfo->ulCcchMsg, strlen((const char*)ulCcchIndInfo->ulCcchMsg)); - DU_FREE_SHRABL_BUF(MAC_MEM_REGION, RG_POOL, ulCcchIndInfo, sizeof(UlCcchIndInfo)); + DU_FREE_SHRABL_BUF(MAC_MEM_REGION, MAC_POOL, ulCcchIndInfo->ulCcchMsg, ulCcchIndInfo->ulCcchMsgLen); + DU_FREE_SHRABL_BUF(MAC_MEM_REGION, MAC_POOL, ulCcchIndInfo, sizeof(UlCcchIndInfo)); return ret; @@ -474,6 +586,9 @@ uint8_t duProcUlCcchInd(UlCcchIndInfo *ulCcchIndInfo) void fillInitDlBwp(InitialDlBwp *initDlBwp) { uint8_t idx = 0; + uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0}; + uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb; + if(initDlBwp) { @@ -486,11 +601,17 @@ void fillInitDlBwp(InitialDlBwp *initDlBwp) if(initDlBwp->pdcchCfg.numCRsetToAddMod <= MAX_NUM_CRSET) { initDlBwp->pdcchCfg.cRSetToAddModList[idx].cRSetId = \ - PDCCH_CTRL_RSRC_SET_ONE_ID; + PDCCH_CTRL_RSRC_SET_ONE_ID; memset(initDlBwp->pdcchCfg.cRSetToAddModList[idx].freqDomainRsrc, 0,\ FREQ_DOM_RSRC_SIZE); - initDlBwp->pdcchCfg.cRSetToAddModList[idx].freqDomainRsrc[idx] =\ - PDCCH_FREQ_DOM_RSRC; + coreset0EndPrb = CORESET0_END_PRB; + coreset1StartPrb = coreset0EndPrb +6; + coreset1NumPrb = CORESET1_NUM_PRB; + /* calculate the PRBs */ + schAllocFreqDomRscType0(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource); + memcpy(initDlBwp->pdcchCfg.cRSetToAddModList[idx].freqDomainRsrc, freqDomainResource, + FREQ_DOM_RSRC_SIZE); + initDlBwp->pdcchCfg.cRSetToAddModList[idx].duration = \ PDCCH_CTRL_RSRC_SET_ONE_DURATION; initDlBwp->pdcchCfg.cRSetToAddModList[idx].cceRegMappingType = \ @@ -810,10 +931,13 @@ void fillLcCfgList(LcCfg *lcCfgInfo) * * *****************************************************************/ -void fillMacUeCfg(MacUeCfg *ueCfg) +void fillMacUeCfg(uint16_t cellId, uint8_t ueIdx,\ + uint16_t crnti, MacUeCfg *ueCfg) { uint8_t idx; - + ueCfg->cellId = cellId; + ueCfg->ueIdx = ueIdx; + ueCfg->crnti = crnti; /* Filling MacCellGroup Config */ fillMacCellGrpInfo(&ueCfg->macCellGrpCfg); /* Filling PhyCellGroup Config */ @@ -834,6 +958,143 @@ void fillMacUeCfg(MacUeCfg *ueCfg) } +/****************************************************************** + * + * @brief Fills Rlc AM Information + * + * @details + * + * Function : fillAmInfo + * + * Functionality: Fills Rlc AM Information + * + * + *****************************************************************/ +void fillAmInfo(AmBearerCfg *amCfg) +{ + /* DL AM */ + amCfg->dlAmCfg.snLenDl = AM_SIZE_12; + amCfg->dlAmCfg.pollRetxTmr = POLL_RETX_TMR_45MS; + amCfg->dlAmCfg.pollPdu = POLL_PDU_TMR_INFINITY; + amCfg->dlAmCfg.pollByte = POLL_BYTES_INFINITY; + amCfg->dlAmCfg.maxRetxTh = RETX_TH_8; + + /* UL AM */ + amCfg->ulAmCfg.snLenUl = AM_SIZE_12; + amCfg->ulAmCfg.reAssemTmr = RE_ASM_40MS; + amCfg->ulAmCfg.statProhTmr = PROH_35MS; + +} + +/****************************************************************** + * + * @brief Fills RLC UM Bi Directional Information + * + * @details + * + * Function : fillUmBiDirInfo + * + * Functionality: Fills RLC UM Bi Directional Information + * + * + *****************************************************************/ +void fillUmBiDirInfo(UmBiDirBearerCfg *umBiDirCfg) +{ + /* UL UM BI DIR INFO */ + umBiDirCfg->ulUmCfg.snLenUlUm = UM_SIZE_12; + umBiDirCfg->ulUmCfg.reAssemTmr = RE_ASM_40MS; + + /* DL UM BI DIR INFO */ + umBiDirCfg->dlUmCfg.snLenDlUm = UM_SIZE_12; + +} + +/****************************************************************** + * + * @brief Fills RLC UM Uni Directional UL Information + * + * @details + * + * Function : fillUmUniDirUlInfo + * + * Functionality: Fills RLC UM Uni Directional Info + * + * + *****************************************************************/ +void fillUmUniDirUlInfo(UmUniDirUlBearerCfg *umUniDirUlCfg) +{ + umUniDirUlCfg->ulUmCfg.snLenUlUm = UM_SIZE_12; + umUniDirUlCfg->ulUmCfg.reAssemTmr = RE_ASM_40MS; +} + +/****************************************************************** + * + * @brief Fills RLC UM Uni Directional DL Information + * + * @details + * + * Function : fillUmUniDirDlInfo + * + * Functionality: Fills RLC UM Uni Directional DL Info + * + * + *****************************************************************/ +void fillUmUniDirDlInfo(UmUniDirDlBearerCfg *umUniDirDlCfg) +{ + umUniDirDlCfg->dlUmCfg.snLenDlUm = UM_SIZE_12; +} + +/****************************************************************** + * + * @brief Fills RlcBearerCfg structure + * + * @details + * + * Function : fillRlcBearerCfg + * + * Functionality: Fills Rlc Bearer Cfg + * + * + *****************************************************************/ +void fillRlcBearerCfg(uint16_t cellId, uint8_t ueIdx, RlcUeCfg *ueCfg) +{ + uint8_t idx; + ueCfg->cellId = cellId; + ueCfg->ueIdx = ueIdx; + ueCfg->numLcs = SRB_ID_1; + + for(idx = 0; idx < ueCfg->numLcs; idx++) + { + 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) + { + 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; + } + } +} + /****************************************************************** * * @brief creates UE context @@ -856,32 +1117,35 @@ uint8_t duCreateUeCb(UeCcchCtxt *ueCcchCtxt, uint32_t gnbCuUeF1apId) uint8_t ret = ROK; uint8_t ueIdx; - for(cellIdx = 0; cellIdx < DU_MAX_CELLS; cellIdx++) + for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++) { if(ueCcchCtxt->cellId == duCb.actvCellLst[cellIdx]->cellId) { GET_UE_IDX(ueCcchCtxt->crnti, ueIdx); DU_LOG("\nDU_APP: Filling UeCb for ueIdx [%d]", ueIdx); - duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId = ueCcchCtxt->gnbDuUeF1apId; - duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId = gnbCuUeF1apId; - duCb.actvCellLst[cellIdx]->ueCb[ueIdx].ueState = UE_ACTIVE; + + duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId = ueCcchCtxt->gnbDuUeF1apId; + duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId = gnbCuUeF1apId; + duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].ueState = UE_ACTIVE; /* Filling Mac Ue Config */ - memset(&duCb.actvCellLst[cellIdx]->ueCb[ueIdx].macUeCfg, 0, sizeof(MacUeCfg)); - duCb.actvCellLst[cellIdx]->ueCb[ueIdx].macUeCfg.cellId = ueCcchCtxt->cellId; - duCb.actvCellLst[cellIdx]->ueCb[ueIdx].macUeCfg.ueIdx = ueIdx; - duCb.actvCellLst[cellIdx]->ueCb[ueIdx].macUeCfg.crnti = ueCcchCtxt->crnti; - fillMacUeCfg(&duCb.actvCellLst[cellIdx]->ueCb[ueIdx].macUeCfg); + 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) + 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) + DU_LOG("\nDU_APP: Failed to send UE create request to RLC"); + duCb.actvCellLst[cellIdx]->numActvUes++; memset(ueCcchCtxt, 0, sizeof(UeCcchCtxt)); - - /* Send Ue Create Request to MAC */ - ret = duBuildAndSendUeCreateReqToMac(duCb.actvCellLst[cellIdx]->ueCb[ueIdx].macUeCfg.cellId, ueIdx); - if(ret) - DU_LOG("\nDU_APP: Failed to send UE create request to MAC"); } } - return ret; } @@ -902,32 +1166,27 @@ uint8_t duCreateUeCb(UeCcchCtxt *ueCcchCtxt, uint32_t gnbCuUeF1apId) * * ****************************************************************/ -uint8_t duBuildAndSendUeCreateReqToMac(uint16_t cellId, uint8_t ueIdx) +uint8_t duBuildAndSendUeCreateReqToMac(uint16_t cellId, uint8_t ueIdx,\ + uint16_t crnti, MacUeCfg *duMacUeCfg) { uint8_t ret = ROK; MacUeCfg *macUeCfg = NULLP; Pst pst; - memset(&pst, 0, sizeof(Pst)); + fillMacUeCfg(cellId, ueIdx, crnti, duMacUeCfg); + /* Fill Pst */ - pst.selector = ODU_SELECTOR_LWLC; - pst.srcEnt = ENTDUAPP; - pst.srcInst = DU_INST; - pst.dstEnt = ENTRG; - pst.dstInst = 0; - pst.dstProcId = DU_PROC; - pst.srcProcId = DU_PROC; - pst.region = DU_APP_MEM_REGION; - pst.pool = DU_POOL; - pst.event = EVENT_MAC_UE_CREATE_REQ; + FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_UE_CREATE_REQ); /* Copying ueCb to a sharable buffer */ DU_ALLOC_SHRABL_BUF(macUeCfg, sizeof(MacUeCfg)); if(macUeCfg) { memset(macUeCfg, 0, sizeof(MacUeCfg)); - memcpy(macUeCfg, &duCb.actvCellLst[cellId - 1]->ueCb[ueIdx].macUeCfg, sizeof(MacUeCfg)); + memcpy(macUeCfg, &duCb.actvCellLst[cellId - 1]->ueCb[ueIdx -1].macUeCfg, sizeof(MacUeCfg)); + DU_LOG("\nDU_APP: Sending UE create request to MAC"); + /* Processing one Ue at a time to MAC */ ret = (*packMacUeCreateReqOpts[pst.selector])(&pst, macUeCfg); if(ret) @@ -939,7 +1198,7 @@ uint8_t duBuildAndSendUeCreateReqToMac(uint16_t cellId, uint8_t ueIdx) } else { - DU_LOG("\n DU_APP: Memory alloc failed at duBuildAndSendUeCreateReq()"); + DU_LOG("\n DU_APP: Memory alloc failed at duBuildAndSendUeCreateReqToMac()"); ret = RFAILED; } return ret; @@ -951,16 +1210,16 @@ uint8_t duBuildAndSendUeCreateReqToMac(uint16_t cellId, uint8_t ueIdx) * * @details * - * Function : duHandleMacUeCreateRsp + * Function : DuHandleMacUeCreateRsp * * Functionality: Handle UE create response from MAC * - * @params[in] + * @params[in] Pointer to MacUeCfgRsp and Pst * @return ROK - success * RFAILED - failure * * ****************************************************************/ -uint8_t duHandleMacUeCreateRsp(Pst *pst, MacUeCfgRsp *cfgRsp) +uint8_t DuHandleMacUeCreateRsp(Pst *pst, MacUeCfgRsp *cfgRsp) { if(cfgRsp->result == MAC_DU_APP_RSP_OK) { @@ -973,6 +1232,104 @@ uint8_t duHandleMacUeCreateRsp(Pst *pst, MacUeCfgRsp *cfgRsp) return ROK; } +/******************************************************************* + * + * @brief Processes UE create Req to RLC UL + * + * @details + * + * Function : duBuildAndSendUeCreateReqToRlc + * + * Functionality: + * Processes UE create Req to RLC UL + * + * @params[in] cellId, + * ueIdx, + * Pointer to RlcUeCfg + * @return ROK - success + * RFAILED - failure + * + *****************************************************************/ + +uint8_t duBuildAndSendUeCreateReqToRlc(uint16_t cellId, uint8_t ueIdx, RlcUeCfg *duRlcUeCfg) +{ + uint8_t ret = ROK; + RlcUeCfg *rlcUeCfg = NULLP; + Pst pst; + memset(&pst, 0, sizeof(Pst)); + + fillRlcBearerCfg(cellId, ueIdx, duRlcUeCfg); + FILL_PST_DUAPP_TO_RLC(pst, RLC_UL_INST, EVENT_RLC_UL_UE_CREATE_REQ); + + /* Copying ueCfg to a sharable buffer */ + DU_ALLOC_SHRABL_BUF(rlcUeCfg, sizeof(RlcUeCfg)); + if(rlcUeCfg) + { + memset(rlcUeCfg, 0, sizeof(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) + { + 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)); + ret = RFAILED; + } + } + else + { + DU_LOG("\n DU_APP: Memory alloc failed at duBuildAndSendUeCreateReqToRlc()"); + ret = RFAILED; + } + return ret; +} + + + +/******************************************************************* + * + * @brief Processes UE create Rsp received from RLC UL + * + * @details + * + * Function : DuProcRlcUlUeCfgRsp + * + * Functionality: + * Processes UE create Rsp received from RLC UL + * + * @params[in] Post structure + * Pointer to RlcCfgCfm + * @return ROK - success + * RFAILED - failure + * + *****************************************************************/ + +uint8_t DuProcRlcUlUeCreateRsp(Pst *pst, RlcUeCfgRsp *cfgRsp) +{ + uint8_t ret = ROK; + + if(cfgRsp) + { + if(cfgRsp->result == RLC_DU_APP_RSP_OK) + { + DU_LOG("\nDU_APP: RLC UE Create Response : SUCCESS [UE IDX:%d]", cfgRsp->ueIdx); + } + else + { + DU_LOG("\nDU_APP: RLC UE Create Response : FAILED [UE IDX:%d, REASON :%d]",\ + cfgRsp->ueIdx, cfgRsp->reason); + 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"); + ret = RFAILED; + } + return ret; +} /********************************************************************** End of file ***********************************************************************/