+ /* Fill Search space info */
+ schPdcchCfg->numSearchSpcToAddMod = macPdcchCfg.numSearchSpcToAddMod;
+ if(schPdcchCfg->numSearchSpcToAddMod > MAX_NUM_SEARCH_SPC)
+ {
+ DU_LOG("\nERROR --> MAC : Number of search space to ADD/MOD [%d] exceeds max [%d]", \
+ schPdcchCfg->numSearchSpcToAddMod, MAX_NUM_SEARCH_SPC);
+ return RFAILED;
+ }
+ for(idx = 0; idx < schPdcchCfg->numSearchSpcToAddMod; idx++)
+ {
+ schPdcchCfg->searchSpcToAddModList[idx].searchSpaceId = \
+ macPdcchCfg.searchSpcToAddModList[idx].searchSpaceId;
+ schPdcchCfg->searchSpcToAddModList[idx].cRSetId = \
+ macPdcchCfg.searchSpcToAddModList[idx].cRSetId;
+ schPdcchCfg->searchSpcToAddModList[idx].mSlotPeriodicityAndOffset = \
+ macPdcchCfg.searchSpcToAddModList[idx].mSlotPeriodicityAndOffset;
+ memcpy(&schPdcchCfg->searchSpcToAddModList[idx].mSymbolsWithinSlot,
+ &macPdcchCfg.searchSpcToAddModList[idx].mSymbolsWithinSlot, \
+ MONITORING_SYMB_WITHIN_SLOT_SIZE);
+ schPdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel1 = \
+ macPdcchCfg.searchSpcToAddModList[idx].numCandidatesAggLevel1;
+ schPdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel2 = \
+ macPdcchCfg.searchSpcToAddModList[idx].numCandidatesAggLevel2;
+ schPdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel4 = \
+ macPdcchCfg.searchSpcToAddModList[idx].numCandidatesAggLevel4;
+ schPdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel8 = \
+ macPdcchCfg.searchSpcToAddModList[idx].numCandidatesAggLevel8;
+ schPdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel16 = \
+ macPdcchCfg.searchSpcToAddModList[idx].numCandidatesAggLevel16;
+ schPdcchCfg->searchSpcToAddModList[idx].searchSpaceType = \
+ macPdcchCfg.searchSpcToAddModList[idx].searchSpaceType;
+ schPdcchCfg->searchSpcToAddModList[idx].ueSpecificDciFormat = \
+ macPdcchCfg.searchSpcToAddModList[idx].ueSpecificDciFormat;
+ }
+
+ schPdcchCfg->numSearchSpcToRel = macPdcchCfg.numSearchSpcToRel;
+ if(schPdcchCfg->numSearchSpcToRel > MAX_NUM_SEARCH_SPC)
+ {
+ DU_LOG("\nERROR --> MAC : Number of search space to release [%d] exceeds max [%d]", \
+ schPdcchCfg->numSearchSpcToRel, MAX_NUM_SEARCH_SPC);
+ return RFAILED;
+ }
+ for(idx = 0; idx < schPdcchCfg->numSearchSpcToRel; idx++)
+ {
+ /* TODO */
+ }
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill PDSCH cfg in Initial DL BWP for UE Cfg in Scheduler
+ *
+ * @details
+ *
+ * Function : fillInitDlBwpPdschCfg
+ *
+ * Functionality:
+ * Fill PDSCH cfg in Initial DL BWP for UE Cfg in Scheduler
+ *
+ * @params[in] macPdschCfg : Inital DL BWP PDSCH cfg at MAC
+ * schPdschCfg : Inital DL BWP PDSCH cfg to be filled
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillInitDlBwpPdschCfg(PdschConfig macPdschCfg, SchPdschConfig *schPdschCfg)
+{
+ uint8_t idx;
+
+ schPdschCfg->dmrsDlCfgForPdschMapTypeA.addPos = \
+ macPdschCfg.dmrsDlCfgForPdschMapTypeA.addPos;
+ schPdschCfg->resourceAllocType = macPdschCfg.resourceAllocType;
+ schPdschCfg->numTimeDomRsrcAlloc = macPdschCfg.numTimeDomRsrcAlloc;
+ if(schPdschCfg->numTimeDomRsrcAlloc > MAX_NUM_DL_ALLOC)
+ {
+ DU_LOG("\nERROR --> MAC : Number of time domain resource allocation [%d], exceeds\
+ max limit [%d]", schPdschCfg->numTimeDomRsrcAlloc, MAX_NUM_DL_ALLOC);
+ return RFAILED;
+ }
+
+ 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 = \
+ macPdschCfg.timeDomRsrcAllociList[idx].startSymbol;
+ schPdschCfg->timeDomRsrcAllociList[idx].symbolLength = \
+ macPdschCfg.timeDomRsrcAllociList[idx].symbolLength;
+ }
+
+ schPdschCfg->rbgSize = macPdschCfg.rbgSize;
+ schPdschCfg->numCodeWordsSchByDci = macPdschCfg.numCodeWordsSchByDci;
+ schPdschCfg->bundlingType = macPdschCfg.bundlingType;
+ if(schPdschCfg->bundlingType == STATIC_BUNDLING_TYPE)
+ {
+ schPdschCfg->bundlingInfo.SchStaticBundling.size = macPdschCfg.bundlingInfo.StaticBundling.size;
+ }
+ else if(schPdschCfg->bundlingType == DYNAMIC_BUNDLING_TYPE)
+ {
+ schPdschCfg->bundlingInfo.SchDynamicBundling.sizeSet1 = macPdschCfg.bundlingInfo.DynamicBundling.sizeSet1;
+ schPdschCfg->bundlingInfo.SchDynamicBundling.sizeSet2 = macPdschCfg.bundlingInfo.DynamicBundling.sizeSet2;
+ }
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill Initial DL BWP for SCH UE config
+ *
+ * @details
+ *
+ * Function : fillInitialDlBwp
+ *
+ * Functionality: Fill Initial DL BWP for SCH UE config
+ *
+ * @params[in] macInitDlBwp : Inital DL BWP cfg at MAC
+ * schInitDlBwp : Inital DL BWP cfg to be filled
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillInitialDlBwp(InitialDlBwp macInitDlBwp, SchInitalDlBwp *schInitDlBwp)
+{
+ schInitDlBwp->pdcchCfgPres = macInitDlBwp.pdcchPresent;
+ if(schInitDlBwp->pdcchCfgPres)
+ {
+ if(fillInitDlBwpPdcchCfg(macInitDlBwp.pdcchCfg, &schInitDlBwp->pdcchCfg) != ROK)
+ {
+ DU_LOG("\nERROR --> MAC : fillInitDlBwpPdcchCfg() failed");
+ return RFAILED;
+ }
+ }
+
+ schInitDlBwp->pdschCfgPres = macInitDlBwp.pdschPresent;
+ if(schInitDlBwp->pdschCfgPres)
+ {
+ if(fillInitDlBwpPdschCfg(macInitDlBwp.pdschCfg,&schInitDlBwp->pdschCfg) != ROK)
+ {
+ DU_LOG("\nERROR --> MAC : fillInitDlBwpPdschCfg() failed");
+ return RFAILED;
+ }
+ }
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fills Sp Cell config to be sent to scheduler
+ *
+ * @details
+ *
+ * Function : fillSpCellCfg
+ *
+ * Functionality: Fills Sp Cell config to be sent to scheduler
+ *
+ * @params[in] macSpCellCfg : SP cell cfg at MAC
+ * schSpCellCfg : SP cell cfg to be filled
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillSpCellCfg(SpCellCfg macSpCellCfg, SchSpCellCfg *schSpCellCfg)
+{
+ uint8_t idx;
+ SchServCellCfgInfo *servCellCfg;
+
+ schSpCellCfg->servCellIdx = macSpCellCfg.servCellIdx;
+ servCellCfg = &schSpCellCfg->servCellCfg;
+
+ /* Fill initial DL BWP */
+ if(fillInitialDlBwp(macSpCellCfg.servCellCfg.initDlBwp, \
+ &servCellCfg->initDlBwp) != ROK )
+ {
+ DU_LOG("\nERROR --> MAC : fillInitialDlBwp() failed");
+ return RFAILED;
+ }
+
+ 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]",\
+ servCellCfg->numDlBwpToAdd, MAX_NUM_BWP);
+ return RFAILED;
+ }
+ for(idx = 0; idx < servCellCfg->numDlBwpToAdd; idx++)
+ {
+ /* TODO : As of now numDlBwpToAdd = 0 */
+ }
+
+ servCellCfg->firstActvDlBwpId = macSpCellCfg.servCellCfg.firstActvDlBwpId;
+ servCellCfg->defaultDlBwpId = macSpCellCfg.servCellCfg.defaultDlBwpId;
+ servCellCfg->bwpInactivityTmr = NULL;
+ if(macSpCellCfg.servCellCfg.bwpInactivityTmr)
+ {
+ /* TODO : This is an optional parameter, not filled currently */
+ }
+
+ /* Fill PDSCH serving cell config */
+ if(fillPdschServCellCfg(macSpCellCfg.servCellCfg.pdschServCellCfg, \
+ &servCellCfg->pdschServCellCfg) != ROK)
+ {
+ DU_LOG("\nERROR --> MAC : fillPdschServCellCfg() failed");
+ return RFAILED;
+ }
+
+ /* Fill Initail UL BWP */
+ if(fillInitialUlBwp(macSpCellCfg.servCellCfg.initUlBwp, \
+ &servCellCfg->initUlBwp) != ROK)
+ {
+ DU_LOG("\nERROR --> MAC : fillInitialUlBwp() failed");
+ return RFAILED;
+ }
+
+ 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]",\
+ servCellCfg->numUlBwpToAdd, MAX_NUM_BWP);
+ return RFAILED;
+ }
+ for(idx = 0; idx < servCellCfg->numUlBwpToAdd; idx++)
+ {
+ /* TODO : As of now numDlBwpToAdd = 0 */
+ }
+ servCellCfg->firstActvUlBwpId = macSpCellCfg.servCellCfg.firstActvUlBwpId;
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Sends UE configuration to Scheduler
+ *
+ * @details
+ *
+ * Function : sendUeReqToSch
+ *
+ * Functionality: sends UE configuration to Scheduler
+ *
+ * @params[in] Pst and Ue configuration
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+
+uint8_t sendUeReqToSch(Pst *pst, SchUeCfg *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);
+
+ 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);
+ default:
+ DU_LOG("\nERROR --> Invalid Pst received %d", pst->event);
+ return RFAILED;
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Fills Sch Drb Qos Information
+ *
+ * @details
+ *
+ * Function : fillSchDrbQosInfo
+ *
+ * Functionality: Fills Sch Drb Qos Information
+ *
+ * @params[in] macLcCfg : Logical channel Cfg at MAC
+ * schLcCfg : LC cfg to fill at scheduler
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+void fillSchDrbQosInfo(DrbQosInfo *macDrbQos, SchDrbQosInfo *schDrbQos)
+{
+ schDrbQos->fiveQiType = macDrbQos->fiveQiType;
+ if(schDrbQos->fiveQiType == SCH_QOS_NON_DYNAMIC)
+ {
+ schDrbQos->u.nonDyn5Qi.fiveQi = macDrbQos->u.nonDyn5Qi.fiveQi;
+ schDrbQos->u.nonDyn5Qi.avgWindow = macDrbQos->u.nonDyn5Qi.avgWindow;
+ schDrbQos->u.nonDyn5Qi.maxDataBurstVol = macDrbQos->u.nonDyn5Qi.maxDataBurstVol;
+ schDrbQos->u.nonDyn5Qi.priorLevel = macDrbQos->u.nonDyn5Qi.priorLevel;
+ }
+ else if(schDrbQos->fiveQiType == SCH_QOS_DYNAMIC)
+ {
+ schDrbQos->u.dyn5Qi.priorLevel = macDrbQos->u.dyn5Qi.priorLevel;
+ schDrbQos->u.dyn5Qi.packetDelayBudget = macDrbQos->u.dyn5Qi.packetDelayBudget;
+ schDrbQos->u.dyn5Qi.packetErrRateScalar= macDrbQos->u.dyn5Qi.packetErrRateScalar;
+ schDrbQos->u.dyn5Qi.packetErrRateExp = macDrbQos->u.dyn5Qi.packetErrRateExp;
+ schDrbQos->u.dyn5Qi.fiveQi = macDrbQos->u.dyn5Qi.fiveQi;
+ schDrbQos->u.dyn5Qi.delayCritical = macDrbQos->u.dyn5Qi.delayCritical;
+ schDrbQos->u.dyn5Qi.avgWindow = macDrbQos->u.dyn5Qi.avgWindow;
+ schDrbQos->u.dyn5Qi.maxDataBurstVol = macDrbQos->u.dyn5Qi.maxDataBurstVol;
+ }
+ schDrbQos->ngRanRetPri.priorityLevel = macDrbQos->ngRanRetPri.priorityLevel;
+ schDrbQos->ngRanRetPri.preEmptionCap = macDrbQos->ngRanRetPri.preEmptionCap;
+ schDrbQos->ngRanRetPri.preEmptionVul = macDrbQos->ngRanRetPri.preEmptionVul;
+ schDrbQos->grbQosFlowInfo.maxFlowBitRateDl = macDrbQos->grbQosInfo.maxFlowBitRateDl;
+ schDrbQos->grbQosFlowInfo.maxFlowBitRateUl = macDrbQos->grbQosInfo.maxFlowBitRateUl;
+ schDrbQos->grbQosFlowInfo.guarFlowBitRateDl= macDrbQos->grbQosInfo.guarFlowBitRateDl;
+ schDrbQos->grbQosFlowInfo.guarFlowBitRateUl= macDrbQos->grbQosInfo.guarFlowBitRateUl;
+ schDrbQos->pduSessionId = macDrbQos->pduSessionId;
+ schDrbQos->ulPduSessAggMaxBitRate = macDrbQos->ulPduSessAggMaxBitRate;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill SCH UL logical channel configuration
+ *
+ * @details
+ *
+ * Function : fillSchUlLcCfg
+ *
+ * Functionality: Fills Sch Ul Lc configuration
+ *
+ * @params[in] macLcCfg : Logical channel Cfg at MAC
+ * schLcCfg : LC cfg to fill at scheduler
+ * @return void
+ *
+ * ****************************************************************/
+
+void fillSchUlLcCfg(SchUlLcCfg *schUlLcCfg, UlLcCfg *macUlLcCfg)
+{
+ schUlLcCfg->priority= macUlLcCfg->priority;
+ schUlLcCfg->lcGroup = macUlLcCfg->lcGroup;
+ schUlLcCfg->schReqId= macUlLcCfg->schReqId;
+ schUlLcCfg->pbr = macUlLcCfg->pbr;
+ schUlLcCfg->bsd = macUlLcCfg->bsd;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill logical channel configuration
+ *
+ * @details
+ *
+ * Function : fillLogicalChannelCfg
+ *
+ * Functionality: Fill logical channel configuration
+ *
+ * @params[in] macLcCfg : Logical channel Cfg at MAC
+ * schLcCfg : LC cfg to fill at scheduler
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+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;
+ }
+ else
+ {
+ schLcCfg->drbQos = NULLP;
+ }
+
+ if(ret == ROK)
+ {
+ if(macLcCfg->snssai)
+ {
+ if(!schLcCfg->snssai)
+ {
+ MAC_ALLOC(schLcCfg->snssai, sizeof(Snssai));
+ if(!schLcCfg->snssai)
+ {
+ DU_LOG("\nERROR --> MAC : Memory alloc failed at snssai at fillLogicalChannelCfg()");
+ ret = RFAILED;
+ }
+ }
+ if(ret == ROK)
+ {
+ schLcCfg->snssai->sst = macLcCfg->snssai->sst;
+ for(sdIdx = 0; sdIdx < SD_SIZE; sdIdx++)
+ {
+ schLcCfg->snssai->sd[sdIdx] = macLcCfg->snssai->sd[sdIdx];
+ }
+ }
+ }
+ else
+ {
+ schLcCfg->snssai = NULLP;
+ }
+ }
+
+ return ret;
+}
+
+/*******************************************************************
+ *
+ * @brief Fills Logical channel Cfg List to Add/Mod/Del
+ *
+ * @details
+ *
+ * Function : fillSchLcCfgList
+ *
+ * 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 fillSchLcCfgList(SchUeCfg *schUeCfg, MacUeCfg *ueCfg)
+{
+ uint8_t lcIdx;
+
+ for(lcIdx = 0; lcIdx < ueCfg->numLcs; lcIdx++)
+ {
+ if(fillLogicalChannelCfg(&schUeCfg->schLcCfg[lcIdx], &ueCfg->lcCfgList[lcIdx]) != ROK)
+ {
+ DU_LOG("\nERROR --> MAC : fillLogicalChannelCfg() failed for lc Idx[%d]", lcIdx);
+ return RFAILED;
+ }
+ schUeCfg->numLcs++;
+ }
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fills and sends UE configuration to Scheduler
+ *
+ * @details
+ *
+ * Function : fillSchUeCfg
+ *
+ * Functionality: Fills and sends UE configuration to Scheduler
+ *
+ * @params[in] Ue configuration from DU APP
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillSchUeCfg(Pst *pst, SchUeCfg *schUeCfg, MacUeCfg *ueCfg)
+{
+ uint8_t ret = ROK;
+
+ schUeCfg->cellId = ueCfg->cellId;
+ schUeCfg->ueId = ueCfg->ueId;
+ schUeCfg->crnti = ueCfg->crnti;
+ schUeCfg->dataTransmissionInfo = ueCfg->transmissionAction;
+ /* Copy MAC cell group config */
+ if(ueCfg->macCellGrpCfgPres == true)
+ {
+ schUeCfg->macCellGrpCfgPres = true;
+ memset(&schUeCfg->macCellGrpCfg, 0, sizeof(SchMacCellGrpCfg));
+ if(fillMacCellGroupCfg(ueCfg->macCellGrpCfg, &schUeCfg->macCellGrpCfg) != ROK)
+ {
+ DU_LOG("\nERROR --> MAC : fillMacCellGroupCfg() failed");
+ return RFAILED;
+ }
+ }
+ if(ueCfg->phyCellGrpCfgPres == true)
+ {
+ schUeCfg->phyCellGrpCfgPres = true;
+ /* Copy Physical cell group config */
+ memset(&schUeCfg->phyCellGrpCfg, 0,sizeof(SchPhyCellGrpCfg));
+ if(fillPhyCellGroupCfg(ueCfg->phyCellGrpCfg, &schUeCfg->phyCellGrpCfg) != ROK)
+ {
+ DU_LOG("\nERROR --> MAC : fillPhyCellGroupCfg() failed");
+ return RFAILED;
+ }
+ }
+
+ if(ueCfg->spCellCfgPres == true)
+ {
+ schUeCfg->spCellCfgPres = true;
+ /* Copy sp cell config */
+ memset(&schUeCfg->spCellCfg, 0, sizeof(SchSpCellCfg));
+ if(fillSpCellCfg(ueCfg->spCellCfg, &schUeCfg->spCellCfg) != ROK)
+ {
+ DU_LOG("\nERROR --> MAC : fillSpCellCfg() failed");
+ return RFAILED;
+ }
+ }
+ if(ueCfg->ambrCfg != NULLP)
+ {
+ MAC_ALLOC(schUeCfg->ambrCfg, sizeof(SchAmbrCfg));
+ if(!schUeCfg->ambrCfg)
+ {
+ DU_LOG("\nERROR --> MAC : Memory allocation failed in sendReconfigReqToSch");
+ return RFAILED;
+ }
+ 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;
+ schUeCfg->dlModInfo.mcsTable = ueCfg->dlModInfo.mcsTable;
+
+ /* Fill UL modulation infor */
+ schUeCfg->ulModInfo.modOrder = ueCfg->ulModInfo.modOrder;
+ schUeCfg->ulModInfo.mcsIndex = ueCfg->ulModInfo.mcsIndex;
+ schUeCfg->ulModInfo.mcsTable = ueCfg->ulModInfo.mcsTable;
+
+ /* Fill sch Lc Cfg to Add/ Mod/ Del */
+ ret = fillSchLcCfgList(schUeCfg, ueCfg);
+ if(ret == RFAILED)
+ {
+ DU_LOG("\nERROR --> MAC : Failed to copy LCs at fillSchUeCfg()");
+ return ret;
+ }
+
+#ifdef NR_DRX
+ schUeCfg->drxConfigIndicatorRelease = ueCfg->drxConfigIndicatorRelease;;
+#endif
+
+ return ret;
+}
+
+/*******************************************************************
+ *
+ * @brief Update UeUlCb Lc List
+ *
+ * @details
+ *
+ * Function : updateMacUlCb
+ *
+ * Functionality: Update UeUlCb Lc List
+ *
+ * @params[in] delIdx, UeUlCb pointer
+ * @return void
+ *
+ * ****************************************************************/
+
+void updateMacUlCb(uint8_t delIdx, UeUlCb *ulCb)
+{
+ uint8_t lcIdx = 0;
+
+ for(lcIdx = delIdx; lcIdx < ulCb->numUlLc; lcIdx++)
+ {
+ /* Moving the array element to one step ahead */
+ 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
+}
+
+/*******************************************************************
+ *
+ * @brief Update UeDlCb Lc List
+ *
+ * @details
+ *
+ * Function : updateMacDlCb
+ *
+ * Functionality: Update UeDlCb Lc List
+ *
+ * @params[in] delIdx, UeDlCb pointer
+ * @return void
+ *
+ * ****************************************************************/
+
+void updateMacDlCb(uint8_t delIdx, UeDlCb *dlCb)
+{
+ uint8_t lcIdx = 0;
+
+ for(lcIdx = delIdx; lcIdx < dlCb->numDlLc; lcIdx++)
+ {
+ /* Moving the array element to one step ahead */
+ 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 Update Mac UL Lc List based on CONFIG_MOD/CONFIG_DEL
+ *
+ * @details
+ *
+ * Function : updateMacUlLcCtxt
+ *
+ * Functionality: Update UeUlCb Lc List
+ *
+ * @params[in] UeUlCb pointer, ueLcCfg(received from DUAPP)
+ * @return void
+ *
+ * ****************************************************************/
+void updateMacUlLcCtxt(UeUlCb *ulInfo, LcCfg *ueLcCfg)
+{
+ uint8_t ueLcIdx = 0;
+
+ /*Traversing UL LC to be updated/Deleted*/
+ for(ueLcIdx = 0; ueLcIdx < ulInfo->numUlLc; ueLcIdx++)
+ {
+ if(ulInfo->lcCb[ueLcIdx].lcId == ueLcCfg->lcId)
+ {
+ if(ueLcCfg->configType == CONFIG_MOD)
+ {
+ /*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;
+ }
+ if(ueLcCfg->configType == CONFIG_DEL)
+ {
+ memset(&ulInfo->lcCb[ueLcIdx], 0, sizeof(UlLcCb));
+ (ulInfo->numUlLc)--;
+ updateMacUlCb(ueLcIdx, ulInfo);
+ DU_LOG("\nINFO --> MAC: Successfully Deleted LC context for lcId[%d]", ueLcCfg->lcId);
+ 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, ueLcCfg(received from DUAPP)
+ * @return void
+ *
+ * ****************************************************************/
+void updateMacDlLcCtxt(UeDlCb *dlInfo, LcCfg *ueLcCfg)
+{
+ uint8_t ueLcIdx = 0;
+
+ /*Traversing DL LC to be updated/Deleted*/
+ for(ueLcIdx = 0; ueLcIdx < dlInfo->numDlLc; ueLcIdx++)
+ {
+ if(dlInfo->lcCb[ueLcIdx].lcId == ueLcCfg->lcId)
+ {
+ if(ueLcCfg->configType == CONFIG_MOD)
+ {
+ /*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;
+ }
+ if(ueLcCfg->configType == CONFIG_DEL)
+ {
+ memset(&dlInfo->lcCb[ueLcIdx], 0, sizeof(DlLcCb));
+ (dlInfo->numDlLc)--;
+ updateMacDlCb(ueLcIdx, dlInfo);
+ DU_LOG("\nINFO --> MAC: Successfully Deleted LC context for lcId[%d]", ueLcCfg->lcId);
+ 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, MacUeCfg *ueCfg)
+{
+ uint8_t lcIdx = 0;
+
+ for(lcIdx = 0; lcIdx < ueCfg->numLcs; lcIdx++)
+ {
+ if(ueCb->dlInfo.numDlLc < MAX_NUM_LC)
+ {
+ if(ueCfg->lcCfgList[lcIdx].configType == CONFIG_ADD)
+ {
+ /*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++;
+ }/*End of Add Config */
+ else
+ {
+ updateMacUlLcCtxt(&ueCb->ulInfo, &ueCfg->lcCfgList[lcIdx]);
+ updateMacDlLcCtxt(&ueCb->dlInfo, &ueCfg->lcCfgList[lcIdx]);
+ }/*End of Mod Config */
+ }
+ }
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fills MAC UE Cb Cfg
+ *
+ * @details
+ *
+ * Function : fillMacUeCb
+ *
+ * Functionality: Fills MAC UE Cb Cfg
+ *
+ * @params[in] MAC UE Cb Cfg , MAC UE Configuration
+ * cellIdx
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+
+uint8_t fillMacUeCb(MacUeCb *ueCb, MacUeCfg *ueCfg, uint8_t cellIdx)
+{
+ uint8_t ret = ROK;
+
+ ueCb->ueId = ueCfg->ueId;
+ ueCb->crnti = ueCfg->crnti;
+ ueCb->cellCb = macCb.macCell[cellIdx];
+ if(ueCfg->spCellCfgPres)
+ {
+ ueCb->dlInfo.dlHarqEnt.numHarqProcs = \
+ ueCfg->spCellCfg.servCellCfg.pdschServCellCfg.numHarqProcForPdsch;
+ }
+
+ /*TODO: To check the bsr value during implementation */
+ if(ueCfg->macCellGrpCfgPres)
+ {
+ ueCb->bsrTmrCfg.periodicTimer = ueCfg->macCellGrpCfg.bsrTmrCfg.periodicTimer;
+ ueCb->bsrTmrCfg.retxTimer = ueCfg->macCellGrpCfg.bsrTmrCfg.retxTimer;
+ ueCb->bsrTmrCfg.srDelayTimer = ueCfg->macCellGrpCfg.bsrTmrCfg.srDelayTimer;
+ }
+ ret = fillMacLcCfgList(ueCb, ueCfg);
+ if(ret == RFAILED)
+ {
+ DU_LOG("\nERROR --> MAC: Failed while filing MAC LC List at fillMacUeCb()");
+ }
+ ueCb->transmissionAction = ueCfg->transmissionAction;
+
+ return ret;
+}
+
+/*******************************************************************
+ *
+ * @brief Function to update Mac Ra Cb
+ *
+ * @details
+ *
+ * Function : updateMacRaCb
+ *
+ * Functionality: Function to update Mac Ra Cb
+ *
+ * @params[in] cellIdx, Mac Ue Cb
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+
+uint8_t updateMacRaCb(uint16_t cellIdx, MacUeCb *ueCb)
+{
+ /* Copy RA Cb */
+ if(macCb.macCell[cellIdx]->macRaCb[ueCb->ueId-1].crnti == ueCb->crnti)
+ {
+ 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;
+}
+
+/*******************************************************************
+ *
+ * @brief Function to delete Mac Ra Cb
+ *
+ * @details
+ *
+ * Function : deleteMacRaCb
+ *
+ * Functionality: Function to delete Mac Ra Cb
+ *
+ * @params[in] cellIdx, Mac Ue Cb
+ * @return void
+ *
+ * ****************************************************************/
+
+void deleteMacRaCb(uint16_t cellIdx, MacUeCb *ueCb)
+{
+ uint8_t tbIdx;
+ MacRaCbInfo *raCb = ueCb->raCb;
+ DlHarqProcCb *hqProcCb;
+
+ if(raCb && (raCb->crnti == ueCb->crnti))
+ {
+ hqProcCb = &raCb->msg4HqInfo;
+ MAC_FREE(raCb->msg4Pdu, raCb->msg4PduLen);
+ for(tbIdx = 0; tbIdx < raCb->msg4HqInfo.numTb; tbIdx++)
+ {
+ MAC_FREE(raCb->msg4HqInfo.tbInfo[tbIdx].tb, \
+ raCb->msg4HqInfo.tbInfo[tbIdx].tbSize - TX_PAYLOAD_HDR_LEN);
+ }
+ memset(raCb, 0, sizeof(MacRaCbInfo));
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Creates UE Cb
+ *
+ * @details
+ *
+ * Function : createUeCb
+ *
+ * Functionality: Creates UE Cb
+ *
+ * @params[in] MAC UE Configuration
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t createUeCb(uint8_t cellIdx, MacUeCb *ueCb, MacUeCfg *ueCfg)
+{
+ uint8_t ret = ROK;
+ uint8_t hqProcIdx = 0;
+
+ if((ueCb->ueId == ueCfg->ueId) && (ueCb->crnti == ueCfg->crnti)\
+ &&(ueCb->state == UE_STATE_ACTIVE))
+ {
+ DU_LOG("\nERROR --> MAC : CRNTI %d already configured ", ueCfg->crnti);
+ return ROKDUP;
+ }
+ else