X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrmac%2Fmac_cfg_hdl.c;h=3544c12dbbfeb8ba6936542d696c55ca3e1db6b3;hb=6dc8a4c17da24847b3a3aee91b37151f77a8a5bc;hp=69591c48849cdabd06aa2b763501ca0b2f27c103;hpb=f3638e5eecd563d0a02488afe54a6bf19b52ffad;p=o-du%2Fl2.git diff --git a/src/5gnrmac/mac_cfg_hdl.c b/src/5gnrmac/mac_cfg_hdl.c index 69591c488..3544c12db 100644 --- a/src/5gnrmac/mac_cfg_hdl.c +++ b/src/5gnrmac/mac_cfg_hdl.c @@ -63,6 +63,20 @@ MacDuSliceRecfgRspFunc macDuSliceRecfgRspOpts[] = packDuMacSliceRecfgRsp /* packing for light weight loosly coupled */ }; +MacDuStatsRspFunc macDuStatsRspOpts[] = +{ + packDuMacStatsRsp, /* packing for loosely coupled */ + DuProcMacStatsRsp, /* packing for tightly coupled */ + packDuMacStatsRsp /* packing for light weight loosly coupled */ +}; + +MacDuStatsDeleteRspFunc macDuStatsDeleteRspOpts[] = +{ + packDuMacStatsDeleteRsp, /* packing for loosely coupled */ + DuProcMacStatsDeleteRsp, /* packing for tightly coupled */ + packDuMacStatsDeleteRsp /* packing for light weight loosly coupled */ +}; + /** * @brief Layer Manager Configuration request handler for Scheduler * @@ -135,7 +149,7 @@ uint8_t SchSendCfgCfm(Pst *pst, RgMngmt *cfm) uint8_t MacProcCellCfgReq(Pst *pst, MacCellCfg *macCellCfg) { Pst cfmPst; - uint16_t cellIdx; + uint16_t cellIdx, scsInKhz = 0; uint8_t ret = ROK, plmnIdx = 0,sliceIdx = 0; MacCellCb *macCellCb; @@ -152,7 +166,11 @@ uint8_t MacProcCellCfgReq(Pst *pst, MacCellCfg *macCellCfg) GET_CELL_IDX(macCellCfg->cellId, cellIdx); macCb.macCell[cellIdx] = macCellCb; macCb.macCell[cellIdx]->cellId = macCellCfg->cellId; - macCb.macCell[cellIdx]->numOfSlots = 10 * (1 << macCellCfg->cellCfg.numerology); + scsInKhz = convertScsEnumValToScsVal(macCellCfg->cellCfg.subCarrSpacing); + + /*Ref : 3GPP 38.211 Table 4.2-1: SCS = (2 ^ numerology * 15kHz)*/ + macCb.macCell[cellIdx]->numerology = log2(scsInKhz/BASE_SCS); + macCb.macCell[cellIdx]->numOfSlots = 10 * (1 << (macCb.macCell[cellIdx]->numerology)); memcpy(&macCb.macCell[cellIdx]->macCellCfg, macCellCfg, sizeof(MacCellCfg)); MAC_ALLOC(macCb.macCell[cellIdx]->macCellCfg.cellCfg.sib1Cfg.sib1Pdu, \ @@ -268,50 +286,50 @@ uint8_t MacSchCellCfgReq(Pst *pst, MacCellCfg *macCellCfg) } schCellCfg.dupMode = macCellCfg->cellCfg.dupType; - schCellCfg.numerology = macCellCfg->cellCfg.numerology; schCellCfg.dlBandwidth = macCellCfg->carrCfg.dlBw; schCellCfg.ulBandwidth = macCellCfg->carrCfg.ulBw; schCellCfg.dlCfgCommon.schFreqInfoDlSib.offsetToPointA = macCellCfg->ssbCfg.ssbOffsetPointA; + schCellCfg.dlCfgCommon.schFreqInfoDlSib.schSpcCarrier[0].subCarrierSpacing = macCellCfg->ssbCfg.scsCmn; /* fill initial DL BWP */ - schCellCfg.dlCfgCommon.schInitialDlBwp.bwp.freqAlloc.startPrb = macCellCfg->initialDlBwp.bwp.firstPrb; - schCellCfg.dlCfgCommon.schInitialDlBwp.bwp.freqAlloc.numPrb = macCellCfg->initialDlBwp.bwp.numPrb; - schCellCfg.dlCfgCommon.schInitialDlBwp.bwp.scs = macCellCfg->initialDlBwp.bwp.scs; - schCellCfg.dlCfgCommon.schInitialDlBwp.bwp.cyclicPrefix = macCellCfg->initialDlBwp.bwp.cyclicPrefix; + schCellCfg.dlCfgCommon.schInitialDlBwp.bwp.freqAlloc.startPrb = macCellCfg->cellCfg.initialDlBwp.bwp.firstPrb; + schCellCfg.dlCfgCommon.schInitialDlBwp.bwp.freqAlloc.numPrb = macCellCfg->cellCfg.initialDlBwp.bwp.numPrb; + schCellCfg.dlCfgCommon.schInitialDlBwp.bwp.scs = macCellCfg->cellCfg.initialDlBwp.bwp.scs; + schCellCfg.dlCfgCommon.schInitialDlBwp.bwp.cyclicPrefix = macCellCfg->cellCfg.initialDlBwp.bwp.cyclicPrefix; schCellCfg.dlCfgCommon.schInitialDlBwp.pdcchCommon.commonSearchSpace.searchSpaceId = - macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.searchSpaceId; + macCellCfg->cellCfg.initialDlBwp.pdcchCommon.commonSearchSpace.searchSpaceId; schCellCfg.dlCfgCommon.schInitialDlBwp.pdcchCommon.commonSearchSpace.coresetId = - macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.coresetId; + macCellCfg->cellCfg.initialDlBwp.pdcchCommon.commonSearchSpace.coresetId; schCellCfg.dlCfgCommon.schInitialDlBwp.pdcchCommon.commonSearchSpace.monitoringSlot = - macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.monitoringSlot; + macCellCfg->cellCfg.initialDlBwp.pdcchCommon.commonSearchSpace.monitoringSlot; schCellCfg.dlCfgCommon.schInitialDlBwp.pdcchCommon.commonSearchSpace.duration = - macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.duration; + macCellCfg->cellCfg.initialDlBwp.pdcchCommon.commonSearchSpace.duration; schCellCfg.dlCfgCommon.schInitialDlBwp.pdcchCommon.commonSearchSpace.monitoringSymbol = - macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.monitoringSymbol; + macCellCfg->cellCfg.initialDlBwp.pdcchCommon.commonSearchSpace.monitoringSymbol; schCellCfg.dlCfgCommon.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel1 = - macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel1; + macCellCfg->cellCfg.initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel1; schCellCfg.dlCfgCommon.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel2 = - macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel2; + macCellCfg->cellCfg.initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel2; schCellCfg.dlCfgCommon.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel4 = - macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel4; + macCellCfg->cellCfg.initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel4; schCellCfg.dlCfgCommon.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel8 = - macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel8; + macCellCfg->cellCfg.initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel8; schCellCfg.dlCfgCommon.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel16 = - macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel16; + macCellCfg->cellCfg.initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel16; - schCellCfg.dlCfgCommon.schInitialDlBwp.pdschCommon.numTimeDomAlloc = macCellCfg->initialDlBwp.pdschCommon.numTimeDomAlloc; - for(rsrcListIdx = 0; rsrcListIdxinitialDlBwp.pdschCommon.numTimeDomAlloc; rsrcListIdx++) + schCellCfg.dlCfgCommon.schInitialDlBwp.pdschCommon.numTimeDomAlloc = macCellCfg->cellCfg.initialDlBwp.pdschCommon.numTimeDomAlloc; + for(rsrcListIdx = 0; rsrcListIdxcellCfg.initialDlBwp.pdschCommon.numTimeDomAlloc; rsrcListIdx++) { schCellCfg.dlCfgCommon.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].k0 = - macCellCfg->initialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].k0; + macCellCfg->cellCfg.initialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].k0; schCellCfg.dlCfgCommon.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].mappingType = - macCellCfg->initialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].mappingType; + macCellCfg->cellCfg.initialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].mappingType; schCellCfg.dlCfgCommon.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].startSymbol = - macCellCfg->initialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].startSymbol; + macCellCfg->cellCfg.initialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].startSymbol; schCellCfg.dlCfgCommon.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].lengthSymbol = - macCellCfg->initialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].lengthSymbol; + macCellCfg->cellCfg.initialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].lengthSymbol; } /* fill SIB1 scheduler parameters */ @@ -323,10 +341,10 @@ uint8_t MacSchCellCfgReq(Pst *pst, MacCellCfg *macCellCfg) } /* fill initial UL BWP */ - schCellCfg.ulCfgCommon.schInitialUlBwp.bwp.freqAlloc.startPrb = macCellCfg->initialUlBwp.bwp.firstPrb; - schCellCfg.ulCfgCommon.schInitialUlBwp.bwp.freqAlloc.numPrb = macCellCfg->initialUlBwp.bwp.numPrb; - schCellCfg.ulCfgCommon.schInitialUlBwp.bwp.scs = macCellCfg->initialUlBwp.bwp.scs; - schCellCfg.ulCfgCommon.schInitialUlBwp.bwp.cyclicPrefix = macCellCfg->initialUlBwp.bwp.cyclicPrefix; + schCellCfg.ulCfgCommon.schInitialUlBwp.bwp.freqAlloc.startPrb = macCellCfg->cellCfg.initialUlBwp.bwp.firstPrb; + schCellCfg.ulCfgCommon.schInitialUlBwp.bwp.freqAlloc.numPrb = macCellCfg->cellCfg.initialUlBwp.bwp.numPrb; + schCellCfg.ulCfgCommon.schInitialUlBwp.bwp.scs = macCellCfg->cellCfg.initialUlBwp.bwp.scs; + schCellCfg.ulCfgCommon.schInitialUlBwp.bwp.cyclicPrefix = macCellCfg->cellCfg.initialUlBwp.bwp.cyclicPrefix; /* fill RACH config params */ schCellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.prachCfgGeneric.prachCfgIdx = macCellCfg->prachCfg.prachCfgIdx; schCellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.prachCfgGeneric.msg1Fdm = macCellCfg->prachCfg.msg1Fdm; @@ -345,21 +363,21 @@ uint8_t MacSchCellCfgReq(Pst *pst, MacCellCfg *macCellCfg) macCellCfg->prachCfg.prachSubcSpacing; schCellCfg.ulCfgCommon.schInitialUlBwp.pucchCommon.pucchResourceCommon = \ - macCellCfg->initialUlBwp.pucchCommon.pucchResourceCommon; + macCellCfg->cellCfg.initialUlBwp.pucchCommon.pucchResourceCommon; schCellCfg.ulCfgCommon.schInitialUlBwp.pucchCommon.pucchGroupHopping = \ - macCellCfg->initialUlBwp.pucchCommon.pucchGroupHopping; + macCellCfg->cellCfg.initialUlBwp.pucchCommon.pucchGroupHopping; schCellCfg.ulCfgCommon.schInitialUlBwp.puschCommon.numTimeDomRsrcAlloc = \ - macCellCfg->initialUlBwp.puschCommon.numTimeDomRsrcAlloc; - for(rsrcListIdx = 0; rsrcListIdx < macCellCfg->initialUlBwp.puschCommon.numTimeDomRsrcAlloc; rsrcListIdx++) + macCellCfg->cellCfg.initialUlBwp.puschCommon.numTimeDomRsrcAlloc; + for(rsrcListIdx = 0; rsrcListIdx < macCellCfg->cellCfg.initialUlBwp.puschCommon.numTimeDomRsrcAlloc; rsrcListIdx++) { schCellCfg.ulCfgCommon.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].k2 = - macCellCfg->initialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].k2; + macCellCfg->cellCfg.initialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].k2; schCellCfg.ulCfgCommon.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].mappingType = - macCellCfg->initialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].mappingType; + macCellCfg->cellCfg.initialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].mappingType; schCellCfg.ulCfgCommon.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].startSymbol = - macCellCfg->initialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].startSymbol; + macCellCfg->cellCfg.initialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].startSymbol; schCellCfg.ulCfgCommon.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].symbolLength = - macCellCfg->initialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].symbolLength; + macCellCfg->cellCfg.initialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].symbolLength; } #ifdef NR_TDD @@ -371,10 +389,10 @@ uint8_t MacSchCellCfgReq(Pst *pst, MacCellCfg *macCellCfg) { schCellCfg.ssbPosInBurst[ssbMaskIdx] = macCellCfg->ssbCfg.ssbMask[ssbMaskIdx]; } - schCellCfg.ssbPeriod = ssbPeriodicity[macCellCfg->ssbCfg.ssbPeriod]; + schCellCfg.ssbPeriod = ssbPeriodicity[macCellCfg->ssbCfg.ssbPeriod]; schCellCfg.ssbFrequency = macCellCfg->cellCfg.ssbFreq; schCellCfg.dmrsTypeAPos = macCellCfg->ssbCfg.dmrsTypeAPos; - schCellCfg.scsCommon = macCellCfg->ssbCfg.scsCmn; + schCellCfg.ssbScs = macCellCfg->cellCfg.subCarrSpacing; schCellCfg.pdcchCfgSib1.coresetZeroIndex = macCellCfg->cellCfg.sib1Cfg.pdcchCfgSib1.coresetZeroIndex; schCellCfg.pdcchCfgSib1.searchSpaceZeroIndex = macCellCfg->cellCfg.sib1Cfg.pdcchCfgSib1.searchSpaceZeroIndex; schCellCfg.ssbPbchPwr = macCellCfg->ssbCfg.ssbPbchPwr; @@ -500,7 +518,7 @@ void fapiMacConfigRsp(uint16_t cellId) * RFAILED - failure * * ****************************************************************/ -uint8_t MacSendCellDeleteRsp(CellDeleteStatus result, uint8_t cellId) +uint8_t MacSendCellDeleteRsp(CauseOfResult status, uint8_t cellId) { MacCellDeleteRsp *deleteRsp=NULLP; Pst rspPst; @@ -516,7 +534,7 @@ uint8_t MacSendCellDeleteRsp(CellDeleteStatus result, uint8_t cellId) memset(deleteRsp, 0, sizeof(MacCellDeleteRsp)); deleteRsp->cellId = cellId; - deleteRsp->result = result; + deleteRsp->status = status; /* Fill Post structure and send CELL delete response*/ memset(&rspPst, 0, sizeof(Pst)); @@ -545,7 +563,7 @@ uint8_t MacProcSchCellDeleteRsp(Pst *pst, SchCellDeleteRsp *schCellDelRsp) { uint8_t ret = ROK, sliceIdx = 0, plmnIdx = 0; uint16_t cellIdx=0; - CellDeleteStatus status; + CauseOfResult cause; #ifdef CALL_FLOW_DEBUG_LOG DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_CELL_DELETE_RSP_TO_MAC\n"); @@ -562,7 +580,7 @@ uint8_t MacProcSchCellDeleteRsp(Pst *pst, SchCellDeleteRsp *schCellDelRsp) { if(macCb.macCell[cellIdx]->cellId == schCellDelRsp->cellId) { - status = SUCCESSFUL_RSP; + cause = SUCCESSFUL; for(plmnIdx = 0; plmnIdx < MAX_PLMN; plmnIdx++) { if(macCb.macCell[cellIdx]->macCellCfg.cellCfg.plmnInfoList[plmnIdx].snssai) @@ -582,24 +600,24 @@ uint8_t MacProcSchCellDeleteRsp(Pst *pst, SchCellDeleteRsp *schCellDelRsp) else { DU_LOG("ERROR --> MAC : MacProcSchCellDeleteRsp(): CellId[%d] does not exists", schCellDelRsp->cellId); - status = CELL_ID_INVALID; + cause = CELLID_INVALID; ret = RFAILED; } } else { DU_LOG("ERROR --> MAC : MacProcSchCellDeleteRsp(): CellId[%d] does not exists", schCellDelRsp->cellId); - status = CELL_ID_INVALID; + cause = CELLID_INVALID; ret = RFAILED; } } else { DU_LOG("ERROR --> MAC : MacProcSchCellDeleteRsp(): CellId[%d] does not exists", schCellDelRsp->cellId); - status = CELL_ID_INVALID; + cause = CELLID_INVALID; ret = RFAILED; } - if(MacSendCellDeleteRsp(status, schCellDelRsp->cellId) != ROK) + if(MacSendCellDeleteRsp(cause, schCellDelRsp->cellId) != ROK) { DU_LOG("\nERROR --> MAC: MacProcSchCellDeleteRsp(): Failed to send CELL delete response"); ret = RFAILED; @@ -693,7 +711,7 @@ uint8_t MacProcCellDeleteReq(Pst *pst, MacCellDeleteReq *cellDelete) if(ret == RFAILED) { DU_LOG("\nERROR --> MAC : MacProcCellDeleteReq(): Sending failure response to DU"); - if(MacSendCellDeleteRsp(CELL_ID_INVALID, cellDelete->cellId) != ROK) + if(MacSendCellDeleteRsp(CELLID_INVALID, cellDelete->cellId) != ROK) { DU_LOG("\nERROR --> MAC : MacProcCellDeleteReq(): failed to send cell delete rsp for cellID[%d]",\ cellDelete->cellId); @@ -961,6 +979,494 @@ uint8_t MacProcDlPcchInd(Pst *pst, DlPcchInd *pcchInd) } return ret; } + +/** + * @brief Mac process the downlink Broadcast Req received from DUAPP + * + * @details + * + * Function : MacProcDlBroadcastReq + * + * This function process the downlink Broadcast Req received from DUAPP + * + * @param[in] Pst *pst + * @param[in] DlBroadcastReq *dlBroadcastReq + * @return int + * -# ROK + **/ +uint8_t MacProcDlBroadcastReq(Pst *pst, MacDlBroadcastReq *dlBroadcastReq) +{ + uint8_t ret = ROK, idx=0; + uint16_t cellIdx = 0; + + if(dlBroadcastReq) + { + DU_LOG("\nINFO --> MAC : Received DL braodcast req from DU_APP for cellId[%d]", dlBroadcastReq->cellId); + + GET_CELL_IDX(dlBroadcastReq->cellId, cellIdx); + + if(macCb.macCell[cellIdx] == NULLP || macCb.macCell[cellIdx]->cellId != dlBroadcastReq->cellId) + { + ret = RFAILED; + DU_LOG("\nERROR --> MAC : MacProcDlBroadcastReq(): CellId[%d] does not exist", dlBroadcastReq->cellId); + } + else + { + /*TODO - Complete the processing of DL Broadcast Request*/ + } + for(idx = 0; idxnumSiBlock; idx++) + { + MAC_FREE_SHRABL_BUF(pst->region, pst->pool, dlBroadcastReq->siSchedulingInfo[idx]->siAreaID, sizeof(uint8_t)); + MAC_FREE_SHRABL_BUF(pst->region, pst->pool, dlBroadcastReq->siSchedulingInfo[idx], sizeof(SiSchedulingInfo)); + } + MAC_FREE_SHRABL_BUF(pst->region, pst->pool, dlBroadcastReq, sizeof(MacDlBroadcastReq)); + } + else + { + ret = RFAILED; + DU_LOG("\nERROR --> MAC : MacProcDlBroadcastReq(): Received Null pointer"); + } + return ret; +} + +/** + * @brief Fill and send statistics response to DU APP + * + * @details + * + * Function : MacSendStatsRspToDuApp + * + * Fill and send statistics response to DU APP + * + * @param[in] Response + * @param[in] Cause of response + * @return int + * -# ROK + **/ +uint8_t MacSendStatsRspToDuApp(MacStatsRsp *statsRsp) +{ + uint8_t ret = ROK; + Pst pst; + MacStatsRsp *macStatsRsp = NULLP; + + DU_LOG("\nINFO --> MAC : MacSendStatsRspToDuApp: Sending Statistics Response to DU APP"); + + /* Workaround : To skip corrupted memory, allocating a pointer that will + * remain unused */ + uint8_t *dummyPtr = NULLP; + MAC_ALLOC_SHRABL_BUF(dummyPtr, sizeof(uint8_t)); + + MAC_ALLOC_SHRABL_BUF(macStatsRsp, sizeof(MacStatsRsp)); + if(macStatsRsp == NULLP) + { + DU_LOG("\nERROR --> MAC : Failed to allocate memory in MacProcSchStatsRsp"); + ret = RFAILED; + } + else + { + memcpy(macStatsRsp, statsRsp, sizeof(MacStatsRsp)); + memset(statsRsp, 0, sizeof(MacStatsRsp)); + + memset(&pst, 0, sizeof(Pst)); + FILL_PST_MAC_TO_DUAPP(pst, EVENT_MAC_STATISTICS_RSP); + if(((*macDuStatsRspOpts[pst.selector])(&pst, macStatsRsp))!= ROK) + { + DU_LOG("\nERROR --> MAC : Failed to send statistics response to DU APP"); + MAC_FREE_SHRABL_BUF(MAC_MEM_REGION, MAC_POOL, macStatsRsp, sizeof(MacStatsRsp)); + ret = RFAILED; + } + } + + /* Workaround : Freeing the dummy pointer */ + MAC_FREE_SHRABL_BUF(MAC_MEM_REGION, MAC_POOL, dummyPtr, sizeof(uint8_t)); + return ret; +} + +/******************************************************************* + * + * @brief Rejects all statistics group requested by DU APP + * + * @details + * + * Function : MacRejectAllStats + * + * Functionality: Add all statistics group received in statistics + * request from DU APP, to Reject-Stats-Group-List in statistics + * response to DU APP + * + * @params[in] Statistics request from DU APP + * Cause of rejection + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t MacRejectAllStats(MacStatsReq *macStatsReq, CauseOfResult cause) +{ + uint8_t grpIdx = 0; + MacStatsRsp macStatsRsp; + + memset(&macStatsRsp, 0, sizeof(MacStatsRsp)); + + /* Copying all stats group from stats request to stats response */ + macStatsRsp.subscriptionId = macStatsReq->subscriptionId; + for(grpIdx = 0; grpIdx < macStatsReq->numStatsGroup; grpIdx++) + { + macStatsRsp.statsGrpRejectedList[grpIdx].groupId = macStatsReq->statsGrpList[grpIdx].groupId; + macStatsRsp.statsGrpRejectedList[grpIdx].cause = cause; + } + macStatsRsp.numGrpRejected = macStatsReq->numStatsGroup; + + return MacSendStatsRspToDuApp(&macStatsRsp); +} + +/** + * @brief Mac process the statistics Req received from DUAPP + * + * @details + * + * Function : MacProcStatsReq + * + * This function process the statistics request from duapp: + * [Step 1] Basic validation. If fails, all stats group in stats request are + * rejected. + * [Step 2] If basic validations passed, traverse all stats group and + * validate each measurement types in each group. + * [Step 3] If any measurement type validation fails in a group, that group + * is not configured and it is added to stats-group-rejected-list in + * mac-stats-response message. + * [Step 4] Even if one group passes all validation, it is sent to SCH in + * statistics request. The mac-stats-response message is added to + * pending-response list. This will be sent to DU APP after stats response + * is received from SCH. + * [Step 5] If none of the groups passes all validation, mac-stats-response + * is sent to du app with all group as part of stats-group-rejected-list. + * + * @param[in] Pst *pst + * @param[in] StatsReq *statsReq + * @return int + * -# ROK + **/ +uint8_t MacProcStatsReq(Pst *pst, MacStatsReq *macStatsReq) +{ + uint8_t macStatsGrpIdx = 0, macStatsIdx = 0, schStatsGrpIdx = 0, schStatsIdx = 0; + uint8_t ret = RFAILED; + bool measTypeInvalid = false; + Pst schPst; + MacStatsGrpInfo *macStatsGrp = NULLP; + SchStatsReq *schStatsReq = NULLP; + MacStatsRsp *macStatsRsp = NULLP; + + DU_LOG("\nINFO --> MAC : Received Statistics Request from DU_APP"); + + if(macStatsReq == NULLP) + { + DU_LOG("\nERROR --> MAC : MacProcStatsReq(): Received Null pointer"); + return RFAILED; + } + + /* [Step 1] Basic validation. If fails, statistics response is sent to DU APP + * that rejectes all stats */ + + /* If number of statistics request for which response is still pending + * towards DU APP has reached its maximum limit */ + if(macCb.statistics.numPendingStatsRsp >= MAX_PENDING_STATS_RSP) + { + DU_LOG("\nERROR --> MAC : MacProcStatsReq: Maximum number of statistics response is pending. \ + Cannot process new request."); + MacRejectAllStats(macStatsReq, RESOURCE_UNAVAILABLE); + MAC_FREE_SHRABL_BUF(pst->region, pst->pool, macStatsReq, sizeof(MacStatsReq)); + return RFAILED; + } + + /* If memory resources are unavailable */ + MAC_ALLOC(schStatsReq, sizeof(SchStatsReq)); + if(schStatsReq == NULLP) + { + DU_LOG("\nERROR --> MAC : MacProcStatsReq: Failed to allocate memory"); + MacRejectAllStats(macStatsReq, RESOURCE_UNAVAILABLE); + MAC_FREE_SHRABL_BUF(pst->region, pst->pool, macStatsReq, sizeof(MacStatsReq)); + return RFAILED; + } + + /* Add stats response to pending response list */ + macStatsRsp = &macCb.statistics.pendingStatsRsp[macCb.statistics.numPendingStatsRsp]; + memset(macStatsRsp, 0, sizeof(MacStatsRsp)); + + /* [Step 2] Traverse all stats group and validate each measurement types in each group */ + schStatsReq->subscriptionId = macStatsReq->subscriptionId; + schStatsReq->numStatsGroup = 0; + for(macStatsGrpIdx = 0; macStatsGrpIdx < macStatsReq->numStatsGroup; macStatsGrpIdx++) + { + measTypeInvalid = false; + schStatsIdx = 0; + macStatsGrp = &macStatsReq->statsGrpList[macStatsGrpIdx]; + + for(macStatsIdx=0; macStatsIdx < macStatsGrp->numStats; macStatsIdx++) + { + /* Validate each measurement type */ + switch(macStatsGrp->statsList[macStatsIdx]) + { + case MAC_DL_TOTAL_PRB_USAGE: + { + schStatsReq->statsGrpList[schStatsGrpIdx].statsList[schStatsIdx] = SCH_DL_TOTAL_PRB_USAGE; + break; + } + case MAC_UL_TOTAL_PRB_USAGE: + { + schStatsReq->statsGrpList[schStatsGrpIdx].statsList[schStatsIdx] = SCH_UL_TOTAL_PRB_USAGE; + break; + } + default: + { + DU_LOG("\nERROR --> MAC : MacProcStatsReq: Invalid measurement type [%d]", \ + macStatsGrp->statsList[macStatsIdx]); + measTypeInvalid = true; + } + } + + /* Even if one measurement type is invalid, this group is rejected */ + if(measTypeInvalid) + { + memset(&schStatsReq->statsGrpList[schStatsGrpIdx], 0, sizeof(SchStatsGrpInfo)); + break; + } + + schStatsIdx++; + } + + /* If all measurement type is valid, add group info to send to SCH */ + if(!measTypeInvalid) + { + schStatsReq->statsGrpList[schStatsGrpIdx].groupId = macStatsGrp->groupId; + schStatsReq->statsGrpList[schStatsGrpIdx].periodicity = macStatsGrp->periodicity; + schStatsReq->statsGrpList[schStatsGrpIdx].numStats = schStatsIdx; + schStatsGrpIdx++; + } + else + { + /* [Step 3] If any measurement type validation fails in a group, that group + * is not configured and it is added to stats-group-rejected-list in + * mac-stats-response message */ + macStatsRsp->statsGrpRejectedList[macStatsRsp->numGrpRejected].groupId = macStatsGrp->groupId; + macStatsRsp->statsGrpRejectedList[macStatsRsp->numGrpRejected].cause = PARAM_INVALID; + macStatsRsp->numGrpRejected++; + } + } + schStatsReq->numStatsGroup = schStatsGrpIdx; + + macStatsRsp->subscriptionId = macStatsReq->subscriptionId; + + if(schStatsReq->numStatsGroup) + { + /* [Step 4] Even if one group passes all validation, it is sent to SCH in + * statistics request. The mac-stats-response message is added to + * pending-response list. */ + macCb.statistics.numPendingStatsRsp++; + + FILL_PST_MAC_TO_SCH(schPst, EVENT_STATISTICS_REQ_TO_SCH); + ret = SchMessageRouter(&schPst, (void *)schStatsReq); + } + else + { + /* [Step 5] If none of the groups passes all validation, mac-stats-response + * is sent to du app with all group as part of stats-group-rejected-list. */ + DU_LOG("\nERROR --> MAC : MacProcStatsReq: All statistics group found invalid"); + MAC_FREE(schStatsReq, sizeof(SchStatsReq)); + ret = MacSendStatsRspToDuApp(macStatsRsp); + } + + MAC_FREE_SHRABL_BUF(pst->region, pst->pool, macStatsReq, sizeof(MacStatsReq)); + return ret; +} + +/** + * @brief Mac process the statistics rsp received from sch. + * + * @details + * + * Function : MacProcSchStatsRsp + * + * This function process the statistics response received from sch + * + * @param[in] Pst *pst + * @param[in] SchStatsRsp *schStatsRsp + * @return int + * -# ROK + **/ +uint8_t MacProcSchStatsRsp(Pst *pst, SchStatsRsp *schStatsRsp) +{ + uint8_t idx = 0, accptdIdx = 0, rjctdIdx = 0; + uint8_t ret = RFAILED; + MacStatsRsp *macStatsRsp = NULLP; + + if(schStatsRsp) + { + /* Fetch pointer to statistics response from pending list saved at MAC + * during processing statistics request from DU APP */ + for(idx = 0; idx < macCb.statistics.numPendingStatsRsp; idx++) + { + if(macCb.statistics.pendingStatsRsp[idx].subscriptionId == schStatsRsp->subscriptionId) + { + macStatsRsp = &macCb.statistics.pendingStatsRsp[idx]; + break; + } + } + + if(macStatsRsp == NULLP) + { + MAC_FREE(schStatsRsp, sizeof(SchStatsRsp)); + return RFAILED; + } + + /* Copy Stats-group-accpeted list received from SCH */ + for(accptdIdx = 0; accptdIdxnumGrpAccepted && macStatsRsp->numGrpAcceptedstatsGrpAcceptedList[macStatsRsp->numGrpAccepted++] = schStatsRsp->statsGrpAcceptedList[accptdIdx]; + } + + /* List together all stats group rejected by MAC and by SCH */ + for(rjctdIdx = 0; rjctdIdx < schStatsRsp->numGrpRejected && macStatsRsp->numGrpRejectedstatsGrpRejectedList[macStatsRsp->numGrpRejected].groupId = \ + schStatsRsp->statsGrpRejectedList[rjctdIdx].groupId; + macStatsRsp->statsGrpRejectedList[macStatsRsp->numGrpRejected].cause = \ + schStatsRsp->statsGrpRejectedList[rjctdIdx].cause; + macStatsRsp->numGrpRejected++; + } + + /* Send statistics response to DU APP */ + ret = MacSendStatsRspToDuApp(macStatsRsp); + } + MAC_FREE(schStatsRsp, sizeof(SchStatsRsp)); + return ret; +} + +/** + * @brief Fill and send statistics delete response to DU APP + * + * @details + * + * Function : MacSendStatsDeleteRspToDuApp + * + * Fill and send statistics delete response to DU APP + * + * @param[in] Response + * @param[in] Cause of response + * @return int + * -# ROK + **/ +uint8_t MacSendStatsDeleteRspToDuApp(uint64_t subscriptionId, MacRsp result, CauseOfResult status) +{ + uint8_t ret = ROK; + Pst pst; + MacStatsDeleteRsp *macStatsDeleteRsp = NULLP; + + DU_LOG("\nINFO --> MAC : MacSendStatsDeleteRspToDuApp: Sending Delete Statistics Response to DU APP"); + + MAC_ALLOC_SHRABL_BUF(macStatsDeleteRsp, sizeof(MacStatsDeleteRsp)); + if(macStatsDeleteRsp == NULLP) + { + DU_LOG("\nERROR --> MAC : Failed to allocate memory in MacSendStatsDeleteRspToDuApp"); + ret = RFAILED; + } + else + { + macStatsDeleteRsp->subscriptionId= subscriptionId; + macStatsDeleteRsp->result = result; + macStatsDeleteRsp->status = status; + memset(&pst, 0, sizeof(Pst)); + FILL_PST_MAC_TO_DUAPP(pst, EVENT_MAC_STATS_DELETE_RSP); + if(((*macDuStatsDeleteRspOpts[pst.selector])(&pst, macStatsDeleteRsp))!= ROK) + { + DU_LOG("\nERROR --> MAC : Failed to send statistics delete response to DU APP"); + MAC_FREE_SHRABL_BUF(MAC_MEM_REGION, MAC_POOL, macStatsDeleteRsp, sizeof(MacStatsDeleteRsp)); + ret = RFAILED; + } + } + + return ret; +} + +/** + * @brief Mac process the statistics delete rsp received from sch. + * + * @details + * + * Function : MacProcSchStatsDeleteRsp + * + * This function process the statistics delete response received from sch + * + * @param[in] Pst *pst + * @param[in] SchStatsDeleteRsp *schStatsDeleteRsp + * @return int + * -# ROK + **/ +uint8_t MacProcSchStatsDeleteRsp(Pst *pst, SchStatsDeleteRsp *schStatsDeleteRsp) +{ + uint8_t ret = RFAILED; + + if(schStatsDeleteRsp) + { + if(schStatsDeleteRsp->rsp == RSP_OK) + ret = MacSendStatsDeleteRspToDuApp(schStatsDeleteRsp->subscriptionId,MAC_DU_APP_RSP_OK,schStatsDeleteRsp->cause); + else + ret = MacSendStatsDeleteRspToDuApp(schStatsDeleteRsp->subscriptionId,MAC_DU_APP_RSP_NOK,schStatsDeleteRsp->cause); + + } + MAC_FREE(schStatsDeleteRsp, sizeof(SchStatsDeleteRsp)); + return ret; +} + +/** + * @brief Mac process the statistics delete Req received from DUAPP + * + * @details + * + * Function : MacProcStatsDeleteReq + * + * Functionality: Process the statistics delete request from duapp + * @param[in] Pst *pst + * @param[in] StatsDeleteReq *statsReq + * @return int + * -# ROK + **/ + +uint8_t MacProcStatsDeleteReq(Pst *pst, MacStatsDeleteReq *macStatsDeleteReq) +{ + Pst schPst; + uint8_t ret = RFAILED; + SchStatsDeleteReq *schStatsDeleteReq = NULLP; + + DU_LOG("\nINFO --> MAC : Received Statistics delete Request from DU_APP"); + + if(macStatsDeleteReq == NULLP) + { + DU_LOG("\nERROR --> MAC : MacProcStatsDeleteReq(): Received Null pointer"); + return RFAILED; + } + + MAC_ALLOC(schStatsDeleteReq, sizeof(SchStatsDeleteReq)); + if(schStatsDeleteReq == NULLP) + { + DU_LOG("\nERROR --> MAC : MacProcStatsDeleteReq: Failed to allocate memory"); + } + else + { + schStatsDeleteReq->subscriptionId = macStatsDeleteReq->subscriptionId; + FILL_PST_MAC_TO_SCH(schPst, EVENT_STATISTICS_DELETE_REQ_TO_SCH); + ret = SchMessageRouter(&schPst, (void *)schStatsDeleteReq); + } + + if(ret != ROK) + { + MAC_FREE(schStatsDeleteReq, sizeof(SchStatsDeleteReq)); + ret = MacSendStatsDeleteRspToDuApp(macStatsDeleteReq->subscriptionId , MAC_DU_APP_RSP_NOK, RESOURCE_UNAVAILABLE); + } + + MAC_FREE_SHRABL_BUF(pst->region, pst->pool, macStatsDeleteReq, sizeof(MacStatsDeleteReq)); + return ret; +} + /********************************************************************** End of file **********************************************************************/