X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrmac%2Fmac_ue_mgr.c;h=cea930536b26e49eca0ea738935897691f527ef5;hb=52ca0cf30806914e2f44054932cd2300f12aded8;hp=8262eeef993fcd060a3f7a699a1ce7e2f1272937;hpb=2dc9d6735bc5ff973a761b7d6b3f71f97e95d60e;p=o-du%2Fl2.git diff --git a/src/5gnrmac/mac_ue_mgr.c b/src/5gnrmac/mac_ue_mgr.c index 8262eeef9..cea930536 100644 --- a/src/5gnrmac/mac_ue_mgr.c +++ b/src/5gnrmac/mac_ue_mgr.c @@ -28,33 +28,18 @@ #include "mac.h" #include "mac_utils.h" -/* function pointers for packing slot ind from mac to sch */ -MacSchAddUeConfigReqFunc macSchAddUeConfigReqOpts[] = +MacDuUeCreateRspFunc macDuUeCreateRspOpts[] = { - packMacSchAddUeConfigReq, /* packing for loosely coupled */ - MacSchAddUeConfigReq, /* packing for tightly coupled */ - packMacSchAddUeConfigReq /* packing for light weight loosely coupled */ + packDuMacUeCreateRsp, /* packing for loosely coupled */ + DuProcMacUeCreateRsp, /* packing for tightly coupled */ + packDuMacUeCreateRsp /* packing for light weight loosly coupled */ }; -MacDuUeCfgRspFunc macDuUeCfgRspOpts[] = +MacDuUeRecfgRspFunc macDuUeRecfgRspOpts[] = { - packDuMacUeCfgRsp, /* packing for loosely coupled */ - DuProcMacUeCfgRsp, /* packing for tightly coupled */ - packDuMacUeCfgRsp /* packing for light weight loosly coupled */ -}; - -MacSchModUeConfigReqFunc macSchModUeConfigReqOpts[] = -{ - packMacSchModUeConfigReq, /* packing for loosely coupled */ - MacSchModUeConfigReq, /* packing for tightly coupled */ - packMacSchModUeConfigReq /* packing for light weight loosely coupled */ -}; - -MacSchUeDeleteReqFunc macSchUeDeleteReqOpts[] = -{ - packMacSchUeDeleteReq, /* packing for loosely coupled */ - MacSchUeDeleteReq, /* packing for tightly coupled */ - packMacSchUeDeleteReq /* packing for light weight loosely coupled */ + packDuMacUeRecfgRsp, /* packing for loosely coupled */ + DuProcMacUeRecfgRsp, /* packing for tightly coupled */ + packDuMacUeRecfgRsp /* packing for light weight loosly coupled */ }; MacDuUeDeleteRspFunc macDuUeDeleteRspOpts[] = @@ -64,20 +49,59 @@ MacDuUeDeleteRspFunc macDuUeDeleteRspOpts[] = packDuMacUeDeleteRsp /* packing for light weight loosly coupled */ }; -MacSchCellDeleteReqFunc macSchCellDeleteReqOpts[]= +MacDuUeResetRspFunc macDuUeResetRspOpts[] = { - packMacSchCellDeleteReq, /* packing for loosely coupled */ - MacSchCellDeleteReq, /* packing for tightly coupled */ - packMacSchCellDeleteReq /* packing for light weight loosely coupled */ + packDuMacUeResetRsp, /* packing for loosely coupled */ + DuProcMacUeResetRsp, /* packing for tightly coupled */ + packDuMacUeResetRsp /* packing for light weight loosly coupled */ }; -MacDuCellDeleteRspFunc macDuCellDeleteRspOpts[] = +MacDuUeSyncStatusIndFunc macDuUeSyncStatusIndOpts[] = { - packDuMacCellDeleteRsp, /* packing for loosely coupled */ - DuProcMacCellDeleteRsp, /* packing for tightly coupled */ - packDuMacCellDeleteRsp /* packing for light weight loosly coupled */ + packDuMacUeSyncStatusInd, /* packing for loosely coupled */ + DuProcMacUeSyncStatusInd, /* packing for tightly coupled */ + packDuMacUeSyncStatusInd /* packing for light weight loosly coupled */ }; +/******************************************************************* +* +* @brief Fill and Send UE Sync Status Indication from MAC to DU APP +* +* @details +* +* Function : MacSendUeSyncStatusInd +* +* Functionality: Fill and Send UE Sync Status Indication from MAC to DUAPP +* +* @params[in] uint16_t cellId, uint16_t ueId, SyncStatus status +* @return ROK - success +* RFAILED - failure +* +* ****************************************************************/ + +uint8_t MacSendUeSyncStatusInd(uint16_t cellId, uint16_t ueId, SyncStatus status) +{ + MacUeSyncStatusInd *ueSyncStatusInd; + Pst rspPst; + + MAC_ALLOC_SHRABL_BUF(ueSyncStatusInd, sizeof(MacUeSyncStatusInd)); + if(!ueSyncStatusInd) + { + DU_LOG("\nERROR --> MAC : Memory allocation for UE Sync Status Indication failed"); + return RFAILED; + } + + /* Filling UE Sync Status Indication */ + ueSyncStatusInd->cellId = cellId; + ueSyncStatusInd->ueId = ueId; + ueSyncStatusInd->status = status; + + /* Fill Post structure and send UE Sync Status Indication */ + memset(&rspPst, 0, sizeof(Pst)); + FILL_PST_MAC_TO_DUAPP(rspPst, EVENT_MAC_UE_SYNC_STATUS_IND); + return (*macDuUeSyncStatusIndOpts[rspPst.selector])(&rspPst, ueSyncStatusInd); +} + /******************************************************************* * * @brief Fills mac cell group config to be sent to scheduler @@ -150,6 +174,32 @@ uint8_t fillMacCellGroupCfg(MacCellGrpCfg macCellGrp, SchMacCellGrpCfg *macCell macCellGrpCfg->phrCfg.modeOtherCG = macCellGrp.phrCfg.phrOtherCG; } +#ifdef NR_DRX + /* Copy Drx configuration */ + macCellGrpCfg->drxCfgPresent = true; + macCellGrpCfg->drxCfg.drxOnDurationTimer.onDurationTimerValInMs = macCellGrp.drxCfg.drxOnDurationTimer.onDurationTimerValInMs; + if(!macCellGrp.drxCfg.drxOnDurationTimer.onDurationTimerValInMs) + macCellGrpCfg->drxCfg.drxOnDurationTimer.onDurationtimerValue.subMilliSeconds = \ + macCellGrp.drxCfg.drxOnDurationTimer.onDurationtimerValue.subMilliSeconds; + else + macCellGrpCfg->drxCfg.drxOnDurationTimer.onDurationtimerValue.milliSeconds = \ + macCellGrp.drxCfg.drxOnDurationTimer.onDurationtimerValue.milliSeconds; + macCellGrpCfg->drxCfg.drxInactivityTimer = macCellGrp.drxCfg.drxInactivityTimer; + macCellGrpCfg->drxCfg.drxHarqRttTimerDl = macCellGrp.drxCfg.drxHarqRttTimerDl; + macCellGrpCfg->drxCfg.drxHarqRttTimerUl = macCellGrp.drxCfg.drxHarqRttTimerUl; + macCellGrpCfg->drxCfg.drxRetransmissionTimerDl = macCellGrp.drxCfg.drxRetransmissionTimerDl; + macCellGrpCfg->drxCfg.drxRetransmissionTimerUl = macCellGrp.drxCfg.drxRetransmissionTimerUl; + macCellGrpCfg->drxCfg.drxLongCycleStartOffset.drxLongCycleStartOffsetChoice = macCellGrp.drxCfg.drxLongCycleStartOffset.\ + drxLongCycleStartOffsetChoice; + macCellGrpCfg->drxCfg.drxLongCycleStartOffset.drxLongCycleStartOffsetVal = macCellGrp.drxCfg.drxLongCycleStartOffset.drxLongCycleStartOffsetVal; + macCellGrpCfg->drxCfg.shortDrxPres = macCellGrp.drxCfg.shortDrxPres; + if(macCellGrpCfg->drxCfg.shortDrxPres) + { + macCellGrpCfg->drxCfg.shortDrx.drxShortCycle = macCellGrp.drxCfg.shortDrx.drxShortCycle; + macCellGrpCfg->drxCfg.shortDrx.drxShortCycleTimer = macCellGrp.drxCfg.shortDrx.drxShortCycleTimer; + } + macCellGrpCfg->drxCfg.drxSlotOffset = macCellGrp.drxCfg.drxSlotOffset; +#endif return ROK; } @@ -199,7 +249,7 @@ uint8_t fillPdschServCellCfg(PdschServCellCfg macPdschCfg, SchPdschServCellCfg * { if(!schPdschCfg->maxMimoLayers) { - MAC_ALLOC_SHRABL_BUF(schPdschCfg->maxMimoLayers, sizeof(uint8_t)); + MAC_ALLOC(schPdschCfg->maxMimoLayers, sizeof(uint8_t)); if(!schPdschCfg->maxMimoLayers) { DU_LOG("\nERROR --> MAC :Memory Alloc MimoLayers Failed at fillPdschServCellCfg()"); @@ -220,7 +270,7 @@ uint8_t fillPdschServCellCfg(PdschServCellCfg macPdschCfg, SchPdschServCellCfg * { if(!schPdschCfg->maxCodeBlkGrpPerTb) { - MAC_ALLOC_SHRABL_BUF(schPdschCfg->maxCodeBlkGrpPerTb, sizeof(SchMaxCodeBlkGrpPerTB)); + MAC_ALLOC(schPdschCfg->maxCodeBlkGrpPerTb, sizeof(SchMaxCodeBlkGrpPerTB)); if(!schPdschCfg->maxCodeBlkGrpPerTb) { DU_LOG("\nERROR --> MAC :Memory Alloc for code Block Failed at fillPdschServCellCfg()"); @@ -238,7 +288,7 @@ uint8_t fillPdschServCellCfg(PdschServCellCfg macPdschCfg, SchPdschServCellCfg * { if(!schPdschCfg->codeBlkGrpFlushInd) { - MAC_ALLOC_SHRABL_BUF(schPdschCfg->codeBlkGrpFlushInd, sizeof(bool)); + MAC_ALLOC(schPdschCfg->codeBlkGrpFlushInd, sizeof(bool)); if(!schPdschCfg->codeBlkGrpFlushInd) { DU_LOG("\nERROR --> MAC :Memory Alloc for Flush Ind Failed at fillPdschServCellCfg()"); @@ -256,7 +306,7 @@ uint8_t fillPdschServCellCfg(PdschServCellCfg macPdschCfg, SchPdschServCellCfg * { if(!schPdschCfg->xOverhead) { - MAC_ALLOC_SHRABL_BUF(schPdschCfg->xOverhead, sizeof(SchPdschXOverhead)); + MAC_ALLOC(schPdschCfg->xOverhead, sizeof(SchPdschXOverhead)); if(!schPdschCfg->xOverhead) { DU_LOG("\nERROR --> MAC :Memory Alloc for xOverHead Failed at fillPdschServCellCfg()"); @@ -1235,6 +1285,16 @@ uint8_t fillInitDlBwpPdschCfg(PdschConfig macPdschCfg, SchPdschConfig *schPdschC for(idx = 0; idx < schPdschCfg->numTimeDomRsrcAlloc; idx++) { + if(macPdschCfg.timeDomRsrcAllociList[idx].k0) + { + MAC_ALLOC(schPdschCfg->timeDomRsrcAllociList[idx].k0, sizeof(uint8_t)); + if(!schPdschCfg->timeDomRsrcAllociList[idx].k0) + { + DU_LOG("\nERROR --> MAC : Memory allocation failed for K0 in fillInitDlBwpPdschCfg()"); + return RFAILED; + } + *(schPdschCfg->timeDomRsrcAllociList[idx].k0) = *(macPdschCfg.timeDomRsrcAllociList[idx].k0); + } schPdschCfg->timeDomRsrcAllociList[idx].mappingType = \ macPdschCfg.timeDomRsrcAllociList[idx].mappingType; schPdschCfg->timeDomRsrcAllociList[idx].startSymbol = \ @@ -1333,15 +1393,14 @@ uint8_t fillSpCellCfg(SpCellCfg macSpCellCfg, SchSpCellCfg *schSpCellCfg) servCellCfg->numDlBwpToAdd = macSpCellCfg.servCellCfg.numDlBwpToAdd; if(servCellCfg->numDlBwpToAdd > MAX_NUM_BWP) { - DU_LOG("\nERROR --> MAC : Number of DL BWP to ADD/MOD [%d] exceeds max limit [%d]",\ + DU_LOG("\nERROR --> MAC : Number of DL BWP to ADD [%d] exceeds max limit [%d]",\ servCellCfg->numDlBwpToAdd, MAX_NUM_BWP); return RFAILED; } for(idx = 0; idx < servCellCfg->numDlBwpToAdd; idx++) { - /* TODO : As of now numDlBwpToAdd = 0 */ + memcpy(&servCellCfg->dlBwpToAddList[idx], &macSpCellCfg.servCellCfg.dlBwpToAddList[idx], sizeof(DlBwpInfo)); } - servCellCfg->firstActvDlBwpId = macSpCellCfg.servCellCfg.firstActvDlBwpId; servCellCfg->defaultDlBwpId = macSpCellCfg.servCellCfg.defaultDlBwpId; servCellCfg->bwpInactivityTmr = NULL; @@ -1369,19 +1428,124 @@ uint8_t fillSpCellCfg(SpCellCfg macSpCellCfg, SchSpCellCfg *schSpCellCfg) servCellCfg->numUlBwpToAdd = macSpCellCfg.servCellCfg.numUlBwpToAdd; if(servCellCfg->numUlBwpToAdd > MAX_NUM_BWP) { - DU_LOG("\nERROR --> MAC : Number of UL BWP to ADD/MOD [%d] exceeds max limit [%d]",\ + DU_LOG("\nERROR --> MAC : Number of UL BWP to ADD [%d] exceeds max limit [%d]",\ servCellCfg->numUlBwpToAdd, MAX_NUM_BWP); return RFAILED; } for(idx = 0; idx < servCellCfg->numUlBwpToAdd; idx++) { - /* TODO : As of now numDlBwpToAdd = 0 */ + memcpy(&servCellCfg->ulBwpToAddList[idx], &macSpCellCfg.servCellCfg.ulBwpToAddList[idx], sizeof(UlBwpInfo)); } servCellCfg->firstActvUlBwpId = macSpCellCfg.servCellCfg.firstActvUlBwpId; return ROK; } +/******************************************************************* + * + * @brief Fills Sp Cell Reconfig to be sent to scheduler + * + * @details + * + * Function : fillSpCellRecfg + * + * Functionality: Fills Sp Cell Reconfig to be sent to scheduler + * + * @params[in] macSpCellRecfg : SP cell Recfg at MAC + * schSpCellRecfg : SP cell Recfg to be filled + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t fillSpCellRecfg(SpCellRecfg macSpCellRecfg, SchSpCellRecfg *schSpCellRecfg) +{ + uint8_t idx; + SchServCellRecfgInfo *servCellRecfg; + + schSpCellRecfg->servCellIdx = macSpCellRecfg.servCellIdx; + servCellRecfg = &schSpCellRecfg->servCellRecfg; + + /* Fill initial DL BWP */ + if(fillInitialDlBwp(macSpCellRecfg.servCellCfg.initDlBwp, \ + &servCellRecfg->initDlBwp) != ROK ) + { + DU_LOG("\nERROR --> MAC : fillInitialDlBwp() failed"); + return RFAILED; + } + + servCellRecfg->numDlBwpToAddOrMod = macSpCellRecfg.servCellCfg.numDlBwpToAddOrMod; + if(servCellRecfg->numDlBwpToAddOrMod > MAX_NUM_BWP) + { + DU_LOG("\nERROR --> MAC : Number of DL BWP to ADD/MOD [%d] exceeds max limit [%d]",\ + servCellRecfg->numDlBwpToAddOrMod, MAX_NUM_BWP); + return RFAILED; + } + for(idx = 0; idx < servCellRecfg->numDlBwpToAddOrMod; idx++) + { + memcpy(&servCellRecfg->dlBwpToAddOrModList[idx], &macSpCellRecfg.servCellCfg.dlBwpToAddOrModList[idx], sizeof(DlBwpInfo)); + } + servCellRecfg->numDlBwpToRel = macSpCellRecfg.servCellCfg.numDlBwpToRel; + if(servCellRecfg->numDlBwpToRel > MAX_NUM_BWP) + { + DU_LOG("\nERROR --> MAC : Number of DL BWP to RELEASE [%d] exceeds max limit [%d]",\ + servCellRecfg->numDlBwpToRel, MAX_NUM_BWP); + return RFAILED; + } + for(idx = 0; idx < servCellRecfg->numDlBwpToRel; idx++) + { + memcpy(&servCellRecfg->dlBwpToRelList[idx], &macSpCellRecfg.servCellCfg.dlBwpToRelList[idx], sizeof(DlBwpInfo)); + } + servCellRecfg->firstActvDlBwpId = macSpCellRecfg.servCellCfg.firstActvDlBwpId; + servCellRecfg->defaultDlBwpId = macSpCellRecfg.servCellCfg.defaultDlBwpId; + servCellRecfg->bwpInactivityTmr = NULL; + if(macSpCellRecfg.servCellCfg.bwpInactivityTmr) + { + /* TODO : This is an optional parameter, not filled currently */ + } + + /* Fill PDSCH serving cell config */ + if(fillPdschServCellCfg(macSpCellRecfg.servCellCfg.pdschServCellCfg, \ + &servCellRecfg->pdschServCellCfg) != ROK) + { + DU_LOG("\nERROR --> MAC : fillPdschServCellCfg() failed"); + return RFAILED; + } + + /* Fill Initail UL BWP */ + if(fillInitialUlBwp(macSpCellRecfg.servCellCfg.initUlBwp, \ + &servCellRecfg->initUlBwp) != ROK) + { + DU_LOG("\nERROR --> MAC : fillInitialUlBwp() failed"); + return RFAILED; + } + + servCellRecfg->numUlBwpToAddOrMod = macSpCellRecfg.servCellCfg.numUlBwpToAddOrMod; + if(servCellRecfg->numUlBwpToAddOrMod > MAX_NUM_BWP) + { + DU_LOG("\nERROR --> MAC : Number of UL BWP to ADD/MOD [%d] exceeds max limit [%d]",\ + servCellRecfg->numUlBwpToAddOrMod, MAX_NUM_BWP); + return RFAILED; + } + for(idx = 0; idx < servCellRecfg->numUlBwpToAddOrMod; idx++) + { + memcpy(&servCellRecfg->ulBwpToAddOrModList[idx], &macSpCellRecfg.servCellCfg.ulBwpToAddOrModList[idx], sizeof(UlBwpInfo)); + } + servCellRecfg->numUlBwpToRel = macSpCellRecfg.servCellCfg.numUlBwpToRel; + if(servCellRecfg->numUlBwpToRel > MAX_NUM_BWP) + { + DU_LOG("\nERROR --> MAC : Number of UL BWP to RELEASE [%d] exceeds max limit [%d]",\ + servCellRecfg->numUlBwpToRel, MAX_NUM_BWP); + return RFAILED; + } + for(idx = 0; idx < servCellRecfg->numUlBwpToRel; idx++) + { + memcpy(&servCellRecfg->ulBwpToRelList[idx], &macSpCellRecfg.servCellCfg.ulBwpToRelList[idx], sizeof(UlBwpInfo)); + } + servCellRecfg->firstActvUlBwpId = macSpCellRecfg.servCellCfg.firstActvUlBwpId; + + return ROK; +} + /******************************************************************* * * @brief Sends UE configuration to Scheduler @@ -1398,21 +1562,30 @@ uint8_t fillSpCellCfg(SpCellCfg macSpCellCfg, SchSpCellCfg *schSpCellCfg) * * ****************************************************************/ -uint8_t sendUeReqToSch(Pst *pst, SchUeCfg *schUeCfg) +uint8_t sendUeReqToSch(Pst *pst, void *schUeCfg) { Pst schPst; switch(pst->event) { case EVENT_MAC_UE_CREATE_REQ: - FILL_PST_MAC_TO_SCH(schPst, EVENT_ADD_UE_CONFIG_REQ_TO_SCH); - return(*macSchAddUeConfigReqOpts[schPst.selector])(&schPst, schUeCfg); - + { + SchUeCfgReq *schUeCfgReq = NULLP; + schUeCfgReq = (SchUeCfgReq *)schUeCfg; + FILL_PST_MAC_TO_SCH(schPst, EVENT_ADD_UE_CONFIG_REQ_TO_SCH); + return(SchMessageRouter(&schPst, (void *)schUeCfgReq)); + } case EVENT_MAC_UE_RECONFIG_REQ: - FILL_PST_MAC_TO_SCH(schPst, EVENT_MODIFY_UE_CONFIG_REQ_TO_SCH); - return(*macSchModUeConfigReqOpts[schPst.selector])(&schPst,schUeCfg); + { + SchUeRecfgReq *schUeRecfgReq = NULLP; + schUeRecfgReq = (SchUeRecfgReq *)schUeCfg; + FILL_PST_MAC_TO_SCH(schPst, EVENT_MODIFY_UE_CONFIG_REQ_TO_SCH); + return(SchMessageRouter(&schPst, (void *)schUeRecfgReq)); + } default: - DU_LOG("\nERROR --> Invalid Pst received %d", pst->event); - return RFAILED; + { + DU_LOG("\nERROR --> Invalid Pst received %d", pst->event); + return RFAILED; + } } } @@ -1510,27 +1683,26 @@ uint8_t fillLogicalChannelCfg(SchLcCfg *schLcCfg, LcCfg *macLcCfg) uint8_t sdIdx; uint8_t ret = ROK; schLcCfg->lcId = macLcCfg->lcId; - schLcCfg->configType = macLcCfg->configType; schLcCfg->dlLcCfg.lcp = macLcCfg->dlLcCfg.lcp; fillSchUlLcCfg(&schLcCfg->ulLcCfg, &macLcCfg->ulLcCfg); if(macLcCfg->drbQos) { - if(!schLcCfg->drbQos) - { - MAC_ALLOC(schLcCfg->drbQos, sizeof(SchDrbQosInfo)); - if(!schLcCfg->drbQos) - { - DU_LOG("\nERROR --> MAC : Memory alloc failed at drbQos at fillLogicalChannelCfg()"); - ret = RFAILED; - } - } - if(ret == ROK) - { - fillSchDrbQosInfo(macLcCfg->drbQos, schLcCfg->drbQos); - } - else - return ret; + if(!schLcCfg->drbQos) + { + MAC_ALLOC(schLcCfg->drbQos, sizeof(SchDrbQosInfo)); + if(!schLcCfg->drbQos) + { + DU_LOG("\nERROR --> MAC : Memory alloc failed at drbQos at fillLogicalChannelCfg()"); + ret = RFAILED; + } + } + if(ret == ROK) + { + fillSchDrbQosInfo(macLcCfg->drbQos, schLcCfg->drbQos); + } + else + return ret; } else { @@ -1543,7 +1715,7 @@ uint8_t fillLogicalChannelCfg(SchLcCfg *schLcCfg, LcCfg *macLcCfg) { if(!schLcCfg->snssai) { - MAC_ALLOC(schLcCfg->snssai, sizeof(SchSnssai)); + MAC_ALLOC(schLcCfg->snssai, sizeof(Snssai)); if(!schLcCfg->snssai) { DU_LOG("\nERROR --> MAC : Memory alloc failed at snssai at fillLogicalChannelCfg()"); @@ -1555,20 +1727,9 @@ uint8_t fillLogicalChannelCfg(SchLcCfg *schLcCfg, LcCfg *macLcCfg) schLcCfg->snssai->sst = macLcCfg->snssai->sst; for(sdIdx = 0; sdIdx < SD_SIZE; sdIdx++) { - schLcCfg->snssai->sd[sdIdx] = macLcCfg->snssai->sd[sdIdx]; + schLcCfg->snssai->sd[sdIdx] = macLcCfg->snssai->sd[sdIdx]; } } - else - { - schLcCfg->snssai = NULLP; - /*Freeing the previously allocated buffer in case of failure */ - if(schLcCfg->drbQos) - { - MAC_FREE(schLcCfg->drbQos, sizeof(SchDrbQosInfo)); - schLcCfg->drbQos = NULLP; - } - return ret; - } } else { @@ -1581,13 +1742,13 @@ uint8_t fillLogicalChannelCfg(SchLcCfg *schLcCfg, LcCfg *macLcCfg) /******************************************************************* * - * @brief Fills Logical channel Cfg List to Add/Mod/Del + * @brief Fills Logical channel Cfg List to Add * * @details * * Function : fillSchLcCfgList * - * Functionality: Fills Logical channel Cfg List to Add/Mod/Del + * Functionality: Fills Logical channel Cfg List to Add * * @params[in] MAC UE Cb Cfg , MAC UE Configuration * @return ROK - success @@ -1595,7 +1756,7 @@ uint8_t fillLogicalChannelCfg(SchLcCfg *schLcCfg, LcCfg *macLcCfg) * * ****************************************************************/ -uint8_t fillSchLcCfgList(SchUeCfg *schUeCfg, MacUeCfg *ueCfg) +uint8_t fillSchLcCfgList(SchUeCfgReq *schUeCfg, MacUeCreateReq *ueCfg) { uint8_t lcIdx; @@ -1603,10 +1764,59 @@ uint8_t fillSchLcCfgList(SchUeCfg *schUeCfg, MacUeCfg *ueCfg) { if(fillLogicalChannelCfg(&schUeCfg->schLcCfg[lcIdx], &ueCfg->lcCfgList[lcIdx]) != ROK) { - DU_LOG("\nERROR --> MAC : fillLogicalChannelCfg() failed for lc Idx[%d]", lcIdx); - return RFAILED; + DU_LOG("\nERROR --> MAC : fillLogicalChannelCfg() failed for lc Idx[%d]", lcIdx); + return RFAILED; + } + schUeCfg->numLcsToAdd++; + } + return ROK; +} + +/******************************************************************* + * + * @brief Fills Logical channel Recfg List to Add/Mod/Del + * + * @details + * + * Function : fillSchLcRecfgList + * + * Functionality: Fills Logical channel Recfg List to Add/Mod/Del + * + * @params[in] MAC UE Cb Recfg , MAC UE ReConfiguration + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ + +uint8_t fillSchLcRecfgList(SchUeRecfgReq *schUeRecfg, MacUeRecfg *ueRecfg) +{ + uint8_t lcIdx; + + /*LC to ADD*/ + for(lcIdx = 0; lcIdx < ueRecfg->numLcsToAdd; lcIdx++) + { + if(fillLogicalChannelCfg(&schUeRecfg->schLcCfgAdd[lcIdx], &ueRecfg->lcCfgAdd[lcIdx]) != ROK) + { + DU_LOG("\nERROR --> MAC : fillLogicalChannelCfg() failed for lc Idx[%d]", lcIdx); + return RFAILED; + } + schUeRecfg->numLcsToAdd++; + } + /*LC to DEL*/ + for(lcIdx = 0; lcIdx < ueRecfg->numLcsToDel; lcIdx++) + { + schUeRecfg->lcIdToDel[lcIdx] = ueRecfg->lcIdToDel[lcIdx]; + schUeRecfg->numLcsToDel++; + } + /*LC to MOD*/ + for(lcIdx = 0; lcIdx < ueRecfg->numLcsToMod; lcIdx++) + { + if(fillLogicalChannelCfg(&schUeRecfg->schLcCfgMod[lcIdx], &ueRecfg->lcCfgMod[lcIdx]) != ROK) + { + DU_LOG("\nERROR --> MAC : fillLogicalChannelCfg() failed for lc Idx[%d]", lcIdx); + return RFAILED; } - schUeCfg->numLcs++; + schUeRecfg->numLcsToMod++; } return ROK; } @@ -1626,13 +1836,13 @@ uint8_t fillSchLcCfgList(SchUeCfg *schUeCfg, MacUeCfg *ueCfg) * RFAILED - failure * * ****************************************************************/ -uint8_t fillSchUeCfg(Pst *pst, SchUeCfg *schUeCfg, MacUeCfg *ueCfg) +uint8_t fillSchUeCfg(SchUeCfgReq *schUeCfg, MacUeCreateReq *ueCfg) { uint8_t ret = ROK; schUeCfg->cellId = ueCfg->cellId; + schUeCfg->ueId = ueCfg->ueId; schUeCfg->crnti = ueCfg->crnti; - /* Copy MAC cell group config */ if(ueCfg->macCellGrpCfgPres == true) { @@ -1678,8 +1888,9 @@ uint8_t fillSchUeCfg(Pst *pst, SchUeCfg *schUeCfg, MacUeCfg *ueCfg) schUeCfg->ambrCfg->ulBr = ueCfg->ambrCfg->ulBr; } else + { schUeCfg->ambrCfg = NULLP; - + } /* Fill DL modulation infor */ schUeCfg->dlModInfo.modOrder = ueCfg->dlModInfo.modOrder; schUeCfg->dlModInfo.mcsIndex = ueCfg->dlModInfo.mcsIndex; @@ -1690,13 +1901,110 @@ uint8_t fillSchUeCfg(Pst *pst, SchUeCfg *schUeCfg, MacUeCfg *ueCfg) schUeCfg->ulModInfo.mcsIndex = ueCfg->ulModInfo.mcsIndex; schUeCfg->ulModInfo.mcsTable = ueCfg->ulModInfo.mcsTable; - /* Fill sch Lc Cfg to Add/ Mod/ Del */ + /* Fill sch Lc Cfg to Add*/ ret = fillSchLcCfgList(schUeCfg, ueCfg); if(ret == RFAILED) { DU_LOG("\nERROR --> MAC : Failed to copy LCs at fillSchUeCfg()"); return ret; } + + return ret; +} + +/******************************************************************* + * + * @brief Fills and sends UE Re-configuration to Scheduler + * + * @details + * + * Function : fillSchUeRecfg + * + * Functionality: Fills and sends UE Reconfiguration to Scheduler + * + * @params[in] Ue configuration from DU APP + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t fillSchUeRecfg(SchUeRecfgReq *schUeRecfg, MacUeRecfg *ueRecfg) +{ + uint8_t ret = ROK; + + schUeRecfg->cellId = ueRecfg->cellId; + schUeRecfg->ueId = ueRecfg->ueId; + schUeRecfg->crnti = ueRecfg->crnti; + schUeRecfg->dataTransmissionInfo = ueRecfg->transmissionAction; + /* Copy MAC cell group config */ + if(ueRecfg->macCellGrpRecfgPres == true) + { + schUeRecfg->macCellGrpRecfgPres = true; + memset(&schUeRecfg->macCellGrpRecfg, 0, sizeof(SchMacCellGrpCfg)); + if(fillMacCellGroupCfg(ueRecfg->macCellGrpRecfg, &schUeRecfg->macCellGrpRecfg) != ROK) + { + DU_LOG("\nERROR --> MAC : fillMacCellGroupRecfg() failed"); + return RFAILED; + } + } + if(ueRecfg->phyCellGrpRecfgPres == true) + { + schUeRecfg->phyCellGrpRecfgPres = true; + /* Copy Physical cell group config */ + memset(&schUeRecfg->phyCellGrpRecfg, 0,sizeof(SchPhyCellGrpCfg)); + if(fillPhyCellGroupCfg(ueRecfg->phyCellGrpRecfg, &schUeRecfg->phyCellGrpRecfg) != ROK) + { + DU_LOG("\nERROR --> MAC : fillPhyCellGroupRecfg() failed"); + return RFAILED; + } + } + + if(ueRecfg->spCellRecfgPres == true) + { + schUeRecfg->spCellRecfgPres = true; + /* Copy sp cell config */ + memset(&schUeRecfg->spCellRecfg, 0, sizeof(SchSpCellCfg)); + if(fillSpCellRecfg(ueRecfg->spCellRecfg, &schUeRecfg->spCellRecfg) != ROK) + { + DU_LOG("\nERROR --> MAC : fillSpCellRecfg() failed"); + return RFAILED; + } + } + if(ueRecfg->ambrRecfg != NULLP) + { + MAC_ALLOC(schUeRecfg->ambrRecfg, sizeof(SchAmbrCfg)); + if(!schUeRecfg->ambrRecfg) + { + DU_LOG("\nERROR --> MAC : Memory allocation failed in sendReconfigReqToSch"); + return RFAILED; + } + schUeRecfg->ambrRecfg->ulBr = ueRecfg->ambrRecfg->ulBr; + } + else + { + schUeRecfg->ambrRecfg = NULLP; + } + /* Fill DL modulation infor */ + schUeRecfg->dlModInfo.modOrder = ueRecfg->dlModInfo.modOrder; + schUeRecfg->dlModInfo.mcsIndex = ueRecfg->dlModInfo.mcsIndex; + schUeRecfg->dlModInfo.mcsTable = ueRecfg->dlModInfo.mcsTable; + + /* Fill UL modulation infor */ + schUeRecfg->ulModInfo.modOrder = ueRecfg->ulModInfo.modOrder; + schUeRecfg->ulModInfo.mcsIndex = ueRecfg->ulModInfo.mcsIndex; + schUeRecfg->ulModInfo.mcsTable = ueRecfg->ulModInfo.mcsTable; + + /* Fill sch Lc Cfg to Add/ Mod/ Del */ + ret = fillSchLcRecfgList(schUeRecfg, ueRecfg); + if(ret == RFAILED) + { + DU_LOG("\nERROR --> MAC : Failed to copy LCs at fillSchUeRecfg()"); + return ret; + } + +#ifdef NR_DRX + schUeRecfg->drxConfigIndicatorRelease = ueRecfg->drxConfigIndicatorRelease;; +#endif + return ret; } @@ -1725,6 +2033,21 @@ void updateMacUlCb(uint8_t delIdx, UeUlCb *ulCb) memcpy(&ulCb->lcCb[lcIdx], &ulCb->lcCb[lcIdx+1], sizeof(UlLcCb)); memset(&ulCb->lcCb[lcIdx+1], 0, sizeof(UlLcCb)); } + /*Commenting as S-NSSAI and PDU session will be stored in MAC DB in future scope*/ +#if 0 + /*Checking the Memory Leakage of Last Index*/ + if(ulCb->lcCb[ulCb->numUlLc].snssai != NULLP) + { + DU_LOG("ERROR --> MAC: updateMacUlCb Last index deleted :%d memory is leaking",\ + ulCb->numUlLc); + MAC_FREE(ulCb->lcCb[ulCb->numUlLc].snssai, sizeof(Snssai)); + } + else + { + DU_LOG("INFO --> MAC: updateMacUlCb Last index:%d (before deletion) memory is freed successfully",\ + ulCb->numUlLc); + } +#endif } /******************************************************************* @@ -1752,80 +2075,293 @@ void updateMacDlCb(uint8_t delIdx, UeDlCb *dlCb) memcpy(&dlCb->lcCb[lcIdx], &dlCb->lcCb[lcIdx+1], sizeof(DlLcCb)); memset(&dlCb->lcCb[lcIdx+1], 0, sizeof(DlLcCb)); } + /*Commenting as S-NSSAI and PDU session will be stored in MAC DB in future scope*/ +#if 0 + /*Checking the Memory Leakage of Last Index*/ + if(dlCb->lcCb[dlCb->numDlLc].snssai != NULLP) + { + DU_LOG("ERROR --> MAC: updateMacDlCb Last Deleted index:%d memory is leaking",\ + dlCb->numDlLc); + MAC_FREE(dlCb->lcCb[dlCb->numDlLc].snssai, sizeof(Snssai)); + } + else + { + DU_LOG("INFO --> MAC: updateMacDlCb Last index:%d (before deletion) memory is freed successfully",\ + dlCb->numDlLc); + } +#endif } /******************************************************************* * - * @brief Fills Logical channel Cfg List to Add/Mod/Del + * @brief Update Mac UL Lc List based on CONFIG_MOD/CONFIG_DEL * * @details * - * Function : fillMacLcCfgList + * Function : updateMacUlLcCtxt * - * Functionality: Fills Logical channel Cfg List to Add/Mod/Del + * Functionality: Update UeUlCb Lc List * - * @params[in] MAC UE Cb Cfg , MAC UE Configuration - * @return ROK - success - * RFAILED - failure + * @params[in] UeUlCb pointer [For DEL case, NULL is passed] + * ueLcCfg(received from DUAPP) + * lcIdToDel [For MOD case, Invalid Value = MAX_NUM_LC is passed] + * @return void * * ****************************************************************/ - -uint8_t fillMacLcCfgList(MacUeCb *ueCb, MacUeCfg *ueCfg) +void updateMacUlLcCtxt(UeUlCb *ulInfo, LcCfg *ueLcCfg, uint8_t lcIdToDel) { - uint8_t lcIdx, ueLcIdx; + uint8_t ueLcIdx = 0; - for(lcIdx = 0; lcIdx < ueCfg->numLcs; lcIdx++) + /*Traversing UL LC to be updated/Deleted*/ + for(ueLcIdx = 0; ueLcIdx < ulInfo->numUlLc; ueLcIdx++) { - if(ueCb->dlInfo.numDlLc < MAX_NUM_LC) + if((ueLcCfg != NULLP) && (ulInfo->lcCb[ueLcIdx].lcId == ueLcCfg->lcId)) { - if(ueCfg->lcCfgList[lcIdx].configType == CONFIG_ADD) - { - /*Filling DL LC CB */ - ueCb->dlInfo.lcCb[ueCb->dlInfo.numDlLc].lcId = ueCfg->lcCfgList[lcIdx].lcId; - ueCb->dlInfo.lcCb[ueCb->dlInfo.numDlLc].lcState = MAC_LC_STATE_ACTIVE; - ueCb->dlInfo.numDlLc++; - /*Filling UL LC CB */ - ueCb->ulInfo.lcCb[ueCb->ulInfo.numUlLc].lcId = ueCfg->lcCfgList[lcIdx].lcId; - ueCb->ulInfo.lcCb[ueCb->ulInfo.numUlLc].lcGrpId = ueCfg->lcCfgList[lcIdx].ulLcCfg.lcGroup; - ueCb->ulInfo.lcCb[ueCb->ulInfo.numUlLc].lcActive = MAC_LC_STATE_ACTIVE; - ueCb->ulInfo.numUlLc++; - }/*End of Add Config */ - else - { - //searching for Lc to be Mod - for(ueLcIdx = 0; ueLcIdx < ueCb->ulInfo.numUlLc; ueLcIdx++) - { - if(ueCb->ulInfo.lcCb[ueLcIdx].lcId == ueCfg->lcCfgList[lcIdx].lcId) - { - if(ueCfg->lcCfgList[lcIdx].configType == CONFIG_MOD) - { - /*Nothing to Modify in DL LC CB */ - /*Modify UL LC CB */ - ueCb->ulInfo.lcCb[ueLcIdx].lcGrpId = ueCfg->lcCfgList[lcIdx].ulLcCfg.lcGroup; - DU_LOG("\nINFO --> MAC: Successfully Modified LC context for lcId[%d]", ueCfg->lcCfgList[lcIdx].lcId); - break; - } - if(ueCfg->lcCfgList[lcIdx].configType == CONFIG_DEL) - { - memset(&ueCb->dlInfo.lcCb[ueLcIdx], 0, sizeof(DlLcCb)); - (ueCb->dlInfo.numDlLc)--; - updateMacDlCb(ueLcIdx, &ueCb->dlInfo); - - memset(&ueCb->ulInfo.lcCb[ueLcIdx], 0, sizeof(UlLcCb)); - (ueCb->ulInfo.numUlLc)--; - updateMacUlCb(ueLcIdx, &ueCb->ulInfo); - DU_LOG("\nINFO --> MAC: Successfully Deleted LC context for lcId[%d]", ueCfg->lcCfgList[lcIdx].lcId); - break; - } - } - } - }/*End of Mod Config */ - } - } - return ROK; -} + /*Modify UL LC CB */ + ulInfo->lcCb[ueLcIdx].lcGrpId = ueLcCfg->ulLcCfg.lcGroup; -/******************************************************************* + /*Commenting as S-NSSAI and PDU session will be stored in MAC DB in future scope*/ +#if 0 + /*Modifying/Copying PduSession ID and S-NSSAI into MAC's UECB*/ + if(ueLcCfg->drbQos) + { + ulInfo->lcCb[ueLcIdx].pduSessionId = ueLcCfg->drbQos->pduSessionId; + } + if(ueLcCfg->snssai) + { + if(ulInfo->lcCb[ueLcIdx].snssai == NULLP) + { + MAC_ALLOC(ulInfo->lcCb[ueLcIdx].snssai, sizeof(Snssai)); + } + + memcpy(ulInfo->lcCb[ueLcIdx].snssai, ueLcCfg->snssai, sizeof(Snssai)); + } +#endif + DU_LOG("\nINFO --> MAC: Successfully Modified LC context for lcId[%d], ueLcIdx:%d",\ + ueLcCfg->lcId,ueLcIdx); + break; + } + else if(lcIdToDel != MAX_NUM_LC && (ulInfo->lcCb[ueLcIdx].lcId == lcIdToDel)) + { + memset(&ulInfo->lcCb[ueLcIdx], 0, sizeof(UlLcCb)); + (ulInfo->numUlLc)--; + updateMacUlCb(ueLcIdx, ulInfo); + DU_LOG("\nINFO --> MAC: Successfully Deleted LC context for lcId[%d]", lcIdToDel); + break; + } + } +} + +/******************************************************************* + * + * @brief Update Mac DL Lc List based on CONFIG_MOD/CONFIG_DEL + * + * @details + * + * Function : updateMacDlLcCtxt + * + * Functionality: Update UeDlCb Lc List + * + * @params[in] UeDlCb pointer [For DEL case, NULL is passed] + * ueLcCfg(received from DUAPP) + * lcIdToDel [For MOD case, Invalid Value = MAX_NUM_LC is passed] + * @return void + * + * ****************************************************************/ +void updateMacDlLcCtxt(UeDlCb *dlInfo, LcCfg *ueLcCfg, uint8_t lcIdToDel) +{ + uint8_t ueLcIdx = 0; + + /*Traversing DL LC to be updated/Deleted*/ + for(ueLcIdx = 0; ueLcIdx < dlInfo->numDlLc; ueLcIdx++) + { + if((ueLcCfg != NULLP) && (dlInfo->lcCb[ueLcIdx].lcId == ueLcCfg->lcId)) + { + /*Commenting as S-NSSAI and PDU session will be stored in MAC DB in future scope*/ +#if 0 + /*Modifying/Copying PduSession ID and S-NSSAI into MAC's UECB*/ + if(ueLcCfg->drbQos) + { + dlInfo->lcCb[ueLcIdx].pduSessionId = ueLcCfg->drbQos->pduSessionId; + } + if(ueLcCfg->snssai) + { + if(dlInfo->lcCb[ueLcIdx].snssai == NULLP) + { + MAC_ALLOC(dlInfo->lcCb[ueLcIdx].snssai, sizeof(Snssai)); + } + + memcpy(dlInfo->lcCb[ueLcIdx].snssai, ueLcCfg->snssai, sizeof(Snssai)); + } +#endif + DU_LOG("\nINFO --> MAC: Successfully Modified LC context for lcId[%d], ueLcIdx:%d",\ + ueLcCfg->lcId,ueLcIdx); + break; + } + else if(lcIdToDel != MAX_NUM_LC && (dlInfo->lcCb[ueLcIdx].lcId == lcIdToDel)) + { + memset(&dlInfo->lcCb[ueLcIdx], 0, sizeof(DlLcCb)); + (dlInfo->numDlLc)--; + updateMacDlCb(ueLcIdx, dlInfo); + DU_LOG("\nINFO --> MAC: Successfully Deleted LC context for lcId[%d]", lcIdToDel); + break; + } + } +} + +/******************************************************************* + * + * @brief Fills Logical channel Cfg List to Add/Mod/Del + * + * @details + * + * Function : fillMacLcCfgList + * + * Functionality: Fills Logical channel Cfg List to Add/Mod/Del + * + * @params[in] MAC UE Cb Cfg , MAC UE Configuration + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ + +uint8_t fillMacLcCfgList(MacUeCb *ueCb, MacUeCreateReq *ueCfg) +{ + uint8_t lcIdx = 0; + + for(lcIdx = 0; lcIdx < ueCfg->numLcs; lcIdx++) + { + if(ueCb->dlInfo.numDlLc < MAX_NUM_LC) + { + /*Commenting as S-NSSAI and PDU session will be stored in MAC DB in future scope*/ +#if 0 + /*Copying PduSession ID and S-NSSAI into MAC's UECB*/ + if(ueCfg->lcCfgList[lcIdx].drbQos) + { + ueCb->dlInfo.lcCb[ueCb->dlInfo.numDlLc].pduSessionId = \ + ueCfg->lcCfgList[lcIdx].drbQos->pduSessionId; + + ueCb->ulInfo.lcCb[ueCb->ulInfo.numUlLc].pduSessionId = \ + ueCfg->lcCfgList[lcIdx].drbQos->pduSessionId; + } + if(ueCfg->lcCfgList[lcIdx].snssai) + { + if(ueCb->dlInfo.lcCb[ueCb->dlInfo.numDlLc].snssai == NULLP) + { + MAC_ALLOC(ueCb->dlInfo.lcCb[ueCb->dlInfo.numDlLc].snssai, sizeof(Snssai)); + } + if(ueCb->ulInfo.lcCb[ueCb->ulInfo.numUlLc].snssai == NULLP) + { + MAC_ALLOC(ueCb->ulInfo.lcCb[ueCb->ulInfo.numUlLc].snssai, sizeof(Snssai)); + } + + memcpy(ueCb->dlInfo.lcCb[ueCb->dlInfo.numDlLc].snssai, \ + ueCfg->lcCfgList[lcIdx].snssai, sizeof(Snssai)); + + memcpy(ueCb->ulInfo.lcCb[ueCb->ulInfo.numUlLc].snssai, \ + ueCfg->lcCfgList[lcIdx].snssai, sizeof(Snssai)); + + } +#endif + /*Filling DL LC CB */ + ueCb->dlInfo.lcCb[ueCb->dlInfo.numDlLc].lcId = ueCfg->lcCfgList[lcIdx].lcId; + ueCb->dlInfo.lcCb[ueCb->dlInfo.numDlLc].lcState = MAC_LC_STATE_ACTIVE; + ueCb->dlInfo.numDlLc++; + /*Filling UL LC CB */ + ueCb->ulInfo.lcCb[ueCb->ulInfo.numUlLc].lcId = ueCfg->lcCfgList[lcIdx].lcId; + ueCb->ulInfo.lcCb[ueCb->ulInfo.numUlLc].lcGrpId = ueCfg->lcCfgList[lcIdx].ulLcCfg.lcGroup; + ueCb->ulInfo.lcCb[ueCb->ulInfo.numUlLc].lcActive = MAC_LC_STATE_ACTIVE; + ueCb->ulInfo.numUlLc++; + } + } + return ROK; +} + +/******************************************************************* + * + * @brief Fills Logical channel Cfg List to Add/Mod/Del + * + * @details + * + * Function : updateMacLcCfgList + * + * Functionality: Fills Logical channel Cfg List to Add/Mod/Del + * + * @params[in] MAC UE Cb Cfg , MAC UE Configuration + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ + +uint8_t updateMacLcCfgList(MacUeCb *ueCb, MacUeRecfg *ueRecfg) +{ + uint8_t lcIdx = 0; + + for(lcIdx = 0; lcIdx < ueRecfg->numLcsToAdd; lcIdx++) + { + if(ueCb->dlInfo.numDlLc < MAX_NUM_LC) + { + /*Commenting as S-NSSAI and PDU session will be stored in MAC DB in future scope*/ +#if 0 + /*Copying PduSession ID and S-NSSAI into MAC's UECB*/ + if(ueRecfg->lcCfgList[lcIdx].drbQos) + { + ueCb->dlInfo.lcCb[ueCb->dlInfo.numDlLc].pduSessionId = \ + ueRecfg->lcCfgList[lcIdx].drbQos->pduSessionId; + + ueCb->ulInfo.lcCb[ueCb->ulInfo.numUlLc].pduSessionId = \ + ueRecfg->lcCfgList[lcIdx].drbQos->pduSessionId; + } + if(ueRecfg->lcCfgList[lcIdx].snssai) + { + if(ueCb->dlInfo.lcCb[ueCb->dlInfo.numDlLc].snssai == NULLP) + { + MAC_ALLOC(ueCb->dlInfo.lcCb[ueCb->dlInfo.numDlLc].snssai, sizeof(Snssai)); + } + if(ueCb->ulInfo.lcCb[ueCb->ulInfo.numUlLc].snssai == NULLP) + { + MAC_ALLOC(ueCb->ulInfo.lcCb[ueCb->ulInfo.numUlLc].snssai, sizeof(Snssai)); + } + + memcpy(ueCb->dlInfo.lcCb[ueCb->dlInfo.numDlLc].snssai, \ + ueRecfg->lcCfgList[lcIdx].snssai, sizeof(Snssai)); + + memcpy(ueCb->ulInfo.lcCb[ueCb->ulInfo.numUlLc].snssai, \ + ueRecfg->lcCfgList[lcIdx].snssai, sizeof(Snssai)); + + } +#endif + /*Filling DL LC CB */ + ueCb->dlInfo.lcCb[ueCb->dlInfo.numDlLc].lcId = ueRecfg->lcCfgAdd[lcIdx].lcId; + ueCb->dlInfo.lcCb[ueCb->dlInfo.numDlLc].lcState = MAC_LC_STATE_ACTIVE; + ueCb->dlInfo.numDlLc++; + /*Filling UL LC CB */ + ueCb->ulInfo.lcCb[ueCb->ulInfo.numUlLc].lcId = ueRecfg->lcCfgAdd[lcIdx].lcId; + ueCb->ulInfo.lcCb[ueCb->ulInfo.numUlLc].lcGrpId = ueRecfg->lcCfgAdd[lcIdx].ulLcCfg.lcGroup; + ueCb->ulInfo.lcCb[ueCb->ulInfo.numUlLc].lcActive = MAC_LC_STATE_ACTIVE; + ueCb->ulInfo.numUlLc++; + }/*End of Add Config */ + } + for(lcIdx = 0; lcIdx < ueRecfg->numLcsToDel; lcIdx++) + { + if(ueCb->dlInfo.numDlLc < MAX_NUM_LC) + { + updateMacUlLcCtxt(&ueCb->ulInfo, NULLP, ueRecfg->lcIdToDel[lcIdx]); + updateMacDlLcCtxt(&ueCb->dlInfo, NULLP, ueRecfg->lcIdToDel[lcIdx]); + } + } + for(lcIdx = 0; lcIdx < ueRecfg->numLcsToMod; lcIdx++) + { + if(ueCb->dlInfo.numDlLc < MAX_NUM_LC) + { + updateMacUlLcCtxt(&ueCb->ulInfo, &ueRecfg->lcCfgMod[lcIdx], MAX_NUM_LC); + updateMacDlLcCtxt(&ueCb->dlInfo, &ueRecfg->lcCfgMod[lcIdx], MAX_NUM_LC); + } + } + return ROK; +} + +/******************************************************************* * * @brief Fills MAC UE Cb Cfg * @@ -1842,11 +2378,11 @@ uint8_t fillMacLcCfgList(MacUeCb *ueCb, MacUeCfg *ueCfg) * * ****************************************************************/ -uint8_t fillMacUeCb(MacUeCb *ueCb, MacUeCfg *ueCfg, uint8_t cellIdx) +uint8_t fillMacUeCb(MacUeCb *ueCb, MacUeCreateReq *ueCfg, uint8_t cellIdx) { uint8_t ret = ROK; - ueCb->ueIdx = ueCfg->ueIdx; + ueCb->ueId = ueCfg->ueId; ueCb->crnti = ueCfg->crnti; ueCb->cellCb = macCb.macCell[cellIdx]; if(ueCfg->spCellCfgPres) @@ -1854,7 +2390,7 @@ uint8_t fillMacUeCb(MacUeCb *ueCb, MacUeCfg *ueCfg, uint8_t cellIdx) ueCb->dlInfo.dlHarqEnt.numHarqProcs = \ ueCfg->spCellCfg.servCellCfg.pdschServCellCfg.numHarqProcForPdsch; } - ueCb->state = UE_STATE_ACTIVE; + /*TODO: To check the bsr value during implementation */ if(ueCfg->macCellGrpCfgPres) { @@ -1870,6 +2406,53 @@ uint8_t fillMacUeCb(MacUeCb *ueCb, MacUeCfg *ueCfg, uint8_t cellIdx) return ret; } +/******************************************************************* + * + * @brief Fills MAC UE Cb Cfg + * + * @details + * + * Function : updateMacUeCb + * + * Functionality: updateMacUeCbs MAC UE Cb Cfg + * + * @params[in] MAC UE Cb Recfg , MAC UE Configuration + * cellIdx + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ + +uint8_t updateMacUeCb(MacUeCb *ueCb, MacUeRecfg *ueRecfg, uint8_t cellIdx) +{ + uint8_t ret = ROK; + + ueCb->ueId = ueRecfg->ueId; + ueCb->crnti = ueRecfg->crnti; + ueCb->cellCb = macCb.macCell[cellIdx]; + if(ueRecfg->spCellRecfgPres) + { + ueCb->dlInfo.dlHarqEnt.numHarqProcs = \ + ueRecfg->spCellRecfg.servCellCfg.pdschServCellCfg.numHarqProcForPdsch; + } + + /*TODO: To check the bsr value during implementation */ + if(ueRecfg->macCellGrpRecfgPres) + { + ueCb->bsrTmrCfg.periodicTimer = ueRecfg->macCellGrpRecfg.bsrTmrCfg.periodicTimer; + ueCb->bsrTmrCfg.retxTimer = ueRecfg->macCellGrpRecfg.bsrTmrCfg.retxTimer; + ueCb->bsrTmrCfg.srDelayTimer = ueRecfg->macCellGrpRecfg.bsrTmrCfg.srDelayTimer; + } + ret = updateMacLcCfgList(ueCb, ueRecfg); + if(ret == RFAILED) + { + DU_LOG("\nERROR --> MAC: Failed while filing MAC LC List at updateMacUeCb()"); + } + ueCb->transmissionAction = ueRecfg->transmissionAction; + + return ret; +} + /******************************************************************* * * @brief Function to update Mac Ra Cb @@ -1888,15 +2471,15 @@ uint8_t fillMacUeCb(MacUeCb *ueCb, MacUeCfg *ueCfg, uint8_t cellIdx) uint8_t updateMacRaCb(uint16_t cellIdx, MacUeCb *ueCb) { - uint8_t ueIdx; /* Copy RA Cb */ - for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++) + if(macCb.macCell[cellIdx]->macRaCb[ueCb->ueId-1].crnti == ueCb->crnti) { - if(macCb.macCell[cellIdx]->macRaCb[ueIdx].crnti == ueCb->crnti) - { - ueCb->raCb = &macCb.macCell[cellIdx]->macRaCb[ueIdx]; - break; - } + ueCb->raCb = &macCb.macCell[cellIdx]->macRaCb[ueCb->ueId-1]; + } + else + { + DU_LOG("\nERROR --> MAC : No RA CB found for UE ID [%d]", ueCb->ueId); + return RFAILED; } return ROK; } @@ -1918,27 +2501,19 @@ uint8_t updateMacRaCb(uint16_t cellIdx, MacUeCb *ueCb) void deleteMacRaCb(uint16_t cellIdx, MacUeCb *ueCb) { - uint8_t ueIdx; + uint8_t tbIdx; + MacRaCbInfo *raCb = ueCb->raCb; - for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++) + if(raCb && (raCb->crnti == ueCb->crnti)) { - if(macCb.macCell[cellIdx]->macRaCb[ueIdx].crnti == ueCb->crnti) + MAC_FREE(raCb->msg4Pdu, raCb->msg4PduLen); + for(tbIdx = 0; tbIdx < raCb->msg4HqInfo.numTb; tbIdx++) { - if(macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4Pdu) - { - MAC_FREE(macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4Pdu, \ - macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4PduLen); - } - if(macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4TxPdu) - { - MAC_FREE(macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4TxPdu, \ - macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4TbSize); - } - memset(&macCb.macCell[cellIdx]->macRaCb[ueIdx], 0, sizeof(MacRaCbInfo)); - break; + MAC_FREE(raCb->msg4HqInfo.tbInfo[tbIdx].tb, \ + raCb->msg4HqInfo.tbInfo[tbIdx].tbSize - TX_PAYLOAD_HDR_LEN); } + memset(raCb, 0, sizeof(MacRaCbInfo)); } - } /******************************************************************* @@ -1956,11 +2531,12 @@ void deleteMacRaCb(uint16_t cellIdx, MacUeCb *ueCb) * RFAILED - failure * * ****************************************************************/ -uint8_t createUeCb(uint8_t cellIdx, MacUeCb *ueCb, MacUeCfg *ueCfg) +uint8_t createUeCb(uint8_t cellIdx, MacUeCb *ueCb, MacUeCreateReq *ueCfg) { - uint8_t ret =ROK; + uint8_t ret = ROK; + uint8_t hqProcIdx = 0; - if((ueCb->ueIdx == ueCfg->ueIdx) && (ueCb->crnti == ueCfg->crnti)\ + if((ueCb->ueId == ueCfg->ueId) && (ueCb->crnti == ueCfg->crnti)\ &&(ueCb->state == UE_STATE_ACTIVE)) { DU_LOG("\nERROR --> MAC : CRNTI %d already configured ", ueCfg->crnti); @@ -1977,13 +2553,27 @@ uint8_t createUeCb(uint8_t cellIdx, MacUeCb *ueCb, MacUeCfg *ueCfg) } else { - macCb.macCell[cellIdx]->numActvUe++; - updateMacRaCb(cellIdx, ueCb); - return ROK; - } + /* Initialize all DL HARQ PROC ID to MAX NUM OF HARQ PROC */ + for(hqProcIdx = 0; hqProcIdx < MAX_NUM_HARQ_PROC; hqProcIdx++) + { + ueCb->dlInfo.dlHarqEnt.harqProcCb[hqProcIdx].procId = MAX_NUM_HARQ_PROC; + } - } + /* If UE has not requested for RACH yet, it means UE context is created for a + * UE in handover */ + if(macCb.macCell[cellIdx]->macRaCb[ueCb->ueId-1].crnti == ueCb->crnti) + { + ueCb->state = UE_STATE_ACTIVE; + macCb.macCell[cellIdx]->numActvUe++; + updateMacRaCb(cellIdx, ueCb); + } + else + ueCb->state = UE_HANDIN_IN_PROGRESS; + return ROK; + } + } + return ROK; } /******************************************************************* @@ -2001,15 +2591,15 @@ uint8_t createUeCb(uint8_t cellIdx, MacUeCb *ueCb, MacUeCfg *ueCfg) * RFAILED - failure * * ****************************************************************/ -uint8_t modifyUeCb(uint8_t cellIdx, MacUeCb *ueCb, MacUeCfg *ueCfg) +uint8_t modifyUeCb(uint8_t cellIdx, MacUeCb *ueCb, MacUeRecfg *ueRecfg) { uint8_t ret = ROK; - if((ueCb->ueIdx == ueCfg->ueIdx) && (ueCb->crnti == ueCfg->crnti)\ - &&(ueCb->state == UE_STATE_ACTIVE)) + if((ueCb->ueId == ueRecfg->ueId) && (ueCb->crnti == ueRecfg->crnti)\ + &&(ueCb->state == UE_STATE_ACTIVE)) { - DU_LOG("\nINFO --> MAC : Modifying Ue config Req for CRNTI %d ", ueCfg->crnti); - ret = fillMacUeCb(ueCb, ueCfg, cellIdx); + DU_LOG("\nINFO --> MAC : Modifying Ue config Req for CRNTI %d ", ueRecfg->crnti); + ret = updateMacUeCb(ueCb, ueRecfg, cellIdx); if(ret != ROK) { DU_LOG("\nERROR --> MAC : Failed to modify MacUeCb at modifyUeCb()"); @@ -2017,8 +2607,7 @@ uint8_t modifyUeCb(uint8_t cellIdx, MacUeCb *ueCb, MacUeCfg *ueCfg) } else { - deleteMacRaCb(cellIdx, ueCb); - return ROK; + return ROK; } } return RFAILED; @@ -2041,19 +2630,30 @@ uint8_t modifyUeCb(uint8_t cellIdx, MacUeCb *ueCb, MacUeCfg *ueCfg) * * ****************************************************************/ -uint8_t procMacUeCfgData(Pst *pst, MacUeCfg *ueCfg) +uint8_t procMacUeCfgData(Pst *pst, MacUeCreateReq *ueCfg, MacUeRecfg *ueRecfg) { - uint8_t ret = ROK; - uint16_t cellIdx; + uint8_t ret = ROK, ueId = 0; + uint16_t cellIdx, cellId; MacUeCb *ueCb = NULLP; + if(ueCfg != NULLP) + { + cellId = ueCfg->cellId; + ueId = ueCfg->ueId; + } + else if(ueRecfg != NULLP) + { + cellId = ueRecfg->cellId; + ueId = ueRecfg->ueId; + } + - GET_CELL_IDX(ueCfg->cellId, cellIdx); + GET_CELL_IDX(cellId, cellIdx); /* Validate cell id */ - if(macCb.macCell[cellIdx]->cellId != ueCfg->cellId) + if(macCb.macCell[cellIdx]->cellId != cellId) { - DU_LOG("\nERROR --> MAC : Cell Id %d not configured", ueCfg->cellId); + DU_LOG("\nERROR --> MAC : Cell Id %d not configured", cellId); return RFAILED; } @@ -2065,21 +2665,28 @@ uint8_t procMacUeCfgData(Pst *pst, MacUeCfg *ueCfg) } /* Check if UE already configured */ - ueCb = &macCb.macCell[cellIdx]->ueCb[ueCfg->ueIdx -1]; + ueCb = &macCb.macCell[cellIdx]->ueCb[ueId -1]; + switch(pst->event) { case EVENT_UE_CONFIG_RSP_TO_MAC: - ret = createUeCb(cellIdx, ueCb, ueCfg); - if(ret != ROK) - DU_LOG("\nERROR --> MAC: AddUeConfigReq for cellIdx :%d failed in procMacUeCfgData()", cellIdx); - break; + { + ret = createUeCb(cellIdx, ueCb, ueCfg); + if(ret != ROK) + DU_LOG("\nERROR --> MAC: AddUeConfigReq for cellIdx :%d failed in procMacUeCfgData()", cellIdx); + break; + } + case EVENT_UE_RECONFIG_RSP_TO_MAC: - ret = modifyUeCb(cellIdx, ueCb, ueCfg); - if(ret != ROK) - DU_LOG("\nERROR --> MAC: ModifyUeConfigReq for cellIdx :%d failed at procMacUeCfgData()", cellIdx); - break; + { + ret = modifyUeCb(cellIdx, ueCb, ueRecfg); + if(ret != ROK) + DU_LOG("\nERROR --> MAC: ModifyUeConfigReq for cellIdx :%d failed at procMacUeCfgData()", cellIdx); + break; + } + default: - break; + break; } return ret; @@ -2095,26 +2702,44 @@ uint8_t procMacUeCfgData(Pst *pst, MacUeCfg *ueCfg) * * Functionality: Function to store the UeCfg Data * - * @params[in] MacUeCfg pointer + * @params[in] MacUeCreateReq pointer * @return ROK - success * RFAILED - failure * * ****************************************************************/ -uint8_t copyToTmpData(MacUeCfg *ueCfg) +uint8_t copyToTmpData(MacUeCreateReq *ueCfg, MacUeRecfg *ueRecfg) { uint8_t cellIdx; - MacUeCfg *tmpData = NULLP; - MAC_ALLOC(tmpData, sizeof(MacUeCfg)); - if(!tmpData) + if(ueCfg != NULLP) { - DU_LOG("\nERROR --> MAC: Memory Alloc Failed at copyToTmpData()"); - return RFAILED; + MacUeCreateReq *tmpData = NULLP; + + MAC_ALLOC(tmpData, sizeof(MacUeCreateReq)); + if(!tmpData) + { + DU_LOG("\nERROR --> MAC: Memory Alloc Failed at copyToTmpData()"); + return RFAILED; + } + memcpy(tmpData, ueCfg, sizeof(MacUeCreateReq)); + GET_CELL_IDX(ueCfg->cellId, cellIdx); + macCb.macCell[cellIdx]->ueCfgTmpData[ueCfg->ueId-1] = tmpData; + } + else if(ueRecfg != NULLP) + { + MacUeRecfg *tmpData = NULLP; + + MAC_ALLOC(tmpData, sizeof(MacUeRecfg)); + if(!tmpData) + { + DU_LOG("\nERROR --> MAC: Memory Alloc Failed at copyToTmpData()"); + return RFAILED; + } + memcpy(tmpData, ueRecfg, sizeof(MacUeRecfg)); + GET_CELL_IDX(ueRecfg->cellId, cellIdx); + macCb.macCell[cellIdx]->ueRecfgTmpData[ueRecfg->ueId-1] = tmpData; } - memcpy(tmpData, ueCfg, sizeof(MacUeCfg)); - GET_CELL_IDX(ueCfg->cellId, cellIdx); - macCb.macCell[cellIdx]->ueCfgTmpData[ueCfg->ueIdx-1] = tmpData; return ROK; } @@ -2133,35 +2758,42 @@ uint8_t copyToTmpData(MacUeCfg *ueCfg) * RFAILED - failure * * ****************************************************************/ -uint8_t MacProcUeCreateReq(Pst *pst, MacUeCfg *ueCfg) +uint8_t MacProcUeCreateReq(Pst *pst, MacUeCreateReq *ueCfg) { uint8_t ret = ROK; - SchUeCfg schUeCfg; - memset(&schUeCfg, 0, sizeof(SchUeCfg)); + SchUeCfgReq schUeCfg; + memset(&schUeCfg, 0, sizeof(SchUeCfgReq)); DU_LOG("\nINFO --> MAC : UE Create Request for CRNTI[%d]", ueCfg->crnti); if(ueCfg) { + /* If CRNTI = 0, MAC must allot a CRNTI to this UE. This scenario hits in + * case of UE in handover */ + if(ueCfg->crnti == 0) + { + GET_CRNTI(ueCfg->crnti, ueCfg->ueId); + } + /*Storing received ueCfg in ueCfgTmpData */ - ret = copyToTmpData(ueCfg); + ret = copyToTmpData(ueCfg, NULLP); if(ret == ROK) { /*Sending Cfg Req to SCH */ - ret = fillSchUeCfg(pst, &schUeCfg, ueCfg); - if(ret != ROK) - DU_LOG("\nERROR --> MAC : Failed to fill Sch Ue Cfg at MacProcUeCreateReq()"); - else - { + ret = fillSchUeCfg(&schUeCfg, ueCfg); + if(ret != ROK) + DU_LOG("\nERROR --> MAC : Failed to fill Sch Ue Cfg at MacProcUeCreateReq()"); + else + { /* Fill event and send UE create request to SCH */ ret = sendUeReqToSch(pst, &schUeCfg); - if(ret != ROK) - DU_LOG("\nERROR --> MAC : Failed to send UE Create request to SCH"); - } + if(ret != ROK) + DU_LOG("\nERROR --> MAC : Failed to send UE Create request to SCH"); + } } else { - DU_LOG("\nERROR --> MAC : Failed to store MAC UE CFG "); + DU_LOG("\nERROR --> MAC : Failed to store MAC UE CFG "); } } else @@ -2170,7 +2802,7 @@ uint8_t MacProcUeCreateReq(Pst *pst, MacUeCfg *ueCfg) ret = RFAILED; } /* FREE shared memory */ - MAC_FREE_SHRABL_BUF(pst->region, pst->pool, ueCfg, sizeof(MacUeCfg)); + MAC_FREE_SHRABL_BUF(pst->region, pst->pool, ueCfg, sizeof(MacUeCreateReq)); return ret; } @@ -2193,10 +2825,10 @@ uint8_t MacProcUeCreateReq(Pst *pst, MacUeCfg *ueCfg) * ****************************************************************/ uint8_t MacSendUeCreateRsp(MacRsp result, SchUeCfgRsp *schCfgRsp) { - MacUeCfgRsp *cfgRsp; + MacUeCreateRsp *cfgRsp; Pst rspPst; - MAC_ALLOC_SHRABL_BUF(cfgRsp, sizeof(MacUeCfgRsp)); + MAC_ALLOC_SHRABL_BUF(cfgRsp, sizeof(MacUeCreateRsp)); if(!cfgRsp) { DU_LOG("\nERROR --> MAC: Memory allocation for UE config response failed"); @@ -2204,15 +2836,15 @@ uint8_t MacSendUeCreateRsp(MacRsp result, SchUeCfgRsp *schCfgRsp) } /* Filling UE Config response */ - memset(cfgRsp, 0, sizeof(MacUeCfgRsp)); + memset(cfgRsp, 0, sizeof(MacUeCreateRsp)); cfgRsp->cellId = schCfgRsp->cellId; - cfgRsp->ueIdx = schCfgRsp->ueIdx; + cfgRsp->ueId = schCfgRsp->ueId; cfgRsp->result = result; /* Fill Post structure and send UE Create response*/ memset(&rspPst, 0, sizeof(Pst)); FILL_PST_MAC_TO_DUAPP(rspPst, EVENT_MAC_UE_CREATE_RSP); - return (*macDuUeCfgRspOpts[rspPst.selector])(&rspPst, cfgRsp); + return (*macDuUeCreateRspOpts[rspPst.selector])(&rspPst, cfgRsp); } /******************************************************************* @@ -2231,28 +2863,28 @@ uint8_t MacSendUeCreateRsp(MacRsp result, SchUeCfgRsp *schCfgRsp) * RFAILED - failure * * ****************************************************************/ -uint8_t MacSendUeReconfigRsp(MacRsp result, SchUeCfgRsp *schCfgRsp) +uint8_t MacSendUeReconfigRsp(MacRsp result, SchUeRecfgRsp *schCfgRsp) { - MacUeCfgRsp *cfgRsp; + MacUeRecfgRsp *recfgRsp; Pst rspPst; - MAC_ALLOC_SHRABL_BUF(cfgRsp, sizeof(MacUeCfgRsp)); - if(!cfgRsp) + MAC_ALLOC_SHRABL_BUF(recfgRsp, sizeof(MacUeRecfgRsp)); + if(!recfgRsp) { DU_LOG("\nERROR --> MAC: Memory allocation for UE Reconfig response failed"); return RFAILED; } /* Filling UE Config response */ - memset(cfgRsp, 0, sizeof(MacUeCfgRsp)); - cfgRsp->cellId = schCfgRsp->cellId; - cfgRsp->ueIdx = schCfgRsp->ueIdx; - cfgRsp->result = result; + memset(recfgRsp, 0, sizeof(MacUeRecfgRsp)); + recfgRsp->cellId = schCfgRsp->cellId; + recfgRsp->ueId = schCfgRsp->ueId; + recfgRsp->result = result; /* Fill Post structure and send UE Create response*/ memset(&rspPst, 0, sizeof(Pst)); FILL_PST_MAC_TO_DUAPP(rspPst, EVENT_MAC_UE_RECONFIG_RSP); - return (*macDuUeCfgRspOpts[rspPst.selector])(&rspPst, cfgRsp); + return (*macDuUeRecfgRspOpts[rspPst.selector])(&rspPst, recfgRsp); } /******************************************************************* @@ -2266,19 +2898,19 @@ uint8_t MacSendUeReconfigRsp(MacRsp result, SchUeCfgRsp *schCfgRsp) * Functionality: * Function to return Mac Ue Cfg pointer * - * @params[in] cellIdx, ueIdx + * @params[in] cellIdx, ueId * - * @return MacUeCfg pointer - success + * @return MacUeCreateReq pointer - success * NULLP - failure * * ****************************************************************/ -MacUeCfg *getMacUeCfg(uint16_t cellIdx, uint8_t ueIdx) +MacUeCreateReq *getMacUeCfg(uint16_t cellIdx, uint8_t ueId) { - MacUeCfg *ueCfg = NULLP; + MacUeCreateReq *ueCfg = NULLP; if(macCb.macCell[cellIdx]) { - ueCfg = macCb.macCell[cellIdx]->ueCfgTmpData[ueIdx-1]; + ueCfg = macCb.macCell[cellIdx]->ueCfgTmpData[ueId-1]; } else { @@ -2289,89 +2921,173 @@ MacUeCfg *getMacUeCfg(uint16_t cellIdx, uint8_t ueIdx) /******************************************************************* * - * @brief Processes UE create response from scheduler + * @brief Function to return Mac Ue Recfg pointer * * @details * - * Function : MacProcSchUeCfgRsp + * Function : getMacUeRecfg * * Functionality: - * Processes UE create response from scheduler - * Sends UE create response to DU APP + * Function to return Mac Ue Recfg pointer * - * @params[in] Pst : Post structure - * schCfgRsp : Scheduler UE cfg response - * @return ROK - success - * RFAILED - failure + * @params[in] cellIdx, ueId + * + * @return MacUeRecfg pointer - success + * NULLP - failure * * ****************************************************************/ -uint8_t MacProcSchUeCfgRsp(Pst *pst, SchUeCfgRsp *schCfgRsp) -{ - uint8_t result = MAC_DU_APP_RSP_NOK; - uint8_t ret = ROK; - uint16_t cellIdx; - MacUeCfg *ueCfg = NULLP; - GET_CELL_IDX(schCfgRsp->cellId, cellIdx); - ueCfg = getMacUeCfg(cellIdx, schCfgRsp->ueIdx); - if(ueCfg == NULLP) +MacUeRecfg *getMacUeRecfg(uint16_t cellIdx, uint8_t ueId) +{ + MacUeRecfg *ueRecfg = NULLP; + if(macCb.macCell[cellIdx]) { - DU_LOG("\nERROR --> MAC : Failed to find the Mac Ue Cfg for event [%d] in MacProcSchUeCfgRsp()", pst->event); - ret = RFAILED; + ueRecfg = macCb.macCell[cellIdx]->ueRecfgTmpData[ueId-1]; + } + else + { + DU_LOG("\nERROR --> MAC: Failed to get macCellCb in getMacUeRecfg()"); } + return ueRecfg; +} +/******************************************************************* + * + * @brief Processes UE create response from scheduler + * + * @details + * + * Function : MacProcSchUeCfgRsp + * + * Functionality: + * Processes UE create response from scheduler + * Sends UE create response to DU APP + * + * @params[in] Pst : Post structure + * schCfgRsp : Scheduler UE cfg response + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t MacProcSchUeCfgRsp(Pst *pst, SchUeCfgRsp *schCfgRsp) +{ + uint8_t result = MAC_DU_APP_RSP_NOK; + uint8_t ret = ROK; + uint16_t cellIdx; + MacUeCreateReq *ueCfg = NULLP; + +#ifdef CALL_FLOW_DEBUG_LOG switch(pst->event) { case EVENT_UE_CONFIG_RSP_TO_MAC: + DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_UE_CONFIG_RSP_TO_MAC\n"); + break; + case EVENT_UE_RECONFIG_RSP_TO_MAC: + DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_UE_RECONFIG_RSP_TO_MAC\n"); + break; + default: + DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : Invalid Event\n"); + break; + } +#endif + + GET_CELL_IDX(schCfgRsp->cellId, cellIdx); + ueCfg = getMacUeCfg(cellIdx, schCfgRsp->ueId); + if(ueCfg == NULLP) + { + DU_LOG("\nERROR --> MAC : Failed to find the Mac Ue Cfg for event [%d] in MacProcSchUeCfgRsp()", pst->event); + ret = RFAILED; + } + + if(schCfgRsp->rsp != RSP_NOK) + { + DU_LOG("\nINFO --> MAC: SCH UeConfigRsp for CRNTI[%d] is success in MacProcSchUeCfgRsp()", schCfgRsp->crnti); + if(ret == ROK) { - if(schCfgRsp->rsp != RSP_NOK) - { - DU_LOG("\nINFO --> MAC: SCH UeConfigRsp for CRNTI[%d] is success in MacProcSchUeCfgRsp()", schCfgRsp->crnti); - if(ret == ROK) - { - ret = procMacUeCfgData(pst, ueCfg); - if(ret == ROK) - { - result = MAC_DU_APP_RSP_OK; - } - } - } - else - { - DU_LOG("\nERROR --> MAC: SCH UeConfigRsp for CRNTI[%d] is failed in MacProcSchUeCfgRsp()", schCfgRsp->crnti); - } - ret = MacSendUeCreateRsp(result, schCfgRsp); + ret = procMacUeCfgData(pst, ueCfg, NULLP); + if(ret == ROK) + { + result = MAC_DU_APP_RSP_OK; + } } - break; + } + else + { + DU_LOG("\nERROR --> MAC: SCH UeConfigRsp for CRNTI[%d] is failed in MacProcSchUeCfgRsp()", schCfgRsp->crnti); + } + ret = MacSendUeCreateRsp(result, schCfgRsp); + MAC_FREE(ueCfg, sizeof(MacUeCreateReq)); + ueCfg = NULLP; + return ret; +} +/******************************************************************* + * + * @brief Processes UE create response from scheduler + * + * @details + * + * Function : MacProcSchUeRecfgRsp + * + * Functionality: + * Processes UE ReConfig response from scheduler + * Sends UE Reconfig response to DU APP + * + * @params[in] Pst : Post structure + * schRecfgRsp : Scheduler UE Recfg response + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t MacProcSchUeRecfgRsp(Pst *pst, SchUeRecfgRsp *schRecfgRsp) +{ + uint8_t result = MAC_DU_APP_RSP_NOK; + uint8_t ret = ROK; + uint16_t cellIdx; + MacUeRecfg *ueRecfg = NULLP; + +#ifdef CALL_FLOW_DEBUG_LOG + switch(pst->event) + { case EVENT_UE_RECONFIG_RSP_TO_MAC: + DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_UE_RECONFIG_RSP_TO_MAC\n"); + break; + default: + DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : Invalid Event\n"); + break; + } +#endif + + GET_CELL_IDX(schRecfgRsp->cellId, cellIdx); + ueRecfg = getMacUeRecfg(cellIdx, schRecfgRsp->ueId); + if(ueRecfg == NULLP) + { + DU_LOG("\nERROR --> MAC : Failed to find the Mac Ue Cfg for event [%d] in MacProcSchUeCfgRsp()", pst->event); + ret = RFAILED; + } + + + if(schRecfgRsp->rsp != RSP_NOK) + { + DU_LOG("\nINFO --> MAC: SCH UeReconfigRsp for CRNTI[%d] is success in MacProcSchUeCfgRsp()",\ + schRecfgRsp->crnti); + if(ret == ROK) { - if(schCfgRsp->rsp != RSP_NOK) - { - DU_LOG("\nINFO --> MAC: SCH UeReconfigRsp for CRNTI[%d] is success in MacProcSchUeCfgRsp()", schCfgRsp->crnti); - if(ret == ROK) - { - ret = procMacUeCfgData(pst, ueCfg); - if(ret == ROK) - { - result = MAC_DU_APP_RSP_OK; - } - } - } - else - { - DU_LOG("\nERROR --> MAC: SCH UeReconfigRsp for CRNTI[%d] is failed in MacProcSchUeCfgRsp()", schCfgRsp->crnti); - } - ret = MacSendUeReconfigRsp(result, schCfgRsp); + ret = procMacUeCfgData(pst, NULLP, ueRecfg); + if(ret == ROK) + { + result = MAC_DU_APP_RSP_OK; + } } - break; - - default: - break; } - MAC_FREE(ueCfg, sizeof(MacUeCfg)); - ueCfg = NULLP; - + else + { + DU_LOG("\nERROR --> MAC: SCH UeReconfigRsp for CRNTI[%d] is failed in MacProcSchUeCfgRsp()",\ + schRecfgRsp->crnti); + } + ret = MacSendUeReconfigRsp(result, schRecfgRsp); + MAC_FREE(ueRecfg, sizeof(MacUeRecfg)); + ueRecfg = NULLP; return ret; } @@ -2390,28 +3106,28 @@ uint8_t MacProcSchUeCfgRsp(Pst *pst, SchUeCfgRsp *schCfgRsp) * RFAILED - failure * * ****************************************************************/ -uint8_t MacProcUeReconfigReq(Pst *pst, MacUeCfg *ueCfg) +uint8_t MacProcUeReconfigReq(Pst *pst, MacUeRecfg *ueRecfg) { uint8_t ret = ROK; - SchUeCfg schUeCfg; - memset(&schUeCfg, 0, sizeof(SchUeCfg)); + SchUeRecfgReq schUeRecfg; + memset(&schUeRecfg, 0, sizeof(SchUeRecfgReq)); - DU_LOG("\nINFO --> MAC : UE Reconfig Request for CRNTI[%d]", ueCfg->crnti); + DU_LOG("\nINFO --> MAC : UE Reconfig Request for CRNTI[%d]", ueRecfg->crnti); - if(ueCfg) + if(ueRecfg) { - /*Storing received ueCfg in ueCfgTmpData */ - ret = copyToTmpData(ueCfg); + /*Storing received ueRecfg in ueCfgTmpData */ + ret = copyToTmpData(NULLP, ueRecfg); if(ret == ROK) { /*Sending Cfg Req to SCH */ - ret = fillSchUeCfg(pst, &schUeCfg, ueCfg); + ret = fillSchUeRecfg(&schUeRecfg, ueRecfg); if(ret != ROK) DU_LOG("\nERROR --> MAC : Failed to fill sch Ue Cfg at MacProcUeReconfigReq()"); else { - /* Fill event and send UE create request to SCH */ - ret = sendUeReqToSch(pst, &schUeCfg); + /* Fill event and send UE Reconfiguration request to SCH */ + ret = sendUeReqToSch(pst, &schUeRecfg); if(ret != ROK) DU_LOG("\nERROR --> MAC : Failed to send UE Reconfig Request to SCH"); } @@ -2423,11 +3139,11 @@ uint8_t MacProcUeReconfigReq(Pst *pst, MacUeCfg *ueCfg) } else { - DU_LOG("\nERROR --> MAC : MAC UE Create request processing failed"); + DU_LOG("\nERROR --> MAC : MAC UE Reconfiguration request processing failed"); ret = RFAILED; } /* FREE shared memory */ - MAC_FREE_SHRABL_BUF(pst->region, pst->pool, ueCfg, sizeof(MacUeCfg)); + MAC_FREE_SHRABL_BUF(pst->region, pst->pool, ueRecfg, sizeof(MacUeRecfg)); return ROK; } @@ -2448,7 +3164,7 @@ uint8_t MacProcUeReconfigReq(Pst *pst, MacUeCfg *ueCfg) * * ****************************************************************/ -uint8_t MacSendUeDeleteRsp(uint16_t cellId, uint16_t crnti, UeDeleteStatus result) +uint8_t MacSendUeDeleteRsp(uint16_t cellId, uint16_t crnti, CauseOfResult status) { MacUeDeleteRsp *deleteRsp; Pst rspPst; @@ -2462,8 +3178,8 @@ uint8_t MacSendUeDeleteRsp(uint16_t cellId, uint16_t crnti, UeDeleteStatus resul /* Filling UE delete response */ deleteRsp->cellId = cellId; - GET_UE_IDX(crnti,deleteRsp->ueIdx); - deleteRsp->result = result; + GET_UE_ID(crnti, deleteRsp->ueId); + deleteRsp->status = status; /* Fill Post structure and send UE delete response*/ memset(&rspPst, 0, sizeof(Pst)); @@ -2524,106 +3240,16 @@ void deletePucchResourcesCfg(PucchResrcCfg *resrcCfg) } -/******************************************************************* -* -* @brief Function to delete MAC Pdsch ServCellCfg -* -* @details -* -* Function : deleteMacPdschServCellCfg -* -* Functionality: Function to delete MAC Pdsch ServCellCfg -* -* @params[in] PdschServCellCfg *pdschServCellCfg -* @return void -* -* ****************************************************************/ - -void deleteMacPdschServCellCfg(PdschServCellCfg *pdschServCellCfg) -{ - MAC_FREE(pdschServCellCfg->maxMimoLayers, sizeof(uint8_t)); - MAC_FREE(pdschServCellCfg->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB)); - MAC_FREE(pdschServCellCfg->codeBlkGrpFlushInd, sizeof(bool)); - MAC_FREE(pdschServCellCfg->xOverhead, sizeof(PdschXOverhead)); -} - -/******************************************************************* -* -* @brief Handles UE Delete requst from DU APP -* -* @details -* -* Function : deleteMacUeCb -* -* Functionality: Handles UE Delete requst from DU APP -* -* @params[in] MacCellCb *cellCb,uint16_t ueIdx -* @return ROK - success -* RFAILED - failure -* -* ****************************************************************/ - -void deleteMacUeCb(MacUeCb *ueCb) -{ - MacUeCfg *ueCfg = NULLP; - ServCellCfgInfo *servCellCfg; - - if(ueCb->cellCb) - { - MAC_FREE(ueCb->cellCb->macRaCb[ueCb->ueIdx-1].msg4Pdu, ueCb->cellCb->macRaCb[ueCb->ueIdx-1].msg4PduLen); - MAC_FREE(ueCb->cellCb->macRaCb[ueCb->ueIdx-1].msg4TxPdu, ueCb->cellCb->macRaCb[ueCb->ueIdx-1].msg4TbSize); - - if(ueCb->cellCb->ueCfgTmpData[ueCb->ueIdx-1]) - { - ueCfg =ueCb->cellCb->ueCfgTmpData[ueCb->ueIdx-1]; - MAC_FREE(ueCfg->ambrCfg, sizeof(AmbrCfg)); - if(ueCfg->spCellCfgPres) - { - servCellCfg = &ueCfg->spCellCfg.servCellCfg; - MAC_FREE(servCellCfg->bwpInactivityTmr, sizeof(uint8_t)); - - if(servCellCfg->initUlBwp.pucchPresent) - { - MAC_FREE(servCellCfg->initUlBwp.pucchCfg.resrcSet, sizeof(PucchResrcSetCfg)); - - if(servCellCfg->initUlBwp.pucchCfg.resrc) - { - deletePucchResourcesCfg(servCellCfg->initUlBwp.pucchCfg.resrc); - MAC_FREE(servCellCfg->initUlBwp.pucchCfg.resrc, sizeof(PucchResrcCfg)); - } - MAC_FREE(servCellCfg->initUlBwp.pucchCfg.format1, sizeof(PucchFormatCfg)); - MAC_FREE(servCellCfg->initUlBwp.pucchCfg.format2, sizeof(PucchFormatCfg)); - MAC_FREE(servCellCfg->initUlBwp.pucchCfg.format3, sizeof(PucchFormatCfg)); - MAC_FREE(servCellCfg->initUlBwp.pucchCfg.format4, sizeof(PucchFormatCfg)); - MAC_FREE(servCellCfg->initUlBwp.pucchCfg.schedReq, sizeof(PucchSchedReqCfg)); - MAC_FREE(servCellCfg->initUlBwp.pucchCfg.multiCsiCfg, sizeof(PucchMultiCsiCfg)); - MAC_FREE(servCellCfg->initUlBwp.pucchCfg.spatialInfo, sizeof(PucchSpatialCfg)); - MAC_FREE(servCellCfg->initUlBwp.pucchCfg.dlDataToUlAck , sizeof(PucchDlDataToUlAck)); - MAC_FREE(servCellCfg->initUlBwp.pucchCfg.powerControl, sizeof(PucchPowerControl)); - deleteMacPdschServCellCfg(&servCellCfg->pdschServCellCfg); - } - } - for(uint8_t idx=0 ;idx < ueCfg->numLcs; idx++) - { - MAC_FREE(ueCfg->lcCfgList[idx].drbQos, sizeof(DrbQosInfo)); - MAC_FREE(ueCfg->lcCfgList[idx].snssai, sizeof(Snssai)); - } - MAC_FREE(ueCb->cellCb->ueCfgTmpData[ueCb->ueIdx-1],sizeof(MacUeCfg)); - } - } - memset(ueCb, 0, sizeof(MacUeCb)); -} - /******************************************************************* * * @brief Processes UE delete response from scheduler * * @details * -* Function : MacProcSchUeCfgRsp +* Function : MacProcSchUeDeleteRsp * * Functionality: -* Processes UE create delete from scheduler +* Processes UE delete from scheduler * * @params[in] Pst : Post structure * schUeDelRsp : Scheduler UE delete respons @@ -2634,11 +3260,16 @@ void deleteMacUeCb(MacUeCb *ueCb) uint8_t MacProcSchUeDeleteRsp(Pst *pst, SchUeDeleteRsp *schUeDelRsp) { - uint8_t ueIdx =0; + uint8_t ueId =0, isCrntiValid = 0, tbIdx =0, idx=0; uint16_t cellIdx=0; uint8_t ret = RFAILED; - UeDeleteStatus result; - + CauseOfResult status; + DlHarqEnt *dlHarqEnt; + +#ifdef CALL_FLOW_DEBUG_LOG + DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_UE_DELETE_RSP_TO_MAC\n"); +#endif + if(schUeDelRsp) { if(schUeDelRsp->rsp == RSP_OK) @@ -2647,33 +3278,68 @@ uint8_t MacProcSchUeDeleteRsp(Pst *pst, SchUeDeleteRsp *schUeDelRsp) GET_CELL_IDX(schUeDelRsp->cellId, cellIdx); if(macCb.macCell[cellIdx]) { - GET_UE_IDX(schUeDelRsp->crnti, ueIdx); - if(macCb.macCell[cellIdx]->ueCb[ueIdx -1].crnti == schUeDelRsp->crnti) + CHECK_CRNTI(schUeDelRsp->crnti, isCrntiValid); + if(!isCrntiValid) { - deleteMacUeCb(&macCb.macCell[cellIdx]->ueCb[ueIdx -1]); - macCb.macCell[cellIdx]->numActvUe--; - result = SUCCESS; - ret = ROK; + /*C-RNTI value is out of Acceptable range*/ + DU_LOG("\nERROR --> MAC : MacProcSchUeDeleteRsp(): Invalid crnti[%d] ",schUeDelRsp->crnti); + status = UEID_INVALID; } else { - DU_LOG("\nERROR --> MAC : MacProcSchUeDeleteRsp(): crnti[%d] does not exist ",schUeDelRsp->crnti); - result = UEIDX_INVALID; + GET_UE_ID(schUeDelRsp->crnti, ueId); + if(macCb.macCell[cellIdx]->ueCb[ueId -1].crnti == schUeDelRsp->crnti) + { + + /*Commenting as S-NSSAI and PDU session will be stored in MAC DB in future scope*/ +#if 0 + /*Looping around LCs to free S-NSSAI memory*/ + for(lcIdx = 0; lcIdx < (macCb.macCell[cellIdx]->ueCb[ueId -1].ulInfo.numUlLc); lcIdx++) + { + MAC_FREE(macCb.macCell[cellIdx]->ueCb[ueId -1].ulInfo.lcCb[lcIdx].snssai, sizeof(Snssai)); + } + for(lcIdx = 0; lcIdx < (macCb.macCell[cellIdx]->ueCb[ueId -1].dlInfo.numDlLc); lcIdx++) + { + MAC_FREE(macCb.macCell[cellIdx]->ueCb[ueId -1].dlInfo.lcCb[lcIdx].snssai, sizeof(Snssai)); + } +#endif + dlHarqEnt = &macCb.macCell[cellIdx]->ueCb[ueId -1].dlInfo.dlHarqEnt; + for(idx =0 ; idxharqProcCb[idx].numTb) + { + + MAC_FREE(dlHarqEnt->harqProcCb[idx].tbInfo[tbIdx].tb, dlHarqEnt->harqProcCb[idx].tbInfo[tbIdx].tbSize); + dlHarqEnt->harqProcCb[idx].numTb--; + tbIdx++; + } + } + memset(&macCb.macCell[cellIdx]->ueCb[ueId -1], 0, sizeof(MacUeCb)); + macCb.macCell[cellIdx]->numActvUe--; + status = SUCCESSFUL; + ret = ROK; + } + else + { + DU_LOG("\nERROR --> MAC : MacProcSchUeDeleteRsp(): crnti[%d] does not exist ",schUeDelRsp->crnti); + status = UEID_INVALID; + } } } else { DU_LOG("\nERROR --> MAC : MacProcSchUeDeleteRsp(): cellId[%d] does not exist ",schUeDelRsp->cellId); - result = CELLID_INVALID; + status = CELLID_INVALID; } } else - { - result = (schUeDelRsp->cause == INVALID_CELLID) ? CELLID_INVALID : UEIDX_INVALID; - } - if(MacSendUeDeleteRsp(schUeDelRsp->cellId, schUeDelRsp->crnti, result) != ROK) + status = schUeDelRsp->cause; + + if(MacSendUeDeleteRsp(schUeDelRsp->cellId, schUeDelRsp->crnti, status) != ROK) { DU_LOG("\nERROR --> MAC: MacProcSchUeDeleteRsp(): Failed to send UE delete response"); + ret = RFAILED; } } else @@ -2712,7 +3378,7 @@ uint8_t sendUeDelReqToSch(Pst *pst, MacUeDelete *ueDelete) schUeDel.crnti = ueDelete->crnti; MAC_FREE_SHRABL_BUF(pst->region, pst->pool, ueDelete, sizeof(MacUeDelete)); FILL_PST_MAC_TO_SCH(schPst, EVENT_UE_DELETE_REQ_TO_SCH); - return(*macSchUeDeleteReqOpts[schPst.selector])(&schPst, &schUeDel); + return(SchMessageRouter(&schPst, (void *)&schUeDel)); } else { @@ -2742,11 +3408,11 @@ uint8_t MacProcUeDeleteReq(Pst *pst, MacUeDelete *ueDelete) { uint8_t ret = ROK; uint8_t cellIdx=0; - UeDeleteStatus result=SUCCESS; + CauseOfResult status =SUCCESSFUL; MacUeCb *ueCb = NULLP; MacCellCb *cellCb = NULLP; - DU_LOG("\nINFO --> MAC : UE Delete Request received for ueIdx[%d]", ueDelete->ueIdx); + DU_LOG("\nINFO --> MAC : UE Delete Request received for ueId[%d]", ueDelete->ueId); if(ueDelete) { @@ -2754,7 +3420,7 @@ uint8_t MacProcUeDeleteReq(Pst *pst, MacUeDelete *ueDelete) cellCb = macCb.macCell[cellIdx]; if(cellCb) { - ueCb = &cellCb->ueCb[ueDelete->ueIdx-1]; + ueCb = &cellCb->ueCb[ueDelete->ueId-1]; if(ueCb->crnti == ueDelete->crnti) { ret = sendUeDelReqToSch(pst, ueDelete); @@ -2767,18 +3433,18 @@ uint8_t MacProcUeDeleteReq(Pst *pst, MacUeDelete *ueDelete) else { DU_LOG("\nERROR --> MAC : MacProcUeDeleteReq(): CRNTI is not matched"); - result = UEIDX_INVALID; + status = UEID_INVALID; } } else { - DU_LOG("\nERROR --> MAC : MacProcUeDeleteReq(): Failed to find the MacUeCb of UeIdx = %d",ueDelete->ueIdx); - result = CELLID_INVALID; + DU_LOG("\nERROR --> MAC : MacProcUeDeleteReq(): Failed to find the MacUeCb of UeId = %d",ueDelete->ueId); + status = CELLID_INVALID; } - if(result != SUCCESS) + if(status!= SUCCESSFUL) { - MacSendUeDeleteRsp(ueDelete->cellId, ueDelete->crnti, result); + MacSendUeDeleteRsp(ueDelete->cellId, ueDelete->crnti, status); MAC_FREE_SHRABL_BUF(pst->region, pst->pool, ueDelete, sizeof(MacUeDelete)); ret = RFAILED; } @@ -2792,251 +3458,103 @@ uint8_t MacProcUeDeleteReq(Pst *pst, MacUeDelete *ueDelete) } /******************************************************************* - * - * @brief Fill and Send Cell Delete response from MAC to DU APP - * - * @details - * - * Function : MacSendCellDeleteRsp - * - * Functionality: Fill and Send Cell Delete response from MAC to DUAPP - * - * @params[in] MAC Cell delete result - * SCH Cell delete response - * @return ROK - success - * RFAILED - failure - * - * ****************************************************************/ -uint8_t MacSendCellDeleteRsp(CellDeleteStatus result, uint8_t cellId) +* +* @brief Fill and Send UE Reset response from MAC to DU APP +* +* @details +* +* Function : MacSendUeResetRsp +* +* Functionality: Fill and Send UE Reset response from MAC to DUAPP +* +* @params[in] MAC UE Reset result +* SCH UE Reset response +* @return ROK - success +* RFAILED - failure +* +* ****************************************************************/ + +uint8_t MacSendUeResetRsp(uint16_t cellId, uint16_t ueId, CauseOfResult status) { - MacCellDeleteRsp *deleteRsp=NULLP; + MacUeResetRsp *ResetRsp; Pst rspPst; - MAC_ALLOC_SHRABL_BUF(deleteRsp, sizeof(MacCellDeleteRsp)); - if(!deleteRsp) + MAC_ALLOC_SHRABL_BUF(ResetRsp, sizeof(MacUeResetRsp)); + if(!ResetRsp) { - DU_LOG("\nERROR --> MAC : MacSendCellDeleteRsp(): Memory allocation for Cell delete response failed"); + DU_LOG("\nERROR --> MAC : Memory allocation for UE Reset response failed"); return RFAILED; } - /* Filling CELL delete response */ - deleteRsp->cellId = cellId; - deleteRsp->result = result; + /* Filling UE Reset response */ + ResetRsp->cellId = cellId; + ResetRsp->ueId = ueId; + ResetRsp->status = status; - /* Fill Post structure and send CELL delete response*/ + /* Fill Post structure and send UE Reset response*/ memset(&rspPst, 0, sizeof(Pst)); - FILL_PST_MAC_TO_DUAPP(rspPst, EVENT_MAC_CELL_DELETE_RSP); - return (*macDuCellDeleteRspOpts[rspPst.selector])(&rspPst, deleteRsp); -} - -/******************************************************************* - * - * @brief delete MAC CellCb information - * - * @details - * - * Function : deleteMacCellCb - * - * Functionality: - * delete MAC CellCb information - * - * @params[in] MacCellCb * cellCb - * - * @return ROK - success - * RFAILED - failure - * - * ****************************************************************/ -void deleteMacCellCb(MacCellCb * cellCb) -{ - uint8_t idx; - for(idx=0; idxdlSlot[idx].dlInfo.rarAlloc, sizeof(RarAlloc)); - if(cellCb->dlSlot[idx].dlInfo.ulGrant) - { - MAC_FREE(cellCb->dlSlot[idx].dlInfo.ulGrant->dciInfo.pdschCfg, sizeof(PdschCfg)); - MAC_FREE(cellCb->dlSlot[idx].dlInfo.ulGrant, sizeof(DciInfo)); - } - if(cellCb->dlSlot[idx].dlInfo.dlMsgAlloc) - { - MAC_FREE(cellCb->dlSlot[idx].dlInfo.dlMsgAlloc->dlMsgInfo.dlMsgPdu,\ - cellCb->dlSlot[idx].dlInfo.dlMsgAlloc->dlMsgInfo.dlMsgPduLen); - MAC_FREE(cellCb->dlSlot[idx].dlInfo.dlMsgAlloc, sizeof(DlMsgAlloc)); - } - } - - memset(cellCb, 0, sizeof(MacCellCb)); -} - -/******************************************************************* - * - * @brief Processes CELL delete response from scheduler - * - * @details - * - * Function : MacProcSchCellDeleteRsp - * - * Functionality: - * Processes CELL delete from scheduler - * - * @params[in] Pst : Post structure - * schCellDelRsp : Scheduler CELL delete respons - * @return ROK - success - * RFAILED - failure - * - * * ****************************************************************/ -uint8_t MacProcSchCellDeleteRsp(Pst *pst, SchCellDeleteRsp *schCellDelRsp) -{ - uint8_t ret = ROK; - uint16_t cellIdx=0; - CellDeleteStatus status; - - if(schCellDelRsp) - { - if(schCellDelRsp->rsp == RSP_OK) - { - DU_LOG("\nINFO --> MAC : SCH CELL Delete response for cellId[%d] is successful ", \ - schCellDelRsp->cellId); - GET_CELL_IDX(schCellDelRsp->cellId, cellIdx); - if(macCb.macCell[cellIdx]) - { - if(macCb.macCell[cellIdx]->cellId == schCellDelRsp->cellId) - { - deleteMacCellCb(macCb.macCell[cellIdx]); - status = SUCCESSFUL_RSP; - MAC_FREE(macCb.macCell[cellIdx], sizeof(MacCellCb)); - } - else - { - DU_LOG("ERROR --> MAC : MacProcSchCellDeleteRsp(): CellId[%d] does not exists", schCellDelRsp->cellId); - status = CELL_ID_INVALID; - ret = RFAILED; - } - } - else - { - DU_LOG("ERROR --> MAC : MacProcSchCellDeleteRsp(): CellId[%d] does not exists", schCellDelRsp->cellId); - status = CELL_ID_INVALID; - ret = RFAILED; - } - } - else - { - DU_LOG("ERROR --> MAC : MacProcSchCellDeleteRsp(): CellId[%d] does not exists", schCellDelRsp->cellId); - status = CELL_ID_INVALID; - ret = RFAILED; - } - if(MacSendCellDeleteRsp(status, schCellDelRsp->cellId) != ROK) - { - DU_LOG("\nERROR --> MAC: MacProcSchCellDeleteRsp(): Failed to send CELL delete response"); - ret = RFAILED; - } - - } - else - { - DU_LOG("\nERROR --> MAC: MacProcSchCellDeleteRsp(): schCellDelRsp is NULL"); - ret = RFAILED; - } - return ret; + FILL_PST_MAC_TO_DUAPP(rspPst, EVENT_MAC_UE_RESET_RSP); + return (*macDuUeResetRspOpts[rspPst.selector])(&rspPst, ResetRsp); } /******************************************************************* * - * @brief Sends Cell delete req to Scheduler + * @brief Handles UE Reset request from DU APP * * @details * - * Function : sendCellDelReqToSch + * Function : MacProcUeResetReq * - * Functionality: sends Cell delete req to Scheduler + * Functionality: Handles UE Reset requst from DU APP * - * @params[in] SchCellDelete *schCellDel + * @params[in] Pst *pst, MacUeResetReq *ueReset * @return ROK - success * RFAILED - failure * * ****************************************************************/ -uint8_t sendCellDelReqToSch(SchCellDelete *schCellDel) -{ - Pst schPst; - FILL_PST_MAC_TO_SCH(schPst, EVENT_CELL_DELETE_REQ_TO_SCH); - return(*macSchCellDeleteReqOpts[schPst.selector])(&schPst, schCellDel); -} - -/******************************************************************* - * - * @brief Handles CELL Delete requst from DU APP - * - * @details - * - * Function : MacProcCellDeleteReq - * - * Functionality: Handles CELL Delete requst from DU APP - * - * @params[in] Pst *pst, MacCellDelete *cellDelete - * @return ROK - success - * RFAILED - failure - * - * - * ****************************************************************/ -uint8_t MacProcCellDeleteReq(Pst *pst, MacCellDelete *cellDelete) +uint8_t MacProcUeResetReq(Pst *pst, MacUeResetReq *ueReset) { - uint8_t ret = ROK, cellIdx=0; - SchCellDelete schCellDelete; + uint8_t cellIdx=0; + CauseOfResult status =SUCCESSFUL; + MacUeCb *ueCb = NULLP; + MacCellCb *cellCb = NULLP; - DU_LOG("\nINFO --> MAC : Cell Delete Request received for cellId[%d]", cellDelete->cellId); + DU_LOG("\nINFO --> MAC : UE Reset Request received for ueId[%d]", ueReset->ueId); - if(cellDelete) + if(ueReset) { - GET_CELL_IDX(cellDelete->cellId, cellIdx); - if(macCb.macCell[cellIdx]) + GET_CELL_IDX(ueReset->cellId, cellIdx); + cellCb = macCb.macCell[cellIdx]; + if(cellCb) { - if(macCb.macCell[cellIdx]->cellId == cellDelete->cellId) + ueCb = &cellCb->ueCb[ueReset->ueId-1]; + if(ueCb->ueId == ueReset->ueId) { - memset(&schCellDelete, 0, sizeof(SchCellDelete)); - schCellDelete.cellId = cellDelete->cellId; - ret = sendCellDelReqToSch(&schCellDelete); - if(ret != ROK) - { - DU_LOG("\nERROR --> MAC : MacProcCellDeleteReq(): Failed to send UE Delete Request to SCH"); - ret = RFAILED; - } + /* TODO := complete the processing of UE reset request*/ } else { - DU_LOG("\nERROR --> MAC : MacProcCellDeleteReq(): Failed to find the MacUeCb of CellId = %d",\ - cellDelete->cellId); - ret = RFAILED; + DU_LOG("\nERROR --> MAC : MacProcUeResetReq(): UE ID [%d] not found in Cell Id [%d]", ueCb->ueId , ueReset->cellId); + status = UEID_INVALID; } } else { - DU_LOG("\nERROR --> MAC : MacProcCellDeleteReq(): Failed to find the MacUeCb of CellId = %d",\ - cellDelete->cellId); - ret = RFAILED; + DU_LOG("\nERROR --> MAC : MacProcUeResetReq(): Cell Id [%d] not found ",ueReset->cellId); + status = CELLID_INVALID; } - if(ret == RFAILED) - { - DU_LOG("\nERROR --> MAC : MacProcCellDeleteReq(): Sending failure response to DU"); - if(MacSendCellDeleteRsp(CELL_ID_INVALID, cellDelete->cellId) != ROK) - { - DU_LOG("\nERROR --> MAC : MacProcCellDeleteReq(): failed to send cell delete rsp for cellID[%d]",\ - cellDelete->cellId); - } - - } - MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cellDelete, sizeof(MacCellDelete)); + MacSendUeResetRsp(ueReset->cellId, ueReset->ueId, status); + MAC_FREE_SHRABL_BUF(pst->region, pst->pool, ueReset, sizeof(MacUeResetReq)); } else { - DU_LOG("\nERROR --> MAC : MacProcCellDeleteReq(): Received MacCellDelete is NULL"); - ret = RFAILED; + DU_LOG("\nERROR --> MAC : MacProcUeResetReq(): MAC UE reset request processing failed"); + return RFAILED; } - return ret; + return ROK; } - /********************************************************************** End of file **********************************************************************/