X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrmac%2Fmac_cfg_hdl.c;h=f354fa430620d1c8220b1715398d4160e054ba16;hb=de6a435729e3cad9d4a66329080b8206a64f452c;hp=2293082cb55c26a4e53b2a60b5f9f777c7de7595;hpb=5d74fef7c9fe6b65a965ceac6bfe812872dab323;p=o-du%2Fl2.git diff --git a/src/5gnrmac/mac_cfg_hdl.c b/src/5gnrmac/mac_cfg_hdl.c index 2293082cb..f354fa430 100644 --- a/src/5gnrmac/mac_cfg_hdl.c +++ b/src/5gnrmac/mac_cfg_hdl.c @@ -29,6 +29,9 @@ #include "lwr_mac.h" #include "lwr_mac_fsm.h" #include "mac_utils.h" +#include "lwr_mac_phy.h" + +uint8_t ssbPeriodicity[6] = {5, 10, 20, 40, 80, 160}; uint8_t MacSchCellCfgReq(Pst *pst, MacCellCfg *macCellCfg); @@ -46,6 +49,40 @@ SchCellCfgFunc SchCellCfgOpts[] = packSchCellCfg /* packing for light weight loosly coupled */ }; +MacSchCellDeleteReqFunc macSchCellDeleteReqOpts[]= +{ + packMacSchCellDeleteReq, /* packing for loosely coupled */ + MacSchCellDeleteReq, /* packing for tightly coupled */ + packMacSchCellDeleteReq /* packing for light weight loosely coupled */ +}; + +MacDuCellDeleteRspFunc macDuCellDeleteRspOpts[] = +{ + packDuMacCellDeleteRsp, /* packing for loosely coupled */ + DuProcMacCellDeleteRsp, /* packing for tightly coupled */ + packDuMacCellDeleteRsp /* packing for light weight loosly coupled */ +}; + +MacDuSliceCfgRspFunc macDuSliceCfgRspOpts[] = +{ + packDuMacSliceCfgRsp, /* packing for loosely coupled */ + DuProcMacSliceCfgRsp, /* packing for tightly coupled */ + packDuMacSliceCfgRsp /* packing for light weight loosly coupled */ +}; + +MacDuSliceReCfgRspFunc macDuSliceReCfgRspOpts[] = +{ + packDuMacSliceReCfgRsp, /* packing for loosely coupled */ + DuProcMacSliceReCfgRsp, /* packing for tightly coupled */ + packDuMacSliceReCfgRsp /* packing for light weight loosly coupled */ +}; + +MacSchPagingIndFunc macSchPagingIndOpts[] = +{ + packMacSchPagingInd, /* packing for loosely coupled */ + MacSchPagingInd, /* packing for tightly coupled */ + packMacSchPagingInd /* packing for light weight loosely coupled */ +}; /** * @brief Layer Manager Configuration request handler for Scheduler @@ -64,9 +101,12 @@ SchCellCfgFunc SchCellCfgOpts[] = **/ uint8_t MacSchGenCfgReq(Pst *pst, RgMngmt *cfg) { + Pst schPst; + printf("\nReceived Scheduler gen config at MAC"); - pst->dstInst = DEFAULT_CELLS + 1; - SchProcGenCfgReq(pst, cfg); + memset(&schPst, 0, sizeof(Pst)); + FILL_PST_MAC_TO_SCH(schPst, EVENT_SCH_GEN_CFG); + SchProcGenCfgReq(&schPst, cfg); return ROK; } @@ -88,7 +128,7 @@ uint8_t MacSchGenCfgReq(Pst *pst, RgMngmt *cfg) **/ uint8_t SchSendCfgCfm(Pst *pst, RgMngmt *cfm) { - printf("\nSending Scheduler config confirm to DU APP"); + DU_LOG("\nDEBUG --> Sending Scheduler config confirm to DU APP"); pst->dstEnt = ENTDUAPP; pst->dstInst = 0; pst->srcInst = 0; @@ -118,15 +158,15 @@ uint8_t MacProcCellCfgReq(Pst *pst, MacCellCfg *macCellCfg) { Pst cfmPst; uint16_t cellIdx; - uint8_t ret = ROK; + uint8_t ret = ROK, sliceIdx = 0; MacCellCb *macCellCb; - memset(&cfmPst, 0, sizeof(Pst)); + memset((uint8_t *)&cfmPst, 0, sizeof(Pst)); MAC_ALLOC(macCellCb, sizeof(MacCellCb)); if(macCellCb == NULLP) { - DU_LOG("\nMAC : macCellCb is NULL at handling of macCellCfg\n"); + DU_LOG("\nERROR --> MAC : macCellCb is NULL at handling of macCellCfg\n"); return RFAILED; } memset(macCellCb, 0, sizeof(MacCellCb)); @@ -140,11 +180,38 @@ uint8_t MacProcCellCfgReq(Pst *pst, MacCellCfg *macCellCfg) macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1PduLen); if(macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1Pdu == NULLP) { - DU_LOG("\nMAC : macCellCb is NULL at handling of sib1Pdu of macCellCfg\n"); + DU_LOG("\nERROR --> MAC : macCellCb is NULL at handling of sib1Pdu of macCellCfg\n"); return RFAILED; } memcpy(macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1Pdu, macCellCfg->sib1Cfg.sib1Pdu, \ macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1PduLen); + + macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.numSupportedSlice = macCellCfg->plmnInfoList.numSupportedSlice; + MAC_ALLOC(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai, macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.numSupportedSlice\ + * sizeof(Snssai*)); + if(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai == NULLP) + { + DU_LOG("\nERROR --> MAC: Memory allocation failed at MacProcCellCfgReq"); + return RFAILED; + } + + if(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai) + { + for(sliceIdx=0; sliceIdxmacCellCfg.plmnInfoList.numSupportedSlice; sliceIdx++) + { + if(macCellCfg->plmnInfoList.snssai[sliceIdx]) + { + MAC_ALLOC(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai[sliceIdx], sizeof(Snssai)); + if(!macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai[sliceIdx]) + { + DU_LOG("\nERROR --> MAC: Memory allocation failed at MacProcCellCfgReq"); + return RFAILED; + } + memcpy(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai[sliceIdx], macCellCfg->plmnInfoList.snssai[sliceIdx],\ + sizeof(Snssai)); + } + } + } /* Send cell cfg to scheduler */ ret = MacSchCellCfgReq(pst, macCellCfg); @@ -161,17 +228,8 @@ uint8_t MacProcCellCfgReq(Pst *pst, MacCellCfg *macCellCfg) } else { - if(macCellCfg->prachCfg.fdm[0].numUnusedRootSeq != 0) - { - MAC_FREE_SHRABL_BUF(pst->region, pst->pool, macCellCfg->prachCfg.fdm[0].unsuedRootSeq, - macCellCfg->prachCfg.fdm[0].numUnusedRootSeq* sizeof(uint8_t)); - } - MAC_FREE_SHRABL_BUF(pst->region, pst->pool, macCellCfg->sib1Cfg.sib1Pdu, macCellCfg->sib1Cfg.sib1PduLen); MAC_FREE_SHRABL_BUF(pst->region, pst->pool, macCellCfg ,sizeof(MacCellCfg)); } -#ifdef INTEL_WLS - LwrMacEnqueueWlsBlock(); -#endif return ret; } /* end of MacProcCellCfgReq */ @@ -193,32 +251,43 @@ uint8_t MacSchCellCfgReq(Pst *pst, MacCellCfg *macCellCfg) { SchCellCfg schCellCfg; Pst cfgPst; - uint8_t ret; + uint8_t ssbMaskIdx = 0, rsrcListIdx = 0, ret=0, sliceIdx=0; memset(&cfgPst, 0, sizeof(Pst)); + memset(&schCellCfg, 0, sizeof(SchCellCfg)); schCellCfg.cellId = macCellCfg->cellId; schCellCfg.phyCellId = macCellCfg->phyCellId; - schCellCfg.bandwidth = macCellCfg->dlCarrCfg.bw; + schCellCfg.numerology = macCellCfg->numerology; schCellCfg.dupMode = macCellCfg->dupType; + schCellCfg.bandwidth = macCellCfg->dlCarrCfg.bw; + schCellCfg.dlFreq = macCellCfg->dlCarrCfg.freq; + schCellCfg.ulFreq = macCellCfg->ulCarrCfg.freq; /* fill ssb scheduler parameters */ schCellCfg.ssbSchCfg.ssbPbchPwr = macCellCfg->ssbCfg.ssbPbchPwr; schCellCfg.ssbSchCfg.scsCommon = macCellCfg->ssbCfg.scsCmn; schCellCfg.ssbSchCfg.ssbOffsetPointA = macCellCfg->ssbCfg.ssbOffsetPointA; - schCellCfg.ssbSchCfg.ssbPeriod = macCellCfg->ssbCfg.ssbPeriod; + schCellCfg.ssbSchCfg.ssbPeriod = ssbPeriodicity[macCellCfg->ssbCfg.ssbPeriod]; schCellCfg.ssbSchCfg.ssbSubcOffset = macCellCfg->ssbCfg.ssbScOffset; - for(uint8_t idx=0; idxssbCfg.ssbMask[idx]; + schCellCfg.ssbSchCfg.nSSBMask[ssbMaskIdx] = macCellCfg->ssbCfg.ssbMask[ssbMaskIdx]; } + schCellCfg.ssbSchCfg.totNumSsb = countSetBits(schCellCfg.ssbSchCfg.nSSBMask[0]); /* fill SIB1 scheduler parameters */ schCellCfg.sib1SchCfg.sib1PduLen = macCellCfg->sib1Cfg.sib1PduLen; - schCellCfg.sib1SchCfg.sib1NewTxPeriod = macCellCfg->sib1Cfg.sib1NewTxPeriod; schCellCfg.sib1SchCfg.sib1RepetitionPeriod = macCellCfg->sib1Cfg.sib1RepetitionPeriod; schCellCfg.sib1SchCfg.coresetZeroIndex = macCellCfg->sib1Cfg.coresetZeroIndex; schCellCfg.sib1SchCfg.searchSpaceZeroIndex = macCellCfg->sib1Cfg.searchSpaceZeroIndex; schCellCfg.sib1SchCfg.sib1Mcs = macCellCfg->sib1Cfg.sib1Mcs; + schCellCfg.sib1SchCfg.pageCfg.numPO = macCellCfg->sib1Cfg.pagingCfg.numPO; + schCellCfg.sib1SchCfg.pageCfg.poPresent = macCellCfg->sib1Cfg.pagingCfg.poPresent; + + if(schCellCfg.sib1SchCfg.pageCfg.poPresent) + { + memcpy(schCellCfg.sib1SchCfg.pageCfg.pagingOcc, macCellCfg->sib1Cfg.pagingCfg.pagingOcc, MAX_PO_PER_PF); + } /* fill RACH config params */ schCellCfg.schRachCfg.prachCfgIdx = macCellCfg->prachCfg.prachCfgIdx; @@ -230,9 +299,10 @@ uint8_t MacSchCellCfgReq(Pst *pst, MacCellCfg *macCellCfg) schCellCfg.schRachCfg.rootSeqIdx = macCellCfg->prachCfg.fdm[0].rootSeqIdx; schCellCfg.schRachCfg.numRootSeq = macCellCfg->prachCfg.fdm[0].numRootSeq; schCellCfg.schRachCfg.k1 = macCellCfg->prachCfg.fdm[0].k1; + schCellCfg.schRachCfg.totalNumRaPreamble = macCellCfg->prachCfg.totalNumRaPreamble; schCellCfg.schRachCfg.ssbPerRach = macCellCfg->prachCfg.ssbPerRach; - schCellCfg.schRachCfg.prachMultCarrBand = \ - macCellCfg->prachCfg.prachMultCarrBand; + schCellCfg.schRachCfg.numCbPreamblePerSsb = macCellCfg->prachCfg.numCbPreamblePerSsb; + schCellCfg.schRachCfg.prachMultCarrBand = macCellCfg->prachCfg.prachMultCarrBand; schCellCfg.schRachCfg.raContResTmr = macCellCfg->prachCfg.raContResTmr; schCellCfg.schRachCfg.rsrpThreshSsb = macCellCfg->prachCfg.rsrpThreshSsb; schCellCfg.schRachCfg.raRspWindow = macCellCfg->prachCfg.raRspWindow; @@ -262,26 +332,65 @@ uint8_t MacSchCellCfgReq(Pst *pst, MacCellCfg *macCellCfg) macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel8; schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel16 = macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel16; - schCellCfg.schInitialDlBwp.pdschCommon.k0 = macCellCfg->initialDlBwp.pdschCommon.k0; - schCellCfg.schInitialDlBwp.pdschCommon.mappingType = - macCellCfg->initialDlBwp.pdschCommon.mappingType; - schCellCfg.schInitialDlBwp.pdschCommon.startSymbol = - macCellCfg->initialDlBwp.pdschCommon.startSymbol; - schCellCfg.schInitialDlBwp.pdschCommon.lengthSymbol = - macCellCfg->initialDlBwp.pdschCommon.lengthSymbol; + schCellCfg.schInitialDlBwp.pdschCommon.numTimeDomAlloc = macCellCfg->initialDlBwp.pdschCommon.numTimeDomAlloc; + for(rsrcListIdx = 0; rsrcListIdxinitialDlBwp.pdschCommon.numTimeDomAlloc; rsrcListIdx++) + { + schCellCfg.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].k0 = + macCellCfg->initialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].k0; + schCellCfg.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].mappingType = + macCellCfg->initialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].mappingType; + schCellCfg.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].startSymbol = + macCellCfg->initialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].startSymbol; + schCellCfg.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].lengthSymbol = + macCellCfg->initialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].lengthSymbol; + } /* fill initial UL BWP */ schCellCfg.schInitialUlBwp.bwp.freqAlloc.startPrb = macCellCfg->initialUlBwp.bwp.firstPrb; schCellCfg.schInitialUlBwp.bwp.freqAlloc.numPrb = macCellCfg->initialUlBwp.bwp.numPrb; schCellCfg.schInitialUlBwp.bwp.scs = macCellCfg->initialUlBwp.bwp.scs; schCellCfg.schInitialUlBwp.bwp.cyclicPrefix = macCellCfg->initialUlBwp.bwp.cyclicPrefix; - schCellCfg.schInitialUlBwp.puschCommon.k2 = macCellCfg->initialUlBwp.puschCommon.k2; - schCellCfg.schInitialUlBwp.puschCommon.mappingType = - macCellCfg->initialUlBwp.puschCommon.mappingType; - schCellCfg.schInitialUlBwp.puschCommon.startSymbol = - macCellCfg->initialUlBwp.puschCommon.startSymbol; - schCellCfg.schInitialUlBwp.puschCommon.lengthSymbol = - macCellCfg->initialUlBwp.puschCommon.lengthSymbol; + schCellCfg.schInitialUlBwp.puschCommon.numTimeDomRsrcAlloc = \ + macCellCfg->initialUlBwp.puschCommon.numTimeDomRsrcAlloc; + for(rsrcListIdx = 0; rsrcListIdx < macCellCfg->initialUlBwp.puschCommon.numTimeDomRsrcAlloc; rsrcListIdx++) + { + schCellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].k2 = + macCellCfg->initialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].k2; + schCellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].mappingType = + macCellCfg->initialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].mappingType; + schCellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].startSymbol = + macCellCfg->initialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].startSymbol; + schCellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].symbolLength = + macCellCfg->initialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].symbolLength; + } + + if(macCellCfg->plmnInfoList.snssai) + { + schCellCfg.plmnInfoList.numSliceSupport = macCellCfg->plmnInfoList.numSupportedSlice; + MAC_ALLOC(schCellCfg.plmnInfoList.snssai, schCellCfg.plmnInfoList.numSliceSupport * sizeof(Snssai*)); + if(!schCellCfg.plmnInfoList.snssai) + { + DU_LOG("\nERROR --> MAC: Memory allocation failed at MacSchCellCfgReq"); + return RFAILED; + } + for(sliceIdx=0; sliceIdxplmnInfoList.snssai[sliceIdx]) + { + MAC_ALLOC(schCellCfg.plmnInfoList.snssai[sliceIdx], sizeof(Snssai)); + if(!schCellCfg.plmnInfoList.snssai[sliceIdx]) + { + DU_LOG("\nERROR --> MAC: Memory allocation failed at MacSchCellCfgReq"); + return RFAILED; + } + memcpy(schCellCfg.plmnInfoList.snssai[sliceIdx], macCellCfg->plmnInfoList.snssai[sliceIdx], sizeof(Snssai)); + } + } + } + +#ifdef NR_TDD + memcpy(&schCellCfg.tddCfg, &macCellCfg->tddCfg, sizeof(TDDCfg)); +#endif FILL_PST_MAC_TO_SCH(cfgPst, EVENT_SCH_CELL_CFG); @@ -343,10 +452,18 @@ uint8_t MacProcSchCellCfgCfm(Pst *pst, SchCellCfgCfm *schCellCfgCfm) { uint16_t *cellId = NULLP; +#ifdef CALL_FLOW_DEBUG_LOG + DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_SCH_CELL_CFG_CFM\n"); +#endif + if(schCellCfgCfm->rsp == RSP_OK) { cellId = &schCellCfgCfm->cellId; +#ifdef INTEL_TIMER_MODE + sendToLowerMac(UL_IQ_SAMPLE, 0, (void *)cellId); +#else sendToLowerMac(CONFIG_REQUEST, 0, (void *)cellId); +#endif } else { @@ -379,6 +496,553 @@ void fapiMacConfigRsp(uint16_t cellId) MacSendCellCfgCfm(cellId, RSP_OK); } +/******************************************************************* + * + * @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) +{ + MacCellDeleteRsp *deleteRsp=NULLP; + Pst rspPst; + + MAC_ALLOC_SHRABL_BUF(deleteRsp, sizeof(MacCellDeleteRsp)); + if(!deleteRsp) + { + DU_LOG("\nERROR --> MAC : MacSendCellDeleteRsp(): Memory allocation for Cell delete response failed"); + return RFAILED; + } + + /* Filling CELL delete response */ + + memset(deleteRsp, 0, sizeof(MacCellDeleteRsp)); + deleteRsp->cellId = cellId; + deleteRsp->result = result; + + /* Fill Post structure and send CELL delete response*/ + memset(&rspPst, 0, sizeof(Pst)); + FILL_PST_MAC_TO_DUAPP(rspPst, EVENT_MAC_CELL_DELETE_RSP); + return (*macDuCellDeleteRspOpts[rspPst.selector])(&rspPst, deleteRsp); +} + +/******************************************************************* + * + * @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, sliceIdx = 0; + uint16_t cellIdx=0; + CellDeleteStatus status; + +#ifdef CALL_FLOW_DEBUG_LOG + DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_CELL_DELETE_RSP_TO_MAC\n"); +#endif + + 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) + { + status = SUCCESSFUL_RSP; + if(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai) + { + for(sliceIdx = 0; sliceIdxmacCellCfg.plmnInfoList.numSupportedSlice; sliceIdx++) + { + MAC_FREE(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai[sliceIdx], sizeof(Snssai)); + } + MAC_FREE(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai, macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.\ + numSupportedSlice * sizeof(Snssai*)); + } + MAC_FREE(macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1Pdu, \ + macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1PduLen); + 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; +} + +/******************************************************************* + * + * @brief Sends Cell delete req to Scheduler + * + * @details + * + * Function : sendCellDelReqToSch + * + * Functionality: sends Cell delete req to Scheduler + * + * @params[in] SchCellDelete *schCellDel + * @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 ret = ROK, cellIdx=0; + SchCellDelete schCellDelete; + + DU_LOG("\nINFO --> MAC : Cell Delete Request received for cellId[%d]", cellDelete->cellId); + + if(cellDelete) + { + GET_CELL_IDX(cellDelete->cellId, cellIdx); + if(macCb.macCell[cellIdx]) + { + if(macCb.macCell[cellIdx]->cellId == cellDelete->cellId) + { + 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; + } + } + else + { + DU_LOG("\nERROR --> MAC : MacProcCellDeleteReq(): Failed to find the MacUeCb of CellId = %d",\ + cellDelete->cellId); + ret = RFAILED; + } + } + else + { + DU_LOG("\nERROR --> MAC : MacProcCellDeleteReq(): Failed to find the MacUeCb of CellId = %d",\ + cellDelete->cellId); + ret = RFAILED; + } + + 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)); + } + else + { + DU_LOG("\nERROR --> MAC : MacProcCellDeleteReq(): Received MacCellDelete is NULL"); + ret = RFAILED; + } + return ret; +} + +/** + * @brief free the temporary slice cfg stored in macCb. + * + * @details + * + * Function : freeMacSliceCfgReq + * + * free the temporary slice cfg stored in macCb + * + * @param[in] + * @return int + * -# ROK + **/ +void freeMacSliceCfgReq(MacSliceCfgReq *cfgReq,Pst *pst) +{ + uint8_t cfgIdx = 0; + + if(cfgReq) + { + if(cfgReq->numOfConfiguredSlice) + { + for(cfgIdx = 0; cfgIdxnumOfConfiguredSlice; cfgIdx++) + { + if(cfgReq->listOfSliceCfg[cfgIdx]) + { + MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cfgReq->listOfSliceCfg[cfgIdx]->rrmPolicyRatio, sizeof(RrmPolicyRatio)); + } + MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cfgReq->listOfSliceCfg[cfgIdx], sizeof(MacSliceRrmPolicy)); + } + MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cfgReq->listOfSliceCfg, cfgReq->numOfConfiguredSlice * sizeof(MacSliceRrmPolicy*)); + } + MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cfgReq, sizeof(MacSliceCfgReq)); + } +} +/** + * @brief fill Mac Slice Config Rsp + * + * @details + * + * Function : fillMacSliceCfgRsp + * + * This function fill Mac Slice Config Rsp + * + * @param[in] SchSliceCfgRsp *sliceCfgRsp, MacSliceCfgRsp *macSliceCfgRsp, + * uint8_t *count + * @return int + * -# ROK + **/ +uint8_t fillMacSliceCfgRsp(SchSliceCfgRsp *schSliceCfgRsp, MacSliceCfgRsp *macSliceCfgRsp) +{ + + bool sliceFound = false; + uint8_t cfgIdx = 0; + + macSliceCfgRsp->numSliceCfgRsp = schSliceCfgRsp->numSliceCfgRsp; + MAC_ALLOC_SHRABL_BUF(macSliceCfgRsp->listOfSliceCfgRsp, macSliceCfgRsp->numSliceCfgRsp* sizeof(MacSliceRsp*)); + if(macSliceCfgRsp->listOfSliceCfgRsp == NULLP) + { + DU_LOG("\nERROR --> MAC : Memory allocation failedi in fillMacSliceCfgRsp"); + return RFAILED; + } + + for(cfgIdx = 0; cfgIdxnumSliceCfgRsp; cfgIdx++) + { + sliceFound = false; + if(schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->rsp == RSP_OK) + { + sliceFound = true; + } + + MAC_ALLOC_SHRABL_BUF(macSliceCfgRsp->listOfSliceCfgRsp[cfgIdx], sizeof(SliceRsp)); + if(macSliceCfgRsp->listOfSliceCfgRsp[cfgIdx] == NULLP) + { + DU_LOG("\nERROR --> MAC : Memory allocation failedi in fillMacSliceCfgRsp"); + return RFAILED; + } + + macSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->snssai = schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->snssai; + if(sliceFound == true) + macSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->rsp = MAC_DU_APP_RSP_OK; + else + { + macSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->rsp = MAC_DU_APP_RSP_NOK; + macSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->cause = SLICE_NOT_PRESENT; + } + } + return ROK; +} + +/** + * @brief send slice cfg response to duapp. + * + * @details + * + * Function : MacSendSliceConfigRsp + * + * sends slice cfg response to duapp + * + * @param[in] MacSliceCfgRsp macSliceCfgRsp + * @return int + * -# ROK + **/ +uint8_t MacSendSliceConfigRsp(MacSliceCfgRsp *macSliceCfgRsp) +{ + Pst rspPst; + + memset(&rspPst, 0, sizeof(Pst)); + FILL_PST_MAC_TO_DUAPP(rspPst, EVENT_MAC_SLICE_CFG_RSP); + return (*macDuSliceCfgRspOpts[rspPst.selector])(&rspPst, macSliceCfgRsp); + +} +/** + * @brief free the slice cfg rsp received from sch. + * + * @details + * + * Function : freeSchSliceCfgRsp + * + * This free the slice cfg rsp received from sch + * + * @param[in] SchSliceCfgRsp *sliceCfgrsp + * @return int + * -# ROK + **/ +void freeSchSliceCfgRsp(SchSliceCfgRsp *schSliceCfgRsp) +{ + uint8_t cfgIdx = 0; + + if(schSliceCfgRsp) + { + if(schSliceCfgRsp->numSliceCfgRsp) + { + for(cfgIdx = 0; cfgIdx< schSliceCfgRsp->numSliceCfgRsp; cfgIdx++) + { + MAC_FREE(schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx], sizeof(SliceRsp)); + } + MAC_FREE(schSliceCfgRsp->listOfSliceCfgRsp, schSliceCfgRsp->numSliceCfgRsp * sizeof(SliceRsp*)); + } + } +} + +/** + * @brief Mac process the slice cfg rsp received from sch. + * + * @details + * + * Function : MacProcSchSliceCfgRsp + * + * This function process the slice cfg rsp received from sch + * + * @param[in] Pst *pst + * @param[in] SchSliceCfgRsp *sliceCfgrsp + * @return int + * -# ROK + **/ +uint8_t MacProcSchSliceCfgRsp(Pst *pst, SchSliceCfgRsp *schSliceCfgRsp) +{ + MacSliceCfgRsp *macSliceCfgRsp = NULLP; + + if(schSliceCfgRsp) + { + MAC_ALLOC_SHRABL_BUF(macSliceCfgRsp, sizeof(MacSliceCfgRsp)); + if(macSliceCfgRsp == NULLP) + { + DU_LOG("\nERROR --> MAC : Failed to allocate memory in MacProcSchSliceCfgRsp"); + return RFAILED; + } + if(schSliceCfgRsp->listOfSliceCfgRsp) + { + if(fillMacSliceCfgRsp(schSliceCfgRsp, macSliceCfgRsp) != ROK) + { + DU_LOG("\nERROR --> MAC : Failed to fill the slice cfg response"); + return RFAILED; + } + MacSendSliceConfigRsp(macSliceCfgRsp); + } + freeSchSliceCfgRsp(schSliceCfgRsp); + } + return ROK; +} + +/** +* @brief send slice cfg response to duapp. +* +* @details +* +* Function : MacSendSliceReconfigRsp +* +* sends slice cfg response to duapp +* +* @param[in] MacSliceCfgRsp macSliceRecfgRsp +* @return int +* -# ROK +**/ +uint8_t MacSendSliceReconfigRsp(MacSliceCfgRsp *macSliceRecfgRsp) +{ + Pst rspPst; + + memset(&rspPst, 0, sizeof(Pst)); + FILL_PST_MAC_TO_DUAPP(rspPst, EVENT_MAC_SLICE_RECFG_RSP); + return (*macDuSliceReCfgRspOpts[rspPst.selector])(&rspPst, macSliceRecfgRsp); + +} + +/** + * @brief Mac process the slice cfg rsp received from sch. + * + * @details + * + * Function : MacProcSchSliceReCfgRsp + * + * This function process the slice cfg rsp received from sch + * + * @param[in] Pst *pst + * @param[in] SchSliceCfgRsp *schSliceRecfgRsp + * @return int + * -# ROK + **/ +uint8_t MacProcSchSliceReCfgRsp(Pst *pst, SchSliceCfgRsp *schSliceRecfgRsp) +{ + MacSliceCfgRsp *macSliceReCfgRsp = NULLP; + + if(schSliceRecfgRsp) + { + MAC_ALLOC_SHRABL_BUF(macSliceReCfgRsp, sizeof(MacSliceCfgRsp)); + if(macSliceReCfgRsp == NULLP) + { + DU_LOG("\nERROR --> MAC : Failed to allocate memory in MacProcSchSliceReCfgRsp"); + return RFAILED; + } + + if(schSliceRecfgRsp->listOfSliceCfgRsp) + { + if(fillMacSliceCfgRsp(schSliceRecfgRsp, macSliceReCfgRsp) != ROK) + { + DU_LOG("\nERROR --> MAC : Failed to fill the slice Recfg response"); + return RFAILED; + } + MacSendSliceReconfigRsp(macSliceReCfgRsp); + } + freeSchSliceCfgRsp(schSliceRecfgRsp); + } + return ROK; +} + +/** + * @brief Mac process the downlink pcch indication received from DUAPP + * + * @details + * + * Function : MacProcDlPcchInd + * + * This function process the downlink pcch indication received from DUAPP + * + * @param[in] Pst *pst + * @param[in] MacPcchInd *pcchInd + * @return int + * -# ROK + **/ +uint8_t MacProcDlPcchInd(Pst *pst, MacPcchInd *pcchInd) +{ + uint8_t ret = RFAILED; + uint16_t cellIdx = 0; + Pst schPst; + SchPageInd *schPageInd = NULLP; + + if(pcchInd) + { + DU_LOG("\nINFO --> MAC : Received DL PCCH IND from DU_APP for cellId[%d]", pcchInd->cellId); + + GET_CELL_IDX(pcchInd->cellId, cellIdx); + + if(macCb.macCell[cellIdx] == NULLP || macCb.macCell[cellIdx]->cellId != pcchInd->cellId) + { + DU_LOG("\nERROR --> MAC : MacProcDlPcchInd(): CellId[%d] does not exist", pcchInd->cellId); + } + else + { + if((pcchInd->pcchPdu == NULLP) || (pcchInd->pduLen <= 0)) + { + DU_LOG("\nERROR --> MAC : MacProcDlPcchInd(): Received Pcch pdu is null"); + } + else + { + MAC_ALLOC(schPageInd, sizeof(SchPageInd)); + if(schPageInd == NULLP) + { + DU_LOG("\nERROR --> MAC : MacProcDlPcchInd(): Failed to allocate memory"); + } + else + { + schPageInd->cellId = pcchInd->cellId; + schPageInd->pf = pcchInd->pf; + schPageInd->i_s = pcchInd->i_s; + schPageInd->pduLen = pcchInd->pduLen; + + MAC_ALLOC(schPageInd->pagePdu, pcchInd->pduLen); + if(schPageInd->pagePdu == NULLP) + { + DU_LOG("\nERROR --> MAC : MacProcDlPcchInd(): Failed to allocate memory"); + MAC_FREE(schPageInd, sizeof(SchPageInd)); + } + else + { + memcpy(schPageInd->pagePdu, pcchInd->pcchPdu, pcchInd->pduLen); + + FILL_PST_MAC_TO_SCH(schPst, EVENT_PAGING_IND_TO_SCH); + ret = (*macSchPagingIndOpts[schPst.selector])(&schPst, schPageInd); + } + } + } + } + if((pcchInd->pcchPdu) && (pcchInd->pduLen > 0)) + { + MAC_FREE_SHRABL_BUF(pst->region, pst->pool, pcchInd->pcchPdu, pcchInd->pduLen); + } + MAC_FREE_SHRABL_BUF(pst->region, pst->pool, pcchInd, sizeof(MacPcchInd)); + } + else + { + DU_LOG("\nERROR --> MAC : MacProcDlPcchInd(): Received Null pointer"); + } + return ret; +} /********************************************************************** End of file **********************************************************************/