+ * @params[in] PucchFormat
+ * PucchFormatCfg pointer,
+ * SchPucchCfg pointer
+ * @return void
+ *
+ * ****************************************************************/
+
+uint8_t fillOtherPucchFormatCfg(uint8_t pucchFormat, PucchFormatCfg *macFormatCfg, SchPucchCfg *schPucchCfg)
+{
+
+ switch(pucchFormat)
+ {
+ case PUCCH_FORMAT_1:
+ {
+ if(macFormatCfg)
+ {
+ MAC_ALLOC(schPucchCfg->format1, sizeof(SchPucchFormatCfg));
+ if(schPucchCfg->format1 == NULLP)
+ {
+ DU_LOG("\nERROR --> MAC : Failed to allocate Mem for Format 1 in fillOtherPucchFormatCfg()");
+ return RFAILED;
+ }
+ fillPucchFormatCfg(macFormatCfg, schPucchCfg->format1);
+ }
+ break;
+ }
+ case PUCCH_FORMAT_2:
+ {
+ if(macFormatCfg)
+ {
+ MAC_ALLOC(schPucchCfg->format2, sizeof(SchPucchFormatCfg));
+ if(schPucchCfg->format2 == NULLP)
+ {
+ DU_LOG("\nERROR --> MAC : Failed to allocate Mem for Format 2 in fillOtherPucchFormatCfg()");
+ return RFAILED;
+ }
+ fillPucchFormatCfg(macFormatCfg, schPucchCfg->format2);
+ }
+ break;
+ }
+ case PUCCH_FORMAT_3:
+ {
+ if(macFormatCfg)
+ {
+ MAC_ALLOC(schPucchCfg->format3, sizeof(SchPucchFormatCfg));
+ if(schPucchCfg->format3 == NULLP)
+ {
+ DU_LOG("\nERROR --> MAC : Failed to allocate Mem for Format 3 in fillOtherPucchFormatCfg()");
+ return RFAILED;
+ }
+ fillPucchFormatCfg(macFormatCfg, schPucchCfg->format3);
+ }
+ break;
+ }
+ case PUCCH_FORMAT_4:
+ {
+ if(macFormatCfg)
+ {
+ MAC_ALLOC(schPucchCfg->format4, sizeof(SchPucchFormatCfg));
+ if(schPucchCfg->format4 == NULLP)
+ {
+ DU_LOG("\nERROR --> MAC : Failed to allocate Mem for Format 4 in fillOtherPucchFormatCfg()");
+ return RFAILED;
+ }
+ fillPucchFormatCfg(macFormatCfg, schPucchCfg->format4);
+ }
+ break;
+ }
+ default:
+ DU_LOG("\nERROR --> MAC : Invalid Format Cfg %d in fillInitialUlBwpPucchCfg()", pucchFormat);
+ return RFAILED;
+ }
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fills PUCCH config in initial UL BWP config for SCH UE Cfg
+ *
+ * @details
+ *
+ * Function : fillInitalUlBwpPucchCfg
+ *
+ * Functionality:
+ * Fills PUCCH cofig in initial UL BWP config for SCH UE Cfg
+ *
+ * @params[in] macPucchCfg : Initial UL-BWP PUCCH cfg at MAC
+ * schPucchCfg : Initial UL-BWP PUCCH cfg to be filled
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillInitialUlBwpPucchCfg(PucchCfg *macPucchCfg, SchPucchCfg *schPucchCfg)
+{
+ if(macPucchCfg->resrcSet)
+ {
+ MAC_ALLOC(schPucchCfg->resrcSet, sizeof(SchPucchResrcSetCfg));
+ if(schPucchCfg->resrcSet == NULLP)
+ {
+ DU_LOG("\nERROR --> MAC : Failed to allocate Mem for Resrc set List in fillInitialUlBwpPucchCfg()");
+ return RFAILED;
+ }
+ memset(schPucchCfg->resrcSet, 0, sizeof(SchPucchResrcSetCfg));
+ fillResrcSetList(macPucchCfg->resrcSet, schPucchCfg->resrcSet);
+ }
+
+ if(macPucchCfg->resrc)
+ {
+ MAC_ALLOC(schPucchCfg->resrc, sizeof(SchPucchResrcCfg));
+ if(schPucchCfg->resrc == NULLP)
+ {
+ DU_LOG("\nERROR --> MAC : Failed to allocate Mem for Resrc List in fillInitialUlBwpPucchCfg()");
+ return RFAILED;
+ }
+ memset(schPucchCfg->resrc, 0, sizeof(SchPucchResrcCfg));
+ if((fillResrcList(macPucchCfg->resrc, schPucchCfg->resrc)) != ROK)
+ {
+ DU_LOG("\nERROR --> MAC : Failed in fillResrcList() at fillInitialUlBwpPucchCfg()");
+ return RFAILED;
+ }
+ }
+
+ /* valid for format 1, 2, 3, 4 */
+ fillOtherPucchFormatCfg(PUCCH_FORMAT_1, macPucchCfg->format1, schPucchCfg);
+ fillOtherPucchFormatCfg(PUCCH_FORMAT_2, macPucchCfg->format2, schPucchCfg);
+ fillOtherPucchFormatCfg(PUCCH_FORMAT_3, macPucchCfg->format3, schPucchCfg);
+ fillOtherPucchFormatCfg(PUCCH_FORMAT_4, macPucchCfg->format4, schPucchCfg);
+
+ if(macPucchCfg->schedReq)
+ {
+ MAC_ALLOC(schPucchCfg->schedReq, sizeof(SchPucchSchedReqCfg));
+ if(schPucchCfg->schedReq == NULLP)
+ {
+ DU_LOG("\nERROR --> MAC : Failed to allocate Mem for PucchSchedReqCfg in fillInitialUlBwpPucchCfg()");
+ return RFAILED;
+ }
+ memset(schPucchCfg->schedReq, 0, sizeof(SchPucchSchedReqCfg));
+ fillPucchSchedReqCfg(macPucchCfg->schedReq, schPucchCfg->schedReq);
+ }
+
+ if(macPucchCfg->multiCsiCfg)
+ {
+ MAC_ALLOC(schPucchCfg->multiCsiCfg, sizeof(SchPucchMultiCsiCfg));
+ if(schPucchCfg->multiCsiCfg == NULLP)
+ {
+ DU_LOG("\nERROR --> MAC : Failed to allocate Mem for multiCsiCfg in fillInitialUlBwpPucchCfg()");
+ return RFAILED;
+ }
+ memset(schPucchCfg->multiCsiCfg, 0, sizeof(SchPucchMultiCsiCfg));
+ fillMultiCsiCfg(macPucchCfg->multiCsiCfg, schPucchCfg->multiCsiCfg);
+ }
+
+ //TODO: To add the support for spatial Config
+ schPucchCfg->spatialInfo = NULLP;
+
+ if(macPucchCfg->dlDataToUlAck)
+ {
+ MAC_ALLOC(schPucchCfg->dlDataToUlAck, sizeof(SchPucchDlDataToUlAck));
+ if(schPucchCfg->dlDataToUlAck == NULLP)
+ {
+ DU_LOG("\nERROR --> MAC : Failed to allocate Mem for dlDataToUlAck in fillInitialUlBwpPucchCfg()");
+ return RFAILED;
+ }
+ memset(schPucchCfg->dlDataToUlAck, 0, sizeof(SchPucchDlDataToUlAck));
+ fillDlToUlAck(macPucchCfg->dlDataToUlAck, schPucchCfg->dlDataToUlAck);
+
+ }
+
+ if(macPucchCfg->powerControl)
+ {
+ MAC_ALLOC(schPucchCfg->powerControl, sizeof(SchPucchPowerControl));
+ if(schPucchCfg->powerControl == NULLP)
+ {
+ DU_LOG("\nERROR --> MAC : Failed to allocate Mem for powerControl in fillInitialUlBwpPucchCfg()");
+ return RFAILED;
+ }
+ memset(schPucchCfg->powerControl, 0, sizeof(SchPucchPowerControl));
+ fillPucchPowerControl(macPucchCfg->powerControl, schPucchCfg->powerControl);
+ }
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief function to free Pucch Format
+ *
+ * @details
+ *
+ * Function : freeSchPucchFormat
+ *
+ * Functionality:
+ * function to free Pucch Format
+ *
+ * @params[in] pucchFormat, SchPucchResrcInfo Pointer,
+ * SchPucchResrcInfo pointer
+ * @return void
+ * ****************************************************************/
+
+void freeSchPucchFormat(uint8_t pucchFormat, SchPucchResrcInfo *resrcInfo, SchPucchFormatCfg *formatCfg)
+{
+ switch(pucchFormat)
+ {
+ case PUCCH_FORMAT_0 :
+ if(resrcInfo->SchPucchFormat.format0)
+ {
+ MAC_FREE(resrcInfo->SchPucchFormat.format0, sizeof(SchPucchFormat0));
+ resrcInfo->SchPucchFormat.format0 = NULLP;
+ }
+ break;
+
+ case PUCCH_FORMAT_1 :
+ if(resrcInfo->SchPucchFormat.format1)
+ {
+ MAC_FREE(resrcInfo->SchPucchFormat.format1, sizeof(SchPucchFormat1));
+ resrcInfo->SchPucchFormat.format1 = NULLP;
+ }
+ if(formatCfg)
+ {
+ memset(formatCfg, 0, sizeof(SchPucchFormatCfg));
+ MAC_FREE(formatCfg, sizeof(SchPucchFormatCfg));
+ }
+ break;
+
+ case PUCCH_FORMAT_2 :
+ if(resrcInfo->SchPucchFormat.format2)
+ {
+ MAC_FREE(resrcInfo->SchPucchFormat.format2, sizeof(SchPucchFormat2_3));
+ resrcInfo->SchPucchFormat.format2 = NULLP;
+ }
+ if(formatCfg)
+ {
+ memset(formatCfg, 0, sizeof(SchPucchFormatCfg));
+ MAC_FREE(formatCfg, sizeof(SchPucchFormatCfg));
+ }
+ break;
+
+ case PUCCH_FORMAT_3 :
+ if(resrcInfo->SchPucchFormat.format3)
+ {
+ MAC_FREE(resrcInfo->SchPucchFormat.format3, sizeof(SchPucchFormat2_3));
+ resrcInfo->SchPucchFormat.format3 = NULLP;
+ }
+ if(formatCfg)
+ {
+ memset(formatCfg, 0, sizeof(SchPucchFormatCfg));
+ MAC_FREE(formatCfg, sizeof(SchPucchFormatCfg));
+ }
+ break;
+
+ case PUCCH_FORMAT_4 :
+ if(resrcInfo->SchPucchFormat.format4)
+ {
+ MAC_FREE(resrcInfo->SchPucchFormat.format4, sizeof(SchPucchFormat4));
+ resrcInfo->SchPucchFormat.format4 = NULLP;
+ }
+ if(formatCfg)
+ {
+ memset(formatCfg, 0, sizeof(SchPucchFormatCfg));
+ MAC_FREE(formatCfg, sizeof(SchPucchFormatCfg));
+ }
+ break;
+
+ default:
+ break;
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief function to free Pucch Resrc Cfg
+ *
+ * @details
+ *
+ * Function : freePucchResrcCfg
+ *
+ * Functionality:
+ * function to free Pucch Resrc Cfg
+ *
+ * @params[in] SchPucchResrcCfg pointer,
+ * @return void
+ * ****************************************************************/
+
+void freePucchResrcCfg(SchPucchResrcCfg *schRsrcList)
+{
+ uint8_t resrcIdx;
+
+ /* free Resrc To AddMod List */
+ for(resrcIdx = 0; resrcIdx < schRsrcList->resrcToAddModListCount; resrcIdx++)
+ {
+ freeSchPucchFormat(schRsrcList->resrcToAddModList[resrcIdx].pucchFormat,
+ &schRsrcList->resrcToAddModList[resrcIdx], NULLP);
+ memset(&schRsrcList->resrcToAddModList[resrcIdx], 0, sizeof(SchPucchResrcInfo));
+ }
+ memset(schRsrcList, 0, sizeof(SchPucchResrcCfg));
+ MAC_FREE(schRsrcList, sizeof(SchPucchResrcCfg));
+}
+
+/*******************************************************************
+ *
+ * @brief function to free Pucch Sched Req Cfg
+ *
+ * @details
+ *
+ * Function : freePucchSchedReqCfg
+ *
+ * Functionality:
+ * function to free Pucch Sched Req Cfg
+ *
+ * @params[in] SchPucchSchedReqCfg pointer,
+ * @return void
+ * ****************************************************************/
+
+void freePucchSchedReqCfg(SchPucchSchedReqCfg *schedReqCfg)
+{
+ uint8_t schedReqIdx;
+
+ for(schedReqIdx = 0; schedReqIdx < schedReqCfg->schedAddModListCount; schedReqIdx++)
+ {
+ memset(&schedReqCfg->schedAddModList[schedReqIdx], 0, sizeof(SchSchedReqResrcInfo));
+ }
+ memset(schedReqCfg, 0, sizeof(SchPucchSchedReqCfg));
+ MAC_FREE(schedReqCfg, sizeof(SchPucchSchedReqCfg));
+}
+
+/*******************************************************************
+ *
+ * @brief function to free Ul Bwp Pucch Cfg
+ *
+ * @details
+ *
+ * Function : freeUlBwpPucchCfg
+ *
+ * Functionality:
+ * function to free Ul Bwp Pucch Cfg
+ *
+ * @params[in] SchPucchCfg pointer,
+ * @return void
+ * ****************************************************************/
+
+void freeUlBwpPucchCfg(SchPucchCfg *schPucchCfg)
+{
+ if(schPucchCfg->resrcSet)
+ {
+ memset(schPucchCfg->resrcSet, 0, sizeof(SchPucchResrcSetCfg));
+ MAC_FREE(schPucchCfg->resrcSet, sizeof(SchPucchResrcSetCfg));
+ }
+ if(schPucchCfg->resrc)
+ {
+ freePucchResrcCfg(schPucchCfg->resrc);
+ }
+ if(schPucchCfg->format1)
+ {
+ freeSchPucchFormat(PUCCH_FORMAT_1, NULLP, schPucchCfg->format1);
+ }
+ if(schPucchCfg->format2)
+ {
+ freeSchPucchFormat(PUCCH_FORMAT_2, NULLP, schPucchCfg->format2);
+ }
+ if(schPucchCfg->format3)
+ {
+ freeSchPucchFormat(PUCCH_FORMAT_3, NULLP, schPucchCfg->format3);
+ }
+ if(schPucchCfg->format4)
+ {
+ freeSchPucchFormat(PUCCH_FORMAT_4, NULLP, schPucchCfg->format4);
+ }
+ if(schPucchCfg->schedReq)
+ {
+ freePucchSchedReqCfg(schPucchCfg->schedReq);
+ }
+ if(schPucchCfg->spatialInfo)
+ {
+ memset(schPucchCfg->spatialInfo, 0, sizeof(SchPucchSpatialCfg));
+ MAC_FREE(schPucchCfg->spatialInfo, sizeof(SchPucchSpatialCfg));
+ }
+ if(schPucchCfg->multiCsiCfg)
+ {
+ memset(schPucchCfg->multiCsiCfg, 0, sizeof(SchPucchMultiCsiCfg));
+ MAC_FREE(schPucchCfg->multiCsiCfg, sizeof(SchPucchMultiCsiCfg));
+ }
+ if(schPucchCfg->dlDataToUlAck)
+ {
+ memset(schPucchCfg->dlDataToUlAck, 0, sizeof(SchPucchDlDataToUlAck));
+ MAC_FREE(schPucchCfg->dlDataToUlAck, sizeof(SchPucchDlDataToUlAck));
+ }
+ if(schPucchCfg->powerControl)
+ {
+ memset(schPucchCfg->powerControl, 0, sizeof(SchPucchPowerControl));
+ MAC_FREE(schPucchCfg->powerControl, sizeof(SchPucchPowerControl));
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Fills initail UL BWP config to send to scheduler
+ *
+ * @details
+ *
+ * Function : fillInitialUlBwp
+ *
+ * Functionality: Fills initail UL BWP config to send to sch
+ *
+ * @params[in] macInitUlBwp : Initial UL BWP cfg at MAC
+ * schInitUlBwp : Initial UL BWP cfg to be filled
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillInitialUlBwp(InitialUlBwp macInitUlBwp, SchInitialUlBwp *schInitUlBwp)
+{
+ schInitUlBwp->pucchCfgPres = macInitUlBwp.pucchPresent;
+ if(schInitUlBwp->pucchCfgPres)
+ {
+ memset(&schInitUlBwp->pucchCfg, 0, sizeof(SchPucchCfg));
+ if(fillInitialUlBwpPucchCfg(&macInitUlBwp.pucchCfg, &schInitUlBwp->pucchCfg) != ROK)
+ {
+ DU_LOG("\nERROR --> MAC : Failed to fill Pucch Cfg in fillInitialUlBwpPucchCfg()");
+ freeUlBwpPucchCfg(&schInitUlBwp->pucchCfg);
+ return RFAILED;
+ }
+ }
+ schInitUlBwp->puschCfgPres = macInitUlBwp.puschPresent;
+ if(schInitUlBwp->puschCfgPres)
+ {
+ memset(&schInitUlBwp->puschCfg, 0, sizeof(SchPuschCfg));
+ if(fillInitalUlBwpPuschCfg(macInitUlBwp.puschCfg, &schInitUlBwp->puschCfg) != ROK)
+ {
+ DU_LOG("\nERROR --> MAC : Failed to fill Pusch Cfg in fillInitalUlBwpPuschCfg()");
+ return RFAILED;
+ }
+ }
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill PDCCH cfg in Initial DL BWP for UE Cfg in Scheduler
+ *
+ * @details
+ *
+ * Function : fillInitDlBwpPdcchCfg
+ *
+ * Functionality:
+ * Fill PDCCH cfg in Initial DL BWP for UE Cfg in Scheduler
+ *
+ * @params[in] macPdcchCfg : Inital DL BWP PDCCH cfg in MAC
+ * schPdcchCfg : Inital DL BWP PDCCH cfg to be filled
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillInitDlBwpPdcchCfg(PdcchConfig macPdcchCfg, SchPdcchConfig *schPdcchCfg)
+{
+ uint8_t idx;
+
+ /* Fill CORESET info */
+ schPdcchCfg->numCRsetToAddMod = macPdcchCfg.numCRsetToAddMod;
+ if(schPdcchCfg->numCRsetToAddMod > MAX_NUM_CRSET)
+ {
+ DU_LOG("\nERROR --> MAC : Number of CORESET to ADD/MOD [%d] exceeds max limit [%d]",\
+ schPdcchCfg->numCRsetToAddMod, MAX_NUM_CRSET);
+ return RFAILED;
+ }
+
+ for(idx = 0; idx < schPdcchCfg->numCRsetToAddMod; idx++)
+ {
+ schPdcchCfg->cRSetToAddModList[idx].cRSetId = \
+ macPdcchCfg.cRSetToAddModList[idx].cRSetId;
+ memcpy(&schPdcchCfg->cRSetToAddModList[idx].freqDomainRsrc,\
+ &macPdcchCfg.cRSetToAddModList[idx].freqDomainRsrc, FREQ_DOM_RSRC_SIZE);
+ schPdcchCfg->cRSetToAddModList[idx].duration = \
+ macPdcchCfg.cRSetToAddModList[idx].duration;
+ schPdcchCfg->cRSetToAddModList[idx].cceRegMappingType = \
+ macPdcchCfg.cRSetToAddModList[idx].cceRegMappingType;
+ schPdcchCfg->cRSetToAddModList[idx].precoderGranularity = \
+ macPdcchCfg.cRSetToAddModList[idx].precoderGranularity;
+ schPdcchCfg->cRSetToAddModList[idx].dmrsScramblingId = \
+ macPdcchCfg.cRSetToAddModList[idx].dmrsScramblingId;
+ }
+
+ schPdcchCfg->numCRsetToRel = macPdcchCfg.numCRsetToRel;
+ if(schPdcchCfg->numCRsetToAddMod > MAX_NUM_CRSET)
+ {
+ DU_LOG("\nERROR --> MAC : Number of CORESET to release [%d] exceeds max limit [%d]",\
+ schPdcchCfg->numCRsetToRel, MAX_NUM_CRSET);
+ return RFAILED;
+ }
+
+ for(idx = 0; idx < schPdcchCfg->numCRsetToRel; idx++)
+ {
+ /* TODO */
+ }
+
+ /* 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 [%d] exceeds max limit [%d]",\
+ servCellCfg->numDlBwpToAdd, MAX_NUM_BWP);
+ return RFAILED;
+ }
+ for(idx = 0; idx < servCellCfg->numDlBwpToAdd; idx++)
+ {
+ memcpy(&servCellCfg->dlBwpToAddList[idx], &macSpCellCfg.servCellCfg.dlBwpToAddList[idx], sizeof(DlBwpInfo));
+ }
+ 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 [%d] exceeds max limit [%d]",\
+ servCellCfg->numUlBwpToAdd, MAX_NUM_BWP);
+ return RFAILED;
+ }
+ for(idx = 0; idx < servCellCfg->numUlBwpToAdd; idx++)
+ {
+ 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
+ *
+ * @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, void *schUeCfg)
+{
+ Pst schPst;
+ switch(pst->event)
+ {
+ case EVENT_MAC_UE_CREATE_REQ:
+ {
+ 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:
+ {
+ 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;
+ }
+ }
+}
+
+/*******************************************************************
+ *
+ * @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->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
+ *
+ * @details
+ *
+ * Function : fillSchLcCfgList
+ *
+ * Functionality: Fills Logical channel Cfg List to Add
+ *
+ * @params[in] MAC UE Cb Cfg , MAC UE Configuration
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+
+uint8_t fillSchLcCfgList(SchUeCfgReq *schUeCfg, MacUeCreateReq *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->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;
+ }
+ schUeRecfg->numLcsToMod++;
+ }
+ 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(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)
+ {
+ 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*/
+ 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;
+}
+
+/*******************************************************************
+ *
+ * @brief Update UeUlCb Lc List
+ *
+ * @details
+ *
+ * Function : updateMacUlCb
+ *
+ * Functionality: Update UeUlCb Lc List
+ *
+ * @params[in] delIdx, UeUlCb pointer
+ * @return void