X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrsch%2Fsch.c;h=8279bf6c6ac158b655b88159427ba9117dee0382;hb=2e3617064e27b8d7bb5ba74319f8c1c99491b8dd;hp=090d3896df6d055ceaa8ae5eed315231ebb08627;hpb=8e6123e23f6d831b1fe972f8229e9594a2e92237;p=o-du%2Fl2.git diff --git a/src/5gnrsch/sch.c b/src/5gnrsch/sch.c index 090d3896d..8279bf6c6 100644 --- a/src/5gnrsch/sch.c +++ b/src/5gnrsch/sch.c @@ -46,59 +46,29 @@ #include "rg_sch_inf.x" /* typedefs for Scheduler */ #include "mac_sch_interface.h" #include "sch.h" +#include "sch_tmr.h" #include "sch_utils.h" - -void SchFillCfmPst(Pst *reqPst,Pst *cfmPst,RgMngmt *cfm); - -/* local defines */ -SchCellCfgCfmFunc SchCellCfgCfmOpts[] = -{ - packSchCellCfgCfm, /* LC */ - MacProcSchCellCfgCfm, /* TC */ - packSchCellCfgCfm /* LWLC */ -}; - +#include "sch_fcfs.h" +#include "sch_slice_based.h" /** - * @brief Task Initiation function. + * @brief Scheduler All Apis initialized. * * @details * - * Function : schActvInit + * Function : schAllApisInit * - * This function is supplied as one of parameters during MAC's - * task registration. MAC will invoke this function once, after - * it creates and attaches this TAPA Task to a system task. + * This function initializes all Scheduler APIs/functionality for each kind + * of scheduler type. * - * @param[in] Ent Entity, the entity ID of this task. - * @param[in] Inst Inst, the instance ID of this task. - * @param[in] Region Region, the region ID registered for memory - * usage of this task. - * @param[in] Reason Reason. - * @return int - * -# ROK + * @param[in] Inst inst, the Scheduler instance + * @return void **/ -uint8_t schActvInit(Ent entity, Inst instId, Region region, Reason reason) +void schAllApisInit(Inst inst) { - Inst inst = (instId - SCH_INST_START); - - /* Initialize the MAC TskInit structure to zero */ - memset ((uint8_t *)&schCb[inst], 0, sizeof(schCb)); - - /* Initialize the MAC TskInit with received values */ - schCb[inst].schInit.ent = entity; - schCb[inst].schInit.inst = inst; - schCb[inst].schInit.region = region; - schCb[inst].schInit.pool = 0; - schCb[inst].schInit.reason = reason; - schCb[inst].schInit.cfgDone = FALSE; - schCb[inst].schInit.acnt = FALSE; - schCb[inst].schInit.usta = FALSE; - schCb[inst].schInit.trc = FALSE; - schCb[inst].schInit.procId = ODU_GET_PROCID(); - - return ROK; -} /* schActvInit */ + schFcfsAllApisInit(&schCb[inst].allApis[SCH_FCFS]); + schSliceBasedAllApisInit(&schCb[inst].allApis[SCH_SLICE_BASED]); +} /** * @brief Scheduler instance Configuration Handler. @@ -129,9 +99,7 @@ uint8_t SchInstCfg(RgCfg *cfg, Inst dInst) return LCM_REASON_INVALID_MSGTYPE; } /* Update the Pst structure for LM interface */ - memcpy(&schCb[inst].schInit.lmPst, - &cfg->s.schInstCfg.genCfg.lmPst, - sizeof(Pst)); + memcpy(&schCb[inst].schInit.lmPst, &cfg->s.schInstCfg.genCfg.lmPst, sizeof(Pst)); schCb[inst].schInit.inst = inst; schCb[inst].schInit.lmPst.srcProcId = schCb[inst].schInit.procId; @@ -142,33 +110,37 @@ uint8_t SchInstCfg(RgCfg *cfg, Inst dInst) schCb[inst].schInit.region = cfg->s.schInstCfg.genCfg.mem.region; schCb[inst].schInit.pool = cfg->s.schInstCfg.genCfg.mem.pool; - schCb[inst].genCfg.tmrRes = cfg->s.schInstCfg.genCfg.tmrRes; #ifdef LTE_ADV schCb[inst].genCfg.forceCntrlSrbBoOnPCel = cfg->s.schInstCfg.genCfg.forceCntrlSrbBoOnPCel; schCb[inst].genCfg.isSCellActDeactAlgoEnable = cfg->s.schInstCfg.genCfg.isSCellActDeactAlgoEnable; #endif schCb[inst].genCfg.startCellId = cfg->s.schInstCfg.genCfg.startCellId; + schCb[inst].schTimersInfo.tmrRes = cfg->s.schInstCfg.genCfg.tmrRes; /* Initialzie the timer queue */ - memset(&schCb[inst].tmrTq, 0, sizeof(CmTqType) * SCH_TQ_SIZE); + memset(&schCb[inst].schTimersInfo.tmrTq, 0, sizeof(CmTqType) * SCH_TQ_SIZE); /* Initialize the timer control point */ - memset(&schCb[inst].tmrTqCp, 0, sizeof(CmTqCp)); - schCb[inst].tmrTqCp.tmrLen = RGSCH_TQ_SIZE; + memset(&schCb[inst].schTimersInfo.tmrTqCp, 0, sizeof(CmTqCp)); + schCb[inst].schTimersInfo.tmrTqCp.tmrLen = SCH_TQ_SIZE; /* SS_MT_TMR needs to be enabled as schActvTmr needs instance information */ /* Timer Registration request to system services */ - if (ODU_REG_TMR_MT(schCb[inst].schInit.ent, dInst, - (int)schCb[inst].genCfg.tmrRes, schActvTmr) != ROK) + if (ODU_REG_TMR_MT(schCb[inst].schInit.ent, dInst, (int)schCb[inst].schTimersInfo.tmrRes, schActvTmr) != ROK) { - DU_LOG("\nERROR --> SCH : SchInstCfg(): Failed to " - "register timer."); + DU_LOG("\nERROR --> SCH : SchInstCfg(): Failed to register timer."); return (LCM_REASON_MEM_NOAVAIL); } - + + /* Initialize statistics related configurations */ + memset(&schCb[inst].statistics, 0, sizeof(SchStatistics)); + cmLListInit(&schCb[inst].statistics.activeKpiList.dlTotPrbUseList); + cmLListInit(&schCb[inst].statistics.activeKpiList.ulTotPrbUseList); + /* Set Config done in TskInit */ schCb[inst].schInit.cfgDone = TRUE; - DU_LOG("\nINFO --> SCH : Scheduler gen config done"); - + DU_LOG("\nINFO --> SCH : Scheduler gen config done"); + + schAllApisInit(inst); return ret; } @@ -197,10 +169,6 @@ uint8_t SchProcGenCfgReq(Pst *pst, RgMngmt *cfg) RgMngmt cfm; Pst cfmPst; -#ifdef CALL_FLOW_DEBUG_LOG - DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : GENERAL_CFG_REQ\n"); -#endif - if(pst->dstInst < SCH_INST_START) { DU_LOG("\nERROR --> SCH : Invalid inst ID"); @@ -208,7 +176,7 @@ uint8_t SchProcGenCfgReq(Pst *pst, RgMngmt *cfg) "pst->dstInst=%d SCH_INST_START=%d", pst->dstInst,SCH_INST_START); return ROK; } - DU_LOG("\nINFO --> SCH : Received scheduler gen config"); + DU_LOG("\nINFO --> SCH : Received scheduler gen config"); /* Fill the post structure for sending the confirmation */ memset(&cfmPst, 0 , sizeof(Pst)); SchFillCfmPst(pst, &cfmPst, cfg); @@ -247,102 +215,6 @@ uint8_t SchProcGenCfgReq(Pst *pst, RgMngmt *cfg) return ROK; }/*-- SchProcGenCfgReq --*/ -/** - * @brief slot indication from MAC to SCH. - * - * @details - * - * Function : MacSchSlotInd - * - * This API is invoked by PHY to indicate slot indication to Scheduler for - * a cell. - * - * @param[in] Pst *pst - * @param[in] SlotTimingInfo *slotInd - * @return S16 - * -# ROK - * -# RFAILED - **/ -uint8_t MacSchSlotInd(Pst *pst, SlotTimingInfo *slotInd) -{ - Inst inst = pst->dstInst-SCH_INST_START; - -#ifdef CALL_FLOW_DEBUG_LOG - DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_SLOT_IND_TO_SCH\n"); -#endif - - schProcessSlotInd(slotInd, inst); - - return ROK; -} /* MacSchSlotInd */ - -/******************************************************************* - * - * @brief Processes Rach indication from MAC - * - * @details - * - * Function : MacSchRachInd - * - * Functionality: - * Processes Rach indication from MAC - * - * @params[in] - * @return ROK - success - * RFAILED - failure - * - * ****************************************************************/ -uint8_t MacSchRachInd(Pst *pst, RachIndInfo *rachInd) -{ - Inst inst = pst->dstInst-SCH_INST_START; - -#ifdef CALL_FLOW_DEBUG_LOG - DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_RACH_IND_TO_SCH\n"); -#endif - - DU_LOG("\nINFO --> SCH : Received Rach indication"); - schProcessRachInd(rachInd, inst); - return ROK; -} - -/******************************************************************* - * - * @brief Processes CRC indication from MAC - * - * @details - * - * Function : MacSchCrcInd - * - * Functionality: - * Processes CRC indication from MAC - * - * @params[in] Post structure - * Crc Indication - * @return ROK - success - * RFAILED - failure - * - * ****************************************************************/ -uint8_t MacSchCrcInd(Pst *pst, CrcIndInfo *crcInd) -{ -#ifdef CALL_FLOW_DEBUG_LOG - DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_CRC_IND_TO_SCH\n"); -#endif - - switch(crcInd->crcInd[0]) - { - case CRC_FAILED: - DU_LOG("\nDEBUG --> SCH : Received CRC indication. CRC Status [FAILURE]"); - break; - case CRC_PASSED: - DU_LOG("\nDEBUG --> SCH : Received CRC indication. CRC Status [PASS]"); - break; - default: - DU_LOG("\nDEBUG --> SCH : Invalid CRC state %d", crcInd->crcInd[0]); - return RFAILED; - } - return ROK; -} - #ifdef NR_TDD /** *@brief Returns TDD periodicity in micro seconds @@ -411,6 +283,48 @@ uint16_t schGetPeriodicityInMsec(DlUlTxPeriodicity tddPeriod) return periodicityInMsec; } +/** + *@brief Fills the slotCfg from CellCfg + * + * @details + * + * Function : schFillSlotConfig + * + * This API Fills the slotCfg from CellCfg + * + * @param[in] SchCellCb *cell, TDDCfg tddCfg + * @return void + * **/ +void schFillSlotConfig(SchCellCb *cell, TDDCfg tddCfg) +{ + uint8_t slotIdx = 0, symbolIdx = 0; + + for(slotIdx =0 ;slotIdx < MAX_TDD_PERIODICITY_SLOTS; slotIdx++) + { + for(symbolIdx = 0; symbolIdx < MAX_SYMB_PER_SLOT; symbolIdx++) + { + /*Fill Full-DL Slots as well as DL symbols ini 1st Flexi Slo*/ + if(slotIdx < tddCfg.nrOfDlSlots || \ + (slotIdx == tddCfg.nrOfDlSlots && symbolIdx < tddCfg.nrOfDlSymbols)) + { + cell->slotCfg[slotIdx][symbolIdx] = DL_SYMBOL; + } + + /*Fill Full-FLEXI SLOT and as well as Flexi Symbols in 1 slot preceding FULL-UL slot*/ + else if(slotIdx < (MAX_TDD_PERIODICITY_SLOTS - tddCfg.nrOfUlSlots -1) || \ + (slotIdx == (MAX_TDD_PERIODICITY_SLOTS - tddCfg.nrOfUlSlots -1) && \ + symbolIdx < (MAX_SYMB_PER_SLOT - tddCfg.nrOfUlSymbols))) + { + cell->slotCfg[slotIdx][symbolIdx] = FLEXI_SYMBOL; + } + /*Fill Partial UL symbols and Full-UL slot*/ + else + { + cell->slotCfg[slotIdx][symbolIdx] = UL_SYMBOL; + } + } + } +} /** * @brief init TDD slot config @@ -431,17 +345,17 @@ void schInitTddSlotCfg(SchCellCb *cell, SchCellCfg *schCellCfg) int8_t slotIdx, symbIdx; periodicityInMicroSec = schGetPeriodicityInMsec(schCellCfg->tddCfg.tddPeriod); - cell->numSlotsInPeriodicity = (periodicityInMicroSec * pow(2, schCellCfg->numerology))/1000; + cell->numSlotsInPeriodicity = (periodicityInMicroSec * pow(2, cell->numerology))/1000; cell->slotFrmtBitMap = 0; - cell->symbFrmtBitMap = 0; + schFillSlotConfig(cell, schCellCfg->tddCfg); for(slotIdx = cell->numSlotsInPeriodicity-1; slotIdx >= 0; slotIdx--) { symbIdx = 0; /* If the first and last symbol are the same, the entire slot is the same type */ - if((schCellCfg->tddCfg.slotCfg[slotIdx][symbIdx] == schCellCfg->tddCfg.slotCfg[slotIdx][MAX_SYMB_PER_SLOT-1]) && - schCellCfg->tddCfg.slotCfg[slotIdx][symbIdx] != FLEXI_SLOT) + if((cell->slotCfg[slotIdx][symbIdx] == cell->slotCfg[slotIdx][MAX_SYMB_PER_SLOT-1]) && + cell->slotCfg[slotIdx][symbIdx] != FLEXI_SYMBOL) { - switch(schCellCfg->tddCfg.slotCfg[slotIdx][symbIdx]) + switch(cell->slotCfg[slotIdx][symbIdx]) { case DL_SLOT: { @@ -462,34 +376,6 @@ void schInitTddSlotCfg(SchCellCb *cell, SchCellCfg *schCellCfg) } /* slot config is flexible. First set slotBitMap to 10 */ cell->slotFrmtBitMap = ((cell->slotFrmtBitMap<<2) | (FLEXI_SLOT)); - - /* Now set symbol bitmap */ - for(symbIdx = MAX_SYMB_PER_SLOT-1; symbIdx >= 0; symbIdx--) - { - switch(schCellCfg->tddCfg.slotCfg[slotIdx][symbIdx]) - { - case DL_SLOT: - { - /*symbol BitMap to be set to 00 */ - cell->symbFrmtBitMap = (cell->symbFrmtBitMap<<2); - break; - } - case UL_SLOT: - { - /*symbol BitMap to be set to 01 */ - cell->symbFrmtBitMap = ((cell->symbFrmtBitMap<<2) | (UL_SLOT)); - break; - } - case FLEXI_SLOT: - { - /*symbol BitMap to be set to 10 */ - cell->symbFrmtBitMap = ((cell->symbFrmtBitMap<<2) | (FLEXI_SLOT)); - break; - } - default: - DU_LOG("\nERROR --> SCH : Invalid slot Config in schInitTddSlotCfg"); - } - } } } #endif @@ -512,7 +398,7 @@ void fillSsbStartSymb(SchCellCb *cellCb) { uint8_t cnt, scs, symbIdx, ssbStartSymbArr[SCH_MAX_SSB_BEAM]; - scs = cellCb->cellCfg.ssbSchCfg.scsCommon; + scs = cellCb->cellCfg.ssbScs; memset(ssbStartSymbArr, 0, sizeof(SCH_MAX_SSB_BEAM)); symbIdx = 0; @@ -520,41 +406,40 @@ void fillSsbStartSymb(SchCellCb *cellCb) switch(scs) { case SCS_15KHZ: - { - if(cellCb->cellCfg.dlFreq <= 300000) - cnt = 2;/* n = 0, 1 */ + { + if(cellCb->cellCfg.ssbFrequency <= 300000) + cnt = 2;/* n = 0, 1 */ else cnt = 4; /* n = 0, 1, 2, 3 */ - for(uint8_t idx=0; idxcellCfg.dlFreq <= 300000) - cnt = 1;/* n = 0 */ + { + if(cellCb->cellCfg.ssbFrequency <= 300000) + cnt = 1;/* n = 0 */ else cnt = 2; /* n = 0, 1 */ - for(uint8_t idx=0; idx SCH : SCS %d is currently not supported", scs); + DU_LOG("\nERROR --> SCH : SCS %d is currently not supported", scs); } memset(cellCb->ssbStartSymbArr, 0, sizeof(SCH_MAX_SSB_BEAM)); memcpy(cellCb->ssbStartSymbArr, ssbStartSymbArr, SCH_MAX_SSB_BEAM); - } @@ -575,6 +460,7 @@ void fillSsbStartSymb(SchCellCb *cellCb) **/ uint8_t schInitCellCb(Inst inst, SchCellCfg *schCellCfg) { + uint16_t scsInKhz = 0; SchCellCb *cell= NULLP; SCH_ALLOC(cell, sizeof(SchCellCb)); if(!cell) @@ -585,7 +471,11 @@ uint8_t schInitCellCb(Inst inst, SchCellCfg *schCellCfg) cell->cellId = schCellCfg->cellId; cell->instIdx = inst; - switch(schCellCfg->numerology) + scsInKhz = convertScsEnumValToScsVal(schCellCfg->ssbScs); + + /*Ref : 3GPP 38.211 Table 4.2-1: SCS = (2 ^ numerology * 15kHz)*/ + cell->numerology = log2(scsInKhz/BASE_SCS); + switch(cell->numerology) { case SCH_NUMEROLOGY_0: { @@ -613,7 +503,7 @@ uint8_t schInitCellCb(Inst inst, SchCellCfg *schCellCfg) } break; default: - DU_LOG("\nERROR --> SCH : Numerology %d not supported", schCellCfg->numerology); + DU_LOG("\nERROR --> SCH : Numerology %d not supported", cell->numerology); } #ifdef NR_TDD schInitTddSlotCfg(cell, schCellCfg); @@ -664,7 +554,10 @@ uint8_t schInitCellCb(Inst inst, SchCellCfg *schCellCfg) cell->firstSsbTransmitted = false; cell->firstSib1Transmitted = false; fillSsbStartSymb(cell); - cmLListInit(&cell->ueToBeScheduled); + +#ifdef NR_DRX + memset(cell->drxCb, 0, MAX_DRX_SIZE*sizeof(SchDrxCb)); +#endif schCb[inst].cells[inst] = cell; DU_LOG("\nINFO --> SCH : Cell init completed for cellId:%d", cell->cellId); @@ -688,7 +581,8 @@ uint8_t schInitCellCb(Inst inst, SchCellCfg *schCellCfg) * uint8_t offsetPointA : offset * @return void **/ -void fillSchSib1Cfg(uint8_t mu, uint8_t bandwidth, uint8_t numSlots, SchSib1Cfg *sib1SchCfg, uint16_t pci, uint8_t offsetPointA) +uint8_t fillSchSib1Cfg(uint8_t mu, uint8_t bandwidth, uint8_t numSlots,SchPdcchConfigSib1 *pdcchCfgSib1,\ + SchSib1Cfg *sib1SchCfg, uint16_t pci, uint8_t offsetPointA, uint16_t sib1PduLen) { uint8_t coreset0Idx = 0; uint8_t searchSpace0Idx = 0; @@ -701,16 +595,18 @@ void fillSchSib1Cfg(uint8_t mu, uint8_t bandwidth, uint8_t numSlots, SchSib1Cfg uint8_t mValue = 0; uint8_t firstSymbol = 0; /* need to calculate using formula mentioned in 38.213 */ uint8_t slotIndex = 0; - uint8_t FreqDomainResource[FREQ_DOM_RSRC_SIZE] = {0}; + uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0}; uint16_t tbSize = 0; uint8_t ssbIdx = 0; + PdcchCfg *pdcch; + PdschCfg *pdsch; + BwpCfg *bwp; - PdcchCfg *pdcch = &(sib1SchCfg->sib1PdcchCfg); - PdschCfg *pdsch = &(sib1SchCfg->sib1PdschCfg); - BwpCfg *bwp = &(sib1SchCfg->bwp); + pdcch = &(sib1SchCfg->sib1PdcchCfg); + bwp = &(sib1SchCfg->bwp); - coreset0Idx = sib1SchCfg->coresetZeroIndex; - searchSpace0Idx = sib1SchCfg->searchSpaceZeroIndex; + coreset0Idx = pdcchCfgSib1->coresetZeroIndex; + searchSpace0Idx = pdcchCfgSib1->searchSpaceZeroIndex; /* derive the sib1 coreset0 params from table 13-1 spec 38.213 */ //ssbMuxPattern = coresetIdxTable[coreset0Idx][0]; @@ -759,8 +655,8 @@ void fillSchSib1Cfg(uint8_t mu, uint8_t bandwidth, uint8_t numSlots, SchSib1Cfg pdcch->coresetCfg.durationSymbols = numSymbols; /* Fill Bitmap for PRBs in coreset */ - fillCoresetFeqDomAllocMap(((offsetPointA-offset)/6), (numRbs/6), FreqDomainResource); - covertFreqDomRsrcMapToIAPIFormat(FreqDomainResource, pdcch->coresetCfg.freqDomainResource); + fillCoresetFeqDomAllocMap(((offsetPointA-offset)/6), (numRbs/6), freqDomainResource); + memcpy(pdcch->coresetCfg.freqDomainResource, freqDomainResource, FREQ_DOM_RSRC_SIZE); pdcch->coresetCfg.cceRegMappingType = 1; /* coreset0 is always interleaved */ pdcch->coresetCfg.regBundleSize = 6; /* spec-38.211 sec 7.3.2.2 */ @@ -769,21 +665,21 @@ void fillSchSib1Cfg(uint8_t mu, uint8_t bandwidth, uint8_t numSlots, SchSib1Cfg pdcch->coresetCfg.shiftIndex = pci; pdcch->coresetCfg.precoderGranularity = 0; /* sameAsRegBundle */ pdcch->numDlDci = 1; - pdcch->dci.rnti = SI_RNTI; - pdcch->dci.scramblingId = pci; - pdcch->dci.scramblingRnti = 0; - pdcch->dci.cceIndex = 0; - pdcch->dci.aggregLevel = 4; - pdcch->dci.beamPdcchInfo.numPrgs = 1; - pdcch->dci.beamPdcchInfo.prgSize = 1; - pdcch->dci.beamPdcchInfo.digBfInterfaces = 0; - pdcch->dci.beamPdcchInfo.prg[0].pmIdx = 0; - pdcch->dci.beamPdcchInfo.prg[0].beamIdx[0] = 0; - pdcch->dci.txPdcchPower.powerValue = 0; - pdcch->dci.txPdcchPower.powerControlOffsetSS = 0; + pdcch->dci[0].rnti = SI_RNTI; + pdcch->dci[0].scramblingId = pci; + pdcch->dci[0].scramblingRnti = 0; + pdcch->dci[0].cceIndex = 0; + pdcch->dci[0].aggregLevel = 4; + pdcch->dci[0].beamPdcchInfo.numPrgs = 1; + pdcch->dci[0].beamPdcchInfo.prgSize = 1; + pdcch->dci[0].beamPdcchInfo.digBfInterfaces = 0; + pdcch->dci[0].beamPdcchInfo.prg[0].pmIdx = 0; + pdcch->dci[0].beamPdcchInfo.prg[0].beamIdx[0] = 0; + pdcch->dci[0].txPdcchPower.beta_pdcch_1_0= 0; + pdcch->dci[0].txPdcchPower.powerControlOffsetSS = 0; /* Storing pdschCfg pointer here. Required to access pdsch config while fillig up pdcch pdu */ - pdcch->dci.pdschCfg = pdsch; + pdsch = &pdcch->dci[0].pdschCfg; /* fill the PDSCH PDU */ uint8_t cwCount = 0; @@ -795,17 +691,17 @@ void fillSchSib1Cfg(uint8_t mu, uint8_t bandwidth, uint8_t numSlots, SchSib1Cfg { pdsch->codeword[cwCount].targetCodeRate = 308; pdsch->codeword[cwCount].qamModOrder = 2; - pdsch->codeword[cwCount].mcsIndex = sib1SchCfg->sib1Mcs; + pdsch->codeword[cwCount].mcsIndex = DEFAULT_MCS; pdsch->codeword[cwCount].mcsTable = 0; /* notqam256 */ pdsch->codeword[cwCount].rvIndex = 0; - tbSize = schCalcTbSize(sib1SchCfg->sib1PduLen + TX_PAYLOAD_HDR_LEN); + tbSize = schCalcTbSize(sib1PduLen + TX_PAYLOAD_HDR_LEN); pdsch->codeword[cwCount].tbSize = tbSize; } pdsch->dataScramblingId = pci; pdsch->numLayers = 1; pdsch->transmissionScheme = 0; pdsch->refPoint = 0; - pdsch->dmrs.dlDmrsSymbPos = 4; /* Bitmap value 00000000000100 i.e. using 3rd symbol for PDSCH DMRS */ + pdsch->dmrs.dlDmrsSymbPos = DL_DMRS_SYMBOL_POS; pdsch->dmrs.dmrsConfigType = 0; /* type-1 */ pdsch->dmrs.dlDmrsScramblingId = pci; pdsch->dmrs.scid = 0; @@ -817,13 +713,13 @@ void fillSchSib1Cfg(uint8_t mu, uint8_t bandwidth, uint8_t numSlots, SchSib1Cfg pdsch->pdschFreqAlloc.resourceAllocType = 1; /* RAT type-1 RIV format */ /* the RB numbering starts from coreset0, and PDSCH is always above SSB */ - pdsch->pdschFreqAlloc.freqAlloc.startPrb = offsetPointA + SCH_SSB_NUM_PRB; - pdsch->pdschFreqAlloc.freqAlloc.numPrb = schCalcNumPrb(tbSize,sib1SchCfg->sib1Mcs, NUM_PDSCH_SYMBOL); + pdsch->pdschFreqAlloc.startPrb = offsetPointA + SCH_SSB_NUM_PRB; + pdsch->pdschFreqAlloc.numPrb = schCalcNumPrb(tbSize, DEFAULT_MCS, NUM_PDSCH_SYMBOL); pdsch->pdschFreqAlloc.vrbPrbMapping = 0; /* non-interleaved */ pdsch->pdschTimeAlloc.rowIndex = 1; /* This is Intel's requirement. PDSCH should start after PDSCH DRMS symbol */ - pdsch->pdschTimeAlloc.timeAlloc.startSymb = 3; /* spec-38.214, Table 5.1.2.1-1 */ - pdsch->pdschTimeAlloc.timeAlloc.numSymb = NUM_PDSCH_SYMBOL; + pdsch->pdschTimeAlloc.startSymb = 3; /* spec-38.214, Table 5.1.2.1-1 */ + pdsch->pdschTimeAlloc.numSymb = NUM_PDSCH_SYMBOL; pdsch->beamPdschInfo.numPrgs = 1; pdsch->beamPdschInfo.prgSize = 1; pdsch->beamPdschInfo.digBfInterfaces = 0; @@ -832,6 +728,7 @@ void fillSchSib1Cfg(uint8_t mu, uint8_t bandwidth, uint8_t numSlots, SchSib1Cfg pdsch->txPdschPower.powerControlOffset = 0; pdsch->txPdschPower.powerControlOffsetSS = 0; + return ROK; } /** @@ -849,52 +746,75 @@ void fillSchSib1Cfg(uint8_t mu, uint8_t bandwidth, uint8_t numSlots, SchSib1Cfg * -# ROK * -# RFAILED **/ -uint8_t SchHdlCellCfgReq(Pst *pst, SchCellCfg *schCellCfg) +uint8_t SchProcCellCfgReq(Pst *pst, SchCellCfg *schCellCfg) { uint8_t ret = ROK; SchCellCb *cellCb; SchCellCfgCfm schCellCfgCfm; Pst rspPst; - Inst inst = pst->dstInst-1; + Inst inst = pst->dstInst - SCH_INST_START; uint8_t coreset0Idx = 0; uint8_t numRbs = 0; uint8_t offset = 0; uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0}; SchPdschConfig pdschCfg; -#ifdef CALL_FLOW_DEBUG_LOG - DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_SCH_CELL_CFG\n"); -#endif - schInitCellCb(inst, schCellCfg); cellCb = schCb[inst].cells[inst]; //cells is of MAX_CELLS, why inst cellCb->macInst = pst->srcInst; /* derive the SIB1 config parameters */ - fillSchSib1Cfg(schCellCfg->numerology, schCellCfg->bandwidth, cellCb->numSlots, - &(schCellCfg->sib1SchCfg), schCellCfg->phyCellId, - schCellCfg->ssbSchCfg.ssbOffsetPointA); + ret = fillSchSib1Cfg(cellCb->numerology, schCellCfg->dlBandwidth, cellCb->numSlots, + &(schCellCfg->pdcchCfgSib1), &(cellCb->sib1SchCfg), schCellCfg->phyCellId, + schCellCfg->dlCfgCommon.schFreqInfoDlSib.offsetToPointA, schCellCfg->sib1PduLen); + + if(ret != ROK) + { + DU_LOG("\nERROR --> SCH : Failed to fill sib1 configuration"); + return RFAILED; + } memcpy(&cellCb->cellCfg, schCellCfg, sizeof(SchCellCfg)); + schProcPagingCfg(cellCb); /* Fill coreset frequencyDomainResource bitmap */ - coreset0Idx = cellCb->cellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.coresetId; + coreset0Idx = cellCb->cellCfg.dlCfgCommon.schInitialDlBwp.pdcchCommon.commonSearchSpace.coresetId; numRbs = coresetIdxTable[coreset0Idx][1]; offset = coresetIdxTable[coreset0Idx][3]; - fillCoresetFeqDomAllocMap(((cellCb->cellCfg.ssbSchCfg.ssbOffsetPointA - offset)/6), (numRbs/6), freqDomainResource); - covertFreqDomRsrcMapToIAPIFormat(freqDomainResource, \ - cellCb->cellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.freqDomainRsrc); - + fillCoresetFeqDomAllocMap(((cellCb->cellCfg.dlCfgCommon.schFreqInfoDlSib.offsetToPointA - offset)/6), \ + (numRbs/6), freqDomainResource); + memcpy(cellCb->cellCfg.dlCfgCommon.schInitialDlBwp.pdcchCommon.commonSearchSpace.freqDomainRsrc,\ + freqDomainResource,FREQ_DOM_RSRC_SIZE); /* Fill K0 - K1 table for common cfg*/ - BuildK0K1Table(cellCb, &cellCb->cellCfg.schInitialDlBwp.k0K1InfoTbl, true, cellCb->cellCfg.schInitialDlBwp.pdschCommon, - pdschCfg, DEFAULT_UL_ACK_LIST_COUNT, defaultUlAckTbl); + BuildK0K1Table(cellCb, &cellCb->k0K1InfoTbl, true, cellCb->cellCfg.dlCfgCommon.schInitialDlBwp.pdschCommon, + pdschCfg, DEFAULT_UL_ACK_LIST_COUNT, defaultUlAckTbl); + + BuildK2InfoTable(cellCb, cellCb->cellCfg.ulCfgCommon.schInitialUlBwp.puschCommon.timeDomRsrcAllocList,\ + cellCb->cellCfg.ulCfgCommon.schInitialUlBwp.puschCommon.numTimeDomRsrcAlloc, &cellCb->msg3K2InfoTbl, \ + &cellCb->k2InfoTbl); - BuildK2InfoTable(cellCb, cellCb->cellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList,\ - cellCb->cellCfg.schInitialUlBwp.puschCommon.numTimeDomRsrcAlloc, &cellCb->cellCfg.schInitialUlBwp.msg3K2InfoTbl, \ - &cellCb->cellCfg.schInitialUlBwp.k2InfoTbl); + /*As per Spec 38.211, Sec 6.3.3.2; RootSeq Len(Lra) where Lra=839 or Lra=139, + *depending on the PRACH preamble format as given by Tables 6.3.3.1-1 and 6.3.3.1-2.*/ + if(prachCfgIdxTable[cellCb->cellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.prachCfgGeneric.prachCfgIdx][0] <= 3) + { + cellCb->cellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.rootSeqLen = ROOT_SEQ_LEN_1; + } + else + { + cellCb->cellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.rootSeqLen = ROOT_SEQ_LEN_2; + } /* Initializing global variables */ cellCb->actvUeBitMap = 0; cellCb->boIndBitMap = 0; + cellCb->schHqCfg.maxDlDataHqTx = SCH_MAX_NUM_DL_HQ_TX; + cellCb->schHqCfg.maxMsg4HqTx = SCH_MAX_NUM_MSG4_TX; + cellCb->schHqCfg.maxUlDataHqTx = SCH_MAX_NUM_UL_HQ_TX; + cellCb->maxMsg3Tx = SCH_MAX_NUM_MSG3_TX; + + cellCb->schAlgoType = SCH_FCFS; + cellCb->api = &schCb[inst].allApis[cellCb->schAlgoType]; /* For FCFS */ + cellCb->api->SchCellCfgReq(cellCb); + /* Fill and send Cell config confirm */ memset(&rspPst, 0, sizeof(Pst)); FILL_PST_SCH_TO_MAC(rspPst, pst->dstInst); @@ -903,145 +823,349 @@ uint8_t SchHdlCellCfgReq(Pst *pst, SchCellCfg *schCellCfg) schCellCfgCfm.cellId = schCellCfg->cellId; schCellCfgCfm.rsp = RSP_OK; - ret = (*SchCellCfgCfmOpts[rspPst.selector])(&rspPst, &schCellCfgCfm); + ret = MacMessageRouter(&rspPst, (void *)&schCellCfgCfm); return ret; } /******************************************************************* * - * @brief Processes DL RLC BO info from MAC + * @brief Fill and send Cell delete response to MAC * * @details * - * Function : MacSchDlRlcBoInfo + * Function : SchSendCellDeleteRspToMac * - * Functionality: - * Processes DL RLC BO info from MAC + * Functionality: Fill and send Cell delete response to MAC * - * @params[in] + * @params[in] SchCellDelete *ueDelete, Inst inst, SchMacRsp result * @return ROK - success * RFAILED - failure * * ****************************************************************/ -uint8_t MacSchDlRlcBoInfo(Pst *pst, DlRlcBoInfo *dlBoInfo) +uint8_t SchSendCellDeleteRspToMac(SchCellDeleteReq *ueDelete, Inst inst, SchMacRsp result) { - uint8_t lcId = 0; - uint16_t ueId = 0; - bool isLcIdValid = false; - SchUeCb *ueCb = NULLP; - SchCellCb *cell = NULLP; - Inst inst = pst->dstInst-SCH_INST_START; - CmLListCp *lcLL = NULLP; - -#ifdef CALL_FLOW_DEBUG_LOG - DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_DL_RLC_BO_INFO_TO_SCH\n"); -#endif + Pst rspPst; + uint8_t ret=0; + + SchCellDeleteRsp delRsp; - DU_LOG("\nDEBUG --> SCH : Received RLC BO Status indication LCId [%d] BO [%d]", dlBoInfo->lcId, dlBoInfo->dataVolume); - cell = schCb[inst].cells[inst]; + DU_LOG("\nINFO --> SCH : Filling Cell Delete response"); + memset(&delRsp, 0, sizeof(SchCellDeleteRsp)); + delRsp.cellId = ueDelete->cellId; + delRsp.rsp = result; - if(cell == NULLP) + /* Filling response post */ + memset(&rspPst, 0, sizeof(Pst)); + FILL_PST_SCH_TO_MAC(rspPst, inst); + rspPst.event = EVENT_CELL_DELETE_RSP_TO_MAC; + ret = MacMessageRouter(&rspPst, (void *)&delRsp); + if(ret == RFAILED) { - DU_LOG("\nERROR --> SCH : MacSchDlRlcBoInfo(): Cell does not exists"); - return RFAILED; + DU_LOG("\nERROR --> SCH : SchSendCellDeleteRspToMac(): failed to send the Cell Delete response"); + return ret; } + return ret; +} - GET_UE_IDX(dlBoInfo->crnti, ueId); - ueCb = &cell->ueCb[ueId-1]; - lcId = dlBoInfo->lcId; - CHECK_LCID(lcId, isLcIdValid); - if(isLcIdValid == FALSE) - { - DU_LOG("ERROR --> SCH: LCID:%d is not valid", lcId); - return RFAILED; - } +/******************************************************************* + * + * @brief Function for cellCb Deletion + * + * @details + * + * Function : deleteSchCellCb + * + * Functionality: Function for cellCb Deletion + * + * @params[in] SchCellDelete *cellDelete + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +void deleteSchCellCb(SchCellCb *cellCb) +{ + uint8_t sliceIdx=0, slotIdx=0, plmnIdx = 0; + CmLListCp *list=NULL; + CmLList *node=NULL, *next=NULL; + SchPageInfo *tempNode = NULLP; - /*Expected when theres a case of Retransmission Failure or Resetablishment - *By Zero BO, the RLC is informing that previous data can be cleared out - *Thus clearing out the LC from the Lc priority list*/ - if(dlBoInfo->dataVolume == 0) + if(cellCb->schDlSlotInfo) { - /*Check the LC is Dedicated or default and accordingly LCList will - * be used*/ - if(ueCb->dlInfo.dlLcCtxt[lcId].isDedicated) - { - lcLL = &(ueCb->dlLcPrbEst.dedLcInfo->dedLcList); - } - else + for(slotIdx=0; slotIdxnumSlots; slotIdx++) { - lcLL = &(ueCb->dlLcPrbEst.defLcList); + list = &cellCb->schDlSlotInfo[slotIdx]->prbAlloc.freePrbBlockList; + node = list->first; + while(node) + { + next = node->next; + SCH_FREE(node->node, sizeof(FreePrbBlock)); + deleteNodeFromLList(list, node); + node = next; + } + SCH_FREE(cellCb->schDlSlotInfo[slotIdx], sizeof(SchDlSlotInfo)); } - handleLcLList(lcLL, lcId, DELETE); - return ROK; + SCH_FREE(cellCb->schDlSlotInfo, cellCb->numSlots *sizeof(SchDlSlotInfo*)); } - if(lcId == SRB0_LCID) + if(cellCb->schUlSlotInfo) { - cell->raCb[ueId -1].msg4recvd = true; - cell->raCb[ueId -1].dlMsgPduLen = dlBoInfo->dataVolume; - + for(slotIdx=0; slotIdxnumSlots; slotIdx++) + { + list = &cellCb->schUlSlotInfo[slotIdx]->prbAlloc.freePrbBlockList; + node = list->first; + while(node) + { + next = node->next; + SCH_FREE(node->node, sizeof(FreePrbBlock)); + deleteNodeFromLList(list, node); + node = next; + } + SCH_FREE(cellCb->schUlSlotInfo[slotIdx], sizeof(SchUlSlotInfo)); + } + SCH_FREE(cellCb->schUlSlotInfo, cellCb->numSlots * sizeof(SchUlSlotInfo*)); } - else + + for(plmnIdx = 0; plmnIdx < MAX_PLMN; plmnIdx++) { - /* TODO : These part of changes will be corrected during DL scheduling as - * per K0 - K1 -K2 */ - SET_ONE_BIT(ueId, cell->boIndBitMap); - if(ueCb->dlInfo.dlLcCtxt[lcId].lcId == lcId) + if(cellCb->cellCfg.plmnInfoList[plmnIdx].suppSliceList.snssai) { - ueCb->dlInfo.dlLcCtxt[lcId].bo = dlBoInfo->dataVolume; + for(sliceIdx=0; sliceIdxcellCfg.plmnInfoList[plmnIdx].suppSliceList.numSupportedSlices; sliceIdx++) + { + SCH_FREE(cellCb->cellCfg.plmnInfoList[plmnIdx].suppSliceList.snssai[sliceIdx], sizeof(Snssai)); + } + SCH_FREE(cellCb->cellCfg.plmnInfoList[plmnIdx].suppSliceList.snssai, cellCb->cellCfg.plmnInfoList[plmnIdx].suppSliceList.numSupportedSlices*sizeof(Snssai*)); } - else + } + + for(uint16_t idx =0; idxpageCb.pageIndInfoRecord[idx]; + node = list->first; + while(node) { - DU_LOG("ERROR --> SCH: LCID:%d is not configured in SCH Cb",lcId); - return RFAILED; + next = node->next; + if(node->node) + { + tempNode = (SchPageInfo*)(node->node); + SCH_FREE(tempNode->pagePdu, tempNode->msgLen); + SCH_FREE(node->node, sizeof(SchPageInfo)); + } + deleteNodeFromLList(list, node); + node = next; } } - - /* Adding UE Id to list of pending UEs to be scheduled */ - addUeToBeScheduled(cell, ueId); - return ROK; + + cellCb->api->SchCellDeleteReq(cellCb); + + memset(cellCb, 0, sizeof(SchCellCb)); } /******************************************************************* * - * @brief Processes BSR indiation from MAC + * @brief Function for cell Delete request from MAC to SCH * * @details * - * Function : MacSchBsr + * Function : SchProcCellDeleteReq * - * Functionality: - * Processes DL BSR from MAC + * Functionality: Function for cell Delete request from MAC to SCH * - * @params[in] Pst pst - * UlBufferStatusRptInd bsrInd + * @params[in] Pst *pst, SchCellDelete *cellDelete * @return ROK - success * RFAILED - failure * * ****************************************************************/ -uint8_t MacSchBsr(Pst *pst, UlBufferStatusRptInd *bsrInd) +uint8_t SchProcCellDeleteReq(Pst *pst, SchCellDeleteReq *cellDelete) { - Inst schInst = pst->dstInst-SCH_INST_START; - SchCellCb *cellCb = NULLP; - SchUeCb *ueCb = NULLP; - uint8_t lcgIdx; - -#ifdef CALL_FLOW_DEBUG_LOG - DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_SHORT_BSR\n"); -#endif - - DU_LOG("\nDEBUG --> SCH : Received BSR"); - cellCb = schCb[schInst].cells[schInst]; - ueCb = schGetUeCb(cellCb, bsrInd->crnti); - - /* store dataVolume per lcg in uecb */ - for(lcgIdx = 0; lcgIdx < bsrInd->numLcg; lcgIdx++) + uint8_t cellIdx=0, ret = RFAILED; + Inst inst = pst->dstInst - SCH_INST_START; + SchMacRsp result= RSP_OK; + + if(!cellDelete) { - ueCb->bsrInfo[lcgIdx].priority = 1; //TODO: determining LCG priority? - ueCb->bsrInfo[lcgIdx].dataVol = bsrInd->dataVolInfo[lcgIdx].dataVol; + DU_LOG("\nERROR --> SCH : SchProcCellDeleteReq(): Ue Delete request failed"); } - return ROK; + else + { + GET_CELL_IDX(cellDelete->cellId, cellIdx); + if(schCb[inst].cells[cellIdx] == NULLP) + { + DU_LOG("\nERROR --> SCH : SchProcCellDeleteReq(): cell Id[%d] is not available", cellDelete->cellId); + result = RSP_NOK; + } + else + { + if(schCb[inst].cells[cellIdx]->cellId == cellDelete->cellId) + { + deleteSchCellCb(schCb[inst].cells[cellIdx]); + result = RSP_OK; + ret = ROK; + SCH_FREE(schCb[inst].cells[cellIdx], sizeof(SchCellCb)); + DU_LOG("\nINFO --> SCH : Sending Cell Delete response to MAC"); + } + else + { + DU_LOG("\nERROR --> SCH : SchProcCellDeleteReq(): cell Id[%d] is not available",cellDelete->cellId); + result = RSP_NOK; + } + } + + if(SchSendCellDeleteRspToMac(cellDelete, inst, result)!=ROK) + { + DU_LOG("\nERROR --> SCH : SchProcCellDeleteReq(): failed to send Cell Delete response"); + ret = RFAILED; + } + } + return ret; +} + +/******************************************************************* + * + * @brief Processes DL RLC BO info from MAC + * + * @details + * + * Function : SchProcDlRlcBoInfo + * + * Functionality: + * Processes DL RLC BO info from MAC + * + * @params[in] + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t SchProcDlRlcBoInfo(Pst *pst, DlRlcBoInfo *dlBoInfo) +{ + uint8_t lcId = 0; + uint16_t ueId = 0; + bool isLcIdValid = false; + SchUeCb *ueCb = NULLP; + SchCellCb *cell = NULLP; + Inst inst = pst->dstInst-SCH_INST_START; + + DU_LOG("\nDEBUG --> SCH : Received RLC BO Status indication LCId [%d] BO [%d]", dlBoInfo->lcId, dlBoInfo->dataVolume); + cell = schCb[inst].cells[inst]; + + if(cell == NULLP) + { + DU_LOG("\nERROR --> SCH : SchProcDlRlcBoInfo(): Cell does not exists"); + return RFAILED; + } + + GET_UE_ID(dlBoInfo->crnti, ueId); + ueCb = &cell->ueCb[ueId-1]; + if(ueCb->ueCfg.dataTransmissionAction == STOP_DATA_TRANSMISSION) + { + DU_LOG("INFO --> SCH : DL Data transmission not allowed for UE %d", ueCb->ueCfg.ueId); + return ROK; + } + + lcId = dlBoInfo->lcId; + CHECK_LCID(lcId, isLcIdValid); + if(isLcIdValid == FALSE) + { + DU_LOG("ERROR --> SCH: LCID:%d is not valid", lcId); + return RFAILED; + } + + /*Expected when theres a case of Retransmission Failure or Resetablishment + *By Zero BO, the RLC is informing that previous data can be cleared out + *Thus clearing out the LC from the Lc priority list*/ + if(dlBoInfo->dataVolume == 0) + { + /* TODO : Check the LC is Dedicated or default and accordingly LCList + * will be used*/ + return ROK; + } + + if(lcId == SRB0_LCID) + { + cell->raCb[ueId -1].msg4recvd = true; + cell->raCb[ueId -1].dlMsgPduLen = dlBoInfo->dataVolume; + } + else + { + /* TODO : These part of changes will be corrected during DL scheduling as + * per K0 - K1 -K2 */ + SET_ONE_BIT(ueId, cell->boIndBitMap); + if(ueCb->dlInfo.dlLcCtxt[lcId].lcId == lcId) + { + ueCb->dlInfo.dlLcCtxt[lcId].bo = dlBoInfo->dataVolume; + } + else + { + DU_LOG("ERROR --> SCH: LCID:%d is not configured in SCH Cb",lcId); + return RFAILED; + } + } + /* Adding UE Id to list of pending UEs to be scheduled */ + cell->api->SchDlRlcBoInfo(cell, ueId); + return ROK; +} + +/******************************************************************* + * + * @brief Processes BSR indiation from MAC + * + * @details + * + * Function : SchProcBsr + * + * Functionality: + * Processes DL BSR from MAC + * + * @params[in] Pst pst + * UlBufferStatusRptInd bsrInd + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t SchProcBsr(Pst *pst, UlBufferStatusRptInd *bsrInd) +{ + Inst schInst = pst->dstInst-SCH_INST_START; + SchCellCb *cellCb = NULLP; + SchUeCb *ueCb = NULLP; + uint8_t lcgIdx = 0; + + DU_LOG("\nDEBUG --> SCH : Received BSR"); + if(bsrInd == NULLP) + { + DU_LOG("\nERROR --> SCH : BSR Ind is empty"); + return RFAILED; + } + cellCb = schCb[schInst].cells[schInst]; + if(cellCb == NULLP) + { + DU_LOG("\nERROR --> SCH : CellCb is empty"); + return RFAILED; + } + ueCb = schGetUeCb(cellCb, bsrInd->crnti); + + if(ueCb == NULLP) + { + DU_LOG("\nERROR --> SCH : UeCB is empty"); + return RFAILED; + } + + if(ueCb->ueCfg.dataTransmissionAction == STOP_DATA_TRANSMISSION) + { + DU_LOG("\nINFO --> SCH: UL Data transmission not allowed for UE %d", ueCb->ueCfg.ueId); + return ROK; + } + + ueCb->bsrRcvd = true; + /* store dataVolume per lcg in uecb */ + for(lcgIdx = 0; lcgIdx < bsrInd->numLcg; lcgIdx++) + { + ueCb->bsrInfo[bsrInd->dataVolInfo[lcgIdx].lcgId].priority = 1; //TODO: determining LCG priority? + ueCb->bsrInfo[bsrInd->dataVolInfo[lcgIdx].lcgId].dataVol = bsrInd->dataVolInfo[lcgIdx].dataVol; + } + + /* Adding UE Id to list of pending UEs to be scheduled */ + cellCb->api->SchBsr(cellCb, ueCb->ueId); + return ROK; } /******************************************************************* @@ -1050,7 +1174,7 @@ uint8_t MacSchBsr(Pst *pst, UlBufferStatusRptInd *bsrInd) * * @details * - * Function : MacSchSrUciInd + * Function : SchProcSrUciInd * * Functionality: * Processes SR UCI indication from MAC @@ -1061,25 +1185,71 @@ uint8_t MacSchBsr(Pst *pst, UlBufferStatusRptInd *bsrInd) * RFAILED - failure * * ****************************************************************/ -uint8_t MacSchSrUciInd(Pst *pst, SrUciIndInfo *uciInd) +uint8_t SchProcSrUciInd(Pst *pst, SrUciIndInfo *uciInd) { Inst inst = pst->dstInst-SCH_INST_START; SchUeCb *ueCb; SchCellCb *cellCb = schCb[inst].cells[inst]; -#ifdef CALL_FLOW_DEBUG_LOG - DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_UCI_IND_TO_SCH\n"); -#endif - DU_LOG("\nDEBUG --> SCH : Received SR"); ueCb = schGetUeCb(cellCb, uciInd->crnti); - + + if(ueCb->state == SCH_UE_STATE_INACTIVE) + { + DU_LOG("\nERROR --> SCH : Crnti %d is inactive", uciInd->crnti); + return ROK; + } + if(ueCb->ueCfg.dataTransmissionAction == STOP_DATA_TRANSMISSION) + { + DU_LOG("\nINFO --> SCH: UL Data transmission not allowed for UE %d", ueCb->ueCfg.ueId); + return ROK; + } if(uciInd->numSrBits) { - ueCb->srRcvd = true; + ueCb->srRcvd = true; + /* Adding UE Id to list of pending UEs to be scheduled */ + cellCb->api->SchSrUciInd(cellCb, ueCb->ueId); + } + return ROK; +} + +/******************************************************************* + * + * @brief Processes DL HARQ indication from MAC + * + * @details + * + * Function : SchProcDlHarqInd + * + * Functionality: + * Processes DL HARQ indication from MAC + * + * @params[in] Post structure + * DL HARQ Indication + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t SchProcDlHarqInd(Pst *pst, DlHarqInd *dlHarqInd) +{ + Inst inst = pst->dstInst-SCH_INST_START; + SchUeCb *ueCb; + SchCellCb *cellCb = schCb[inst].cells[inst]; + + DU_LOG("\nDEBUG --> SCH : Received HARQ"); + + ueCb = schGetUeCb(cellCb, dlHarqInd->crnti); + + if(ueCb->state == SCH_UE_STATE_INACTIVE) + { + DU_LOG("\nERROR --> SCH : Crnti %d is inactive", dlHarqInd->crnti); + return ROK; } + + schUpdateHarqFdbk(ueCb, dlHarqInd->numHarq, dlHarqInd->harqPayload, &dlHarqInd->slotInd); + return ROK; } @@ -1126,18 +1296,18 @@ uint8_t allocatePrbDl(SchCellCb *cell, SlotTimingInfo slotTime, \ if(ssbOccasion && sib1Occasion) { - broadcastPrbStart = cell->cellCfg.ssbSchCfg.ssbOffsetPointA; - broadcastPrbEnd = broadcastPrbStart + SCH_SSB_NUM_PRB + cell->cellCfg.sib1SchCfg.sib1PdschCfg.pdschFreqAlloc.freqAlloc.numPrb -1; + broadcastPrbStart = cell->cellCfg.dlCfgCommon.schFreqInfoDlSib.offsetToPointA; + broadcastPrbEnd = broadcastPrbStart + SCH_SSB_NUM_PRB + cell->sib1SchCfg.sib1PdcchCfg.dci[0].pdschCfg.pdschFreqAlloc.numPrb -1; } else if(ssbOccasion) { - broadcastPrbStart = cell->cellCfg.ssbSchCfg.ssbOffsetPointA; + broadcastPrbStart = cell->cellCfg.dlCfgCommon.schFreqInfoDlSib.offsetToPointA; broadcastPrbEnd = broadcastPrbStart + SCH_SSB_NUM_PRB -1; } else if(sib1Occasion) { - broadcastPrbStart = cell->cellCfg.sib1SchCfg.sib1PdschCfg.pdschFreqAlloc.freqAlloc.startPrb; - broadcastPrbEnd = broadcastPrbStart + cell->cellCfg.sib1SchCfg.sib1PdschCfg.pdschFreqAlloc.freqAlloc.numPrb -1; + broadcastPrbStart = cell->sib1SchCfg.sib1PdcchCfg.dci[0].pdschCfg.pdschFreqAlloc.startPrb; + broadcastPrbEnd = broadcastPrbStart + cell->sib1SchCfg.sib1PdcchCfg.dci[0].pdschCfg.pdschFreqAlloc.numPrb -1; } /* Iterate through all free PRB blocks */ @@ -1215,6 +1385,10 @@ uint8_t allocatePrbDl(SchCellCb *cell, SlotTimingInfo slotTime, \ return RFAILED; } } + + /* Update statistics of PRB usage if stats calculation is enabled */ + if(schCb[cell->instIdx].statistics.activeKpiList.dlTotPrbUseList.count) + prbAlloc->numPrbAlloc += numPrb; /* Update the remaining number for free PRBs */ removeAllocatedPrbFromFreePrbList(&prbAlloc->freePrbBlockList, freePrbNode, *startPrb, numPrb); @@ -1252,8 +1426,15 @@ uint8_t allocatePrbUl(SchCellCb *cell, SlotTimingInfo slotTime, \ bool isPrachOccasion; FreePrbBlock *freePrbBlock = NULLP; CmLList *freePrbNode = NULLP; - SchPrbAlloc *prbAlloc = &cell->schUlSlotInfo[slotTime.slot]->prbAlloc; + SchPrbAlloc *prbAlloc = NULLP; + if(cell == NULLP) + { + DU_LOG("\nERROR --> SCH : allocatePrbUl(): Received cellCb is null"); + return RFAILED; + } + + prbAlloc = &cell->schUlSlotInfo[slotTime.slot]->prbAlloc; /* If startPrb is set to MAX_NUM_RB, it means startPrb is not known currently. * Search for an appropriate location in PRB grid and allocate requested resources */ if(*startPrb == MAX_NUM_RB) @@ -1262,7 +1443,7 @@ uint8_t allocatePrbUl(SchCellCb *cell, SlotTimingInfo slotTime, \ isPrachOccasion = schCheckPrachOcc(cell, slotTime); if(isPrachOccasion) { - prachStartPrb = cell->cellCfg.schRachCfg.msg1FreqStart; + prachStartPrb = cell->cellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.prachCfgGeneric.msg1FreqStart; prachNumPrb = schCalcPrachNumRb(cell); prachEndPrb = prachStartPrb + prachNumPrb -1; } @@ -1342,71 +1523,23 @@ uint8_t allocatePrbUl(SchCellCb *cell, SlotTimingInfo slotTime, \ } } + /* Update statistics of PRB usage if stats calculation is enabled */ + if(schCb[cell->instIdx].statistics.activeKpiList.ulTotPrbUseList.count) + prbAlloc->numPrbAlloc += numPrb; + /* Update the remaining number for free PRBs */ removeAllocatedPrbFromFreePrbList(&prbAlloc->freePrbBlockList, freePrbNode, *startPrb, numPrb); return ROK; } -/******************************************************************* - * - * @brief Add UE to ueToBeScheduled List - * - * @details - * - * Function : addUeToBeScheduled - * - * Functionality: - * Search if UE entry present in the list - * If yes, return. - * If no, add UE to the list - * - * @params[in] Cell control block - * Ue Idx to be added - * - * @return ROK - success - * RFAILED - failure - * - * ****************************************************************/ -uint8_t addUeToBeScheduled(SchCellCb *cell, uint8_t ueIdToAdd) -{ - uint8_t *ueId; - CmLList *node; - - /* Search if UE entry is already present in ueToBeScheduled list. - * If yes, another entry for same UE not needed. Hence, return */ - node = cell->ueToBeScheduled.first; - while(node) - { - ueId = (uint8_t *)node->node; - if(*ueId == ueIdToAdd) - return ROK; - node = node->next; - } - - /* If UE entry not present already, add UE to the end of ueToBeScheduled list */ - SCH_ALLOC(ueId, sizeof(uint8_t)); - if(!ueId) - { - DU_LOG("\nERROR --> SCH : Memory allocation failure in addUeToBeScheduled"); - return RFAILED; - } - *ueId = ueIdToAdd; - if(addNodeToLList(&cell->ueToBeScheduled, ueId, NULLP) != ROK) - { - DU_LOG("\nERROR --> SCH : Failed to add UeIdx to cell->ueToBeScheduled list"); - return RFAILED; - } - return ROK; -} - /******************************************************************************* * * @brief Try to find Best Free Block with Max Num PRB * * @details * - * Function : searchLargestFreeBlockDL + * Function : searchLargestFreeBlock * * Functionality: * Finds the FreeBlock with MaxNum of FREE PRB considering SSB/SIB1 ocassions. @@ -1414,6 +1547,7 @@ uint8_t addUeToBeScheduled(SchCellCb *cell, uint8_t ueIdToAdd) * @params[in] I/P > prbAlloc table (FreeBlock list) * I/P > Slot timing Info * O/P > Start PRB + * I/P > Direction (UL/DL) * * * @return Max Number of Free PRB @@ -1421,38 +1555,70 @@ uint8_t addUeToBeScheduled(SchCellCb *cell, uint8_t ueIdToAdd) * * ********************************************************************************/ -uint16_t searchLargestFreeBlockDL(SchCellCb *cell, SlotTimingInfo slotTime,uint16_t *startPrb) +uint16_t searchLargestFreeBlock(SchCellCb *cell, SlotTimingInfo slotTime,uint16_t *startPrb, Direction dir) { - uint16_t broadcastPrbStart=0, broadcastPrbEnd=0, maxFreePRB = 0; - PduTxOccsaion ssbOccasion=0, sib1Occasion=0; + uint16_t reservedPrbStart=0, reservedPrbEnd=0, maxFreePRB = 0; FreePrbBlock *freePrbBlock = NULLP; CmLList *freePrbNode = NULLP; + SchPrbAlloc *prbAlloc = NULLP; + bool checkOccasion = FALSE; - SchDlSlotInfo *schDlSlotInfo = cell->schDlSlotInfo[slotTime.slot]; - SchPrbAlloc *prbAlloc = &schDlSlotInfo->prbAlloc; - - ssbOccasion = schCheckSsbOcc(cell, slotTime); - sib1Occasion = schCheckSib1Occ(cell, slotTime); + *startPrb = 0; /*Initialize the StartPRB to zero*/ - if(ssbOccasion && sib1Occasion) + /*Based on Direction, Reserved Messsages will differi.e. + * DL >> SSB and SIB1 ocassions wheres for UL, PRACH ocassions to be checked + * and reserved before allocation for dedicated DL/UL msg*/ + if(dir == DIR_DL) { - broadcastPrbStart = cell->cellCfg.ssbSchCfg.ssbOffsetPointA; - broadcastPrbEnd = broadcastPrbStart + SCH_SSB_NUM_PRB + cell->cellCfg.sib1SchCfg.sib1PdschCfg.pdschFreqAlloc.freqAlloc.numPrb -1; + SchDlSlotInfo *schDlSlotInfo = cell->schDlSlotInfo[slotTime.slot]; + PduTxOccsaion ssbOccasion=0, sib1Occasion=0; + + prbAlloc = &schDlSlotInfo->prbAlloc; + + ssbOccasion = schCheckSsbOcc(cell, slotTime); + sib1Occasion = schCheckSib1Occ(cell, slotTime); + + checkOccasion = TRUE; + if(ssbOccasion && sib1Occasion) + { + reservedPrbStart = cell->cellCfg.dlCfgCommon.schFreqInfoDlSib.offsetToPointA; + reservedPrbEnd = reservedPrbStart + SCH_SSB_NUM_PRB + \ + cell->sib1SchCfg.sib1PdcchCfg.dci[0].pdschCfg.pdschFreqAlloc.numPrb -1; + } + else if(ssbOccasion) + { + reservedPrbStart = cell->cellCfg.dlCfgCommon.schFreqInfoDlSib.offsetToPointA; + reservedPrbEnd = reservedPrbStart + SCH_SSB_NUM_PRB -1; + } + else if(sib1Occasion) + { + reservedPrbStart = cell->sib1SchCfg.sib1PdcchCfg.dci[0].pdschCfg.pdschFreqAlloc.startPrb; + reservedPrbEnd = reservedPrbStart + cell->sib1SchCfg.sib1PdcchCfg.dci[0].pdschCfg.pdschFreqAlloc.numPrb -1; + } + else + { + checkOccasion = FALSE; + } } - else if(ssbOccasion) + else if(dir == DIR_UL) { - broadcastPrbStart = cell->cellCfg.ssbSchCfg.ssbOffsetPointA; - broadcastPrbEnd = broadcastPrbStart + SCH_SSB_NUM_PRB -1; + prbAlloc = &cell->schUlSlotInfo[slotTime.slot]->prbAlloc; + + /* Check if PRACH is also scheduled in this slot */ + checkOccasion = schCheckPrachOcc(cell, slotTime); + if(checkOccasion) + { + reservedPrbStart = cell->cellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.prachCfgGeneric.msg1FreqStart; + reservedPrbEnd = reservedPrbStart + (schCalcPrachNumRb(cell)) -1; + } } - else if(sib1Occasion) + else { - broadcastPrbStart = cell->cellCfg.sib1SchCfg.sib1PdschCfg.pdschFreqAlloc.freqAlloc.startPrb; - broadcastPrbEnd = broadcastPrbStart + cell->cellCfg.sib1SchCfg.sib1PdschCfg.pdschFreqAlloc.freqAlloc.numPrb -1; + DU_LOG("\nERROR --> SCH: Invalid Direction!"); + return (maxFreePRB); } - freePrbNode = prbAlloc->freePrbBlockList.first; - *startPrb = 0; /*Initialize the StartPRB to zero*/ while(freePrbNode) { freePrbBlock = (FreePrbBlock *)freePrbNode->node; @@ -1466,27 +1632,27 @@ uint16_t searchLargestFreeBlockDL(SchCellCb *cell, SlotTimingInfo slotTime,uint1 continue; } - /* If broadcast message is scheduled in this slot, then check if its PRBs belong to the current free block. + /* If Broadcast/Prach message is scheduled in this slot, then check if its PRBs belong to the current free block. * Since SSB/SIB1 PRB location is fixed, these PRBs cannot be allocated to other message in same slot */ - if((ssbOccasion || sib1Occasion) && - ((broadcastPrbStart >= freePrbBlock->startPrb) && (broadcastPrbStart <= freePrbBlock->endPrb)) && \ - ((broadcastPrbEnd >= freePrbBlock->startPrb) && (broadcastPrbEnd <= freePrbBlock->endPrb))) + if(checkOccasion && + ((reservedPrbStart >= freePrbBlock->startPrb) && (reservedPrbStart <= freePrbBlock->endPrb)) && \ + ((reservedPrbEnd >= freePrbBlock->startPrb) && (reservedPrbEnd <= freePrbBlock->endPrb))) { /* Implmentation is done such that highest-numbered free-RB is Checked first and freePRB in this block is greater than Max till now */ - if((freePrbBlock->endPrb > broadcastPrbEnd) && ((freePrbBlock->endPrb - broadcastPrbEnd) > maxFreePRB)) + if((freePrbBlock->endPrb > reservedPrbEnd) && ((freePrbBlock->endPrb - reservedPrbEnd) > maxFreePRB)) { - /* If sufficient free PRBs are available above broadcast message*/ - *startPrb = broadcastPrbEnd + 1; - maxFreePRB = (freePrbBlock->endPrb - broadcastPrbEnd); + /* If sufficient free PRBs are available above reserved message*/ + *startPrb = reservedPrbEnd + 1; + maxFreePRB = (freePrbBlock->endPrb - reservedPrbEnd); } - /*Also check the other freeBlock (i.e. Above the broadcast message) for MAX FREE PRB*/ - if((broadcastPrbStart > freePrbBlock->startPrb) && ((broadcastPrbStart - freePrbBlock->startPrb) > maxFreePRB)) + /*Also check the other freeBlock (i.e. Above the reserved message) for MAX FREE PRB*/ + if((reservedPrbStart > freePrbBlock->startPrb) && ((reservedPrbStart - freePrbBlock->startPrb) > maxFreePRB)) { - /* If free PRBs are available below broadcast message*/ + /* If free PRBs are available below reserved message*/ *startPrb = freePrbBlock->startPrb; - maxFreePRB = (broadcastPrbStart - freePrbBlock->startPrb); + maxFreePRB = (reservedPrbStart - freePrbBlock->startPrb); } } else //Best Block @@ -1503,6 +1669,1908 @@ uint16_t searchLargestFreeBlockDL(SchCellCb *cell, SlotTimingInfo slotTime,uint1 return(maxFreePRB); } +/******************************************************************************* + * + * @brief This function is used to send Slice Cfg rsp to MAC + * + * @details + * + * Function : SchSendSliceCfgRspToMac + * + * Functionality: + * function is used to send Slice Cfg rsp to MAC + * + * @params[in] Pst *pst, SchSliceCfgRsp sliceCfgRsp + * + * @return- void + * + * ********************************************************************************/ +void SchSendSliceCfgRspToMac(Inst inst, SchSliceCfgRsp sliceCfgRsp) +{ + Pst rspPst; + + memset(&rspPst, 0, sizeof(Pst)); + FILL_PST_SCH_TO_MAC(rspPst, inst); + rspPst.event = EVENT_SLICE_CFG_RSP_TO_MAC; + + MacMessageRouter(&rspPst, (void *)&sliceCfgRsp); + +} + +/******************************************************************************* + * + * @brief This function is used to store or modify the slice configuration Sch DB + * + * @details + * + * Function : addOrModifySliceCfgInSchDb + * + * Functionality: + * function is used to store or modify the slice configuration Sch DB + * + * @params[in] SchSliceCfg *storeSliceCfg, SchSliceCfgReq *cfgReq, + * SchSliceCfgRsp cfgRsp, uint8_t count + * + * @return + * ROK - Success + * RFAILED - Failure + * + * ********************************************************************************/ +uint8_t addSliceCfgInSchDb(CmLListCp *sliceCfgInDb, SchRrmPolicyOfSlice *cfgReq) +{ + SchRrmPolicyOfSlice *sliceToStore; + + SCH_ALLOC(sliceToStore, sizeof(SchRrmPolicyOfSlice)); + if(sliceToStore) + { + memcpy(&sliceToStore->snssai, &cfgReq->snssai, sizeof(Snssai)); + memcpy(&sliceToStore->rrmPolicyRatioInfo, &cfgReq->rrmPolicyRatioInfo, sizeof(SchRrmPolicyRatio)); + addNodeToLList(sliceCfgInDb, sliceToStore, NULL); + } + else + { + DU_LOG("\nERROR --> SCH : Memory allocation failed in addOrModifySliceCfgInSchDb"); + return RFAILED; + } + return ROK; +} + +/******************************************************************************* + * + * @brief fill slice configuration response + * + * @details + * + * Function : fillSliceCfgRsp + * + * Functionality: + * fill slice configuration response + * + * @params[in] SchCellCb, SchSliceCfgReq, SchSliceCfgRsp,uint8_t count + * + * @return + * ROK - Success + * RFAILED - Failure + * + * ********************************************************************************/ +uint8_t fillSliceCfgRsp(Inst inst, CmLListCp *storedSliceCfg, SchCellCb *cellCb, SchSliceCfgReq *schSliceCfgReq) +{ + SchMacRsp sliceFound; + uint8_t cfgIdx = 0, sliceIdx = 0, plmnIdx = 0, ret =ROK; + SchSliceCfgRsp schSliceCfgRsp; + + for(cfgIdx = 0; cfgIdxnumOfConfiguredSlice; cfgIdx++) + { + sliceFound = RSP_NOK; + /* Here comparing the slice cfg request with the slice stored in cellCfg */ + for(plmnIdx = 0; plmnIdx < MAX_PLMN; plmnIdx++) + { + for(sliceIdx = 0; sliceIdxcellCfg.plmnInfoList[plmnIdx].suppSliceList.numSupportedSlices; sliceIdx++) + { + /* If we find the SliceCfgReq's SNSSAI in CellCb's SNSSAI DB, we mark this slice as configured and add it to Sch's DB. */ + if(!memcmp(&schSliceCfgReq->listOfSlices[cfgIdx]->snssai, cellCb->cellCfg.plmnInfoList[plmnIdx].suppSliceList.snssai[sliceIdx], sizeof(Snssai))) + { + if(addSliceCfgInSchDb(storedSliceCfg, schSliceCfgReq->listOfSlices[cfgIdx]) == ROK) + { + sliceFound = RSP_OK; + schSliceCfgRsp.cause = SUCCESSFUL; + } + else + { + DU_LOG("\nERROR --> SCH : Failed to store slice configuration in SchDb"); + schSliceCfgRsp.cause = RESOURCE_UNAVAILABLE; + ret = RFAILED; + } + plmnIdx = MAX_PLMN; + break; + } + } + } + + if((sliceFound == RSP_NOK) && (schSliceCfgRsp.cause != RESOURCE_UNAVAILABLE)) + schSliceCfgRsp.cause = SLICE_NOT_FOUND; + + schSliceCfgRsp.snssai = schSliceCfgReq->listOfSlices[cfgIdx]->snssai; + schSliceCfgRsp.rsp = sliceFound; + SchSendSliceCfgRspToMac(inst, schSliceCfgRsp); + } + return ret; +} + +/******************************************************************************* + * + * @brief This function is used to free the slice cfg and re cfg request pointer + * + * @details + * + * Function : freeSchSliceCfgReq + * + * Functionality: + * function is used to free the slice cfg and re cfg request pointer + * + * @params[in] Pst *pst, SchSliceCfgReq *schSliceCfgReq + * + * @return + * ROK - Success + * RFAILED - Failure + * ********************************************************************************/ +void freeSchSliceCfgReq(SchSliceCfgReq *sliceCfgReq) +{ + uint8_t cfgIdx = 0; + + if(sliceCfgReq) + { + if(sliceCfgReq->numOfConfiguredSlice) + { + for(cfgIdx = 0; cfgIdxnumOfConfiguredSlice; cfgIdx++) + { + if(sliceCfgReq->listOfSlices[cfgIdx]) + { + SCH_FREE(sliceCfgReq->listOfSlices[cfgIdx], sizeof(SchRrmPolicyOfSlice)); + } + } + SCH_FREE(sliceCfgReq->listOfSlices, sliceCfgReq->numOfConfiguredSlice * sizeof(SchRrmPolicyOfSlice*)); + } + SCH_FREE(sliceCfgReq, sizeof(SchSliceCfgReq)); + } +} +/******************************************************************************* + * + * @brief This function is used to store the slice configuration Sch DB + * + * @details + * + * Function : SchProcSliceCfgReq + * + * Functionality: + * function is used to store the slice configuration Sch DB + * + * @params[in] Pst *pst, SchSliceCfgReq *schSliceCfgReq + * + * @return + * ROK - Success + * RFAILED - Failure + * + * ********************************************************************************/ +uint8_t SchProcSliceCfgReq(Pst *pst, SchSliceCfgReq *schSliceCfgReq) +{ + uint8_t ret = ROK; + Inst inst = pst->dstInst - SCH_INST_START; + + DU_LOG("\nINFO --> SCH : Received Slice Cfg request from MAC"); + if(schSliceCfgReq) + { + if(schSliceCfgReq->listOfSlices) + { + /* filling the slice configuration response of each slice */ + if(fillSliceCfgRsp(inst, &schCb[inst].sliceCfg, schCb[inst].cells[0], schSliceCfgReq) != ROK) + { + DU_LOG("\nERROR --> SCH : Failed to fill the slice cfg rsp"); + ret = RFAILED; + } + freeSchSliceCfgReq(schSliceCfgReq); + } + } + else + { + DU_LOG("\nERROR --> SCH : Received SchSliceCfgReq is NULL"); + ret = RFAILED; + } + return ret; +} + +/******************************************************************************* + * + * @brief This function is used to send Slice re Cfg rsp to MAC + * + * @details + * + * Function : SchSendSliceRecfgRspToMac + * + * Functionality: + * function is used to send Slice re Cfg rsp to MAC + * + * @params[in] Pst *pst, SchSliceRecfgRsp schSliceRecfgRsp + * + * @return- void + * + * ********************************************************************************/ +void SchSendSliceRecfgRspToMac(Inst inst, SchSliceRecfgRsp schSliceRecfgRsp) +{ + Pst rspPst; + + memset(&rspPst, 0, sizeof(Pst)); + FILL_PST_SCH_TO_MAC(rspPst, inst); + rspPst.event = EVENT_SLICE_RECFG_RSP_TO_MAC; + + MacMessageRouter(&rspPst, (void *)&schSliceRecfgRsp); +} + +/******************************************************************************* + * + * @brief fill slice configuration response + * + * @details + * + * Function : fillSliceRecfgRsp + * + * Functionality: fill slice reconfiguration response + * + * @params[in] SchCellCb, SchSliceCfgReq, SchSliceCfgRsp,uint8_t count + * + * @return + * ROK - Success + * RFAILED - Failure + * + * ********************************************************************************/ + +uint8_t fillSliceRecfgRsp(Inst inst, CmLListCp *storedSliceCfg, SchSliceRecfgReq *schSliceRecfgReq) +{ + SchMacRsp sliceFound; + uint8_t cfgIdx = 0; + SchRrmPolicyOfSlice *rrmPolicyOfSlices; + SchSliceRecfgRsp schSliceRecfgRsp; + + for(cfgIdx = 0; cfgIdxnumOfConfiguredSlice; cfgIdx++) + { + sliceFound = RSP_NOK; + /* Here comparing the slice recfg request with the StoredSliceCfg */ + CmLList *sliceCfg = storedSliceCfg->first; + + while(sliceCfg) + { + rrmPolicyOfSlices = (SchRrmPolicyOfSlice*)sliceCfg->node; + + if(rrmPolicyOfSlices && (memcmp(&schSliceRecfgReq->listOfSlices[cfgIdx]->snssai, &(rrmPolicyOfSlices->snssai), sizeof(Snssai)) == 0)) + { + memcpy(&rrmPolicyOfSlices->rrmPolicyRatioInfo, &schSliceRecfgReq->listOfSlices[cfgIdx]->rrmPolicyRatioInfo, sizeof(SchRrmPolicyRatio)); + sliceFound = RSP_OK; + break; + } + sliceCfg = sliceCfg->next; + } + + schSliceRecfgRsp.snssai = schSliceRecfgReq->listOfSlices[cfgIdx]->snssai; + schSliceRecfgRsp.rsp = sliceFound; + if(schSliceRecfgRsp.rsp == RSP_OK) + schSliceRecfgRsp.cause = SUCCESSFUL; + else + schSliceRecfgRsp.cause = SLICE_NOT_FOUND; + SchSendSliceRecfgRspToMac(inst, schSliceRecfgRsp); + } + return ROK; +} +/******************************************************************************* + * + * @brief This function is used to store the slice reconfiguration Sch DB + * + * @details + * + * Function : SchProcSliceRecfgReq + * + * Functionality: + * function is used to store the slice re configuration Sch DB + * + * @params[in] Pst *pst, SchSliceRecfgReq *schSliceRecfgReq + * + * @return + * ROK - Success + * RFAILED - Failure + * + * ********************************************************************************/ +uint8_t SchProcSliceRecfgReq(Pst *pst, SchSliceRecfgReq *schSliceRecfgReq) +{ + uint8_t ret = ROK; + Inst inst = pst->dstInst - SCH_INST_START; + + DU_LOG("\nINFO --> SCH : Received Slice ReCfg request from MAC"); + if(schSliceRecfgReq) + { + if(schSliceRecfgReq->listOfSlices) + { + /* filling the slice configuration response of each slice */ + if(fillSliceRecfgRsp(inst, &schCb[inst].sliceCfg, schSliceRecfgReq) != ROK) + { + DU_LOG("\nERROR --> SCH : Failed to fill sch slice cfg response"); + ret = RFAILED; + } + freeSchSliceCfgReq(schSliceRecfgReq); + } + } + else + { + DU_LOG("\nERROR --> SCH : Received SchSliceRecfgReq is NULL"); + + } + return ret; +} + +/**************************************************************************** + * + * @brief Stores the Paging Configuration from DU APP in CellCb + * + * @details + * + * Function : schProcPagingParam + * + * Functionality: + * Process the Paging Configuration when FirstPDCCHMonitoring for + * Paging Ocassion is not present. + * + * As per 38.304 Sec 7.1, + * "When firstPDCCH-MonitoringOccasionOfPO is present, the + * starting PDCCH monitoring occasion number of (i_s + 1)th PO is the + * (i_s + 1)th value of the firstPDCCHMonitoringOccasionOfPO + * parameter; otherwise, it is equal to i_s * S." + * "S = number of actual transmitted SSBs determined according + * to ssb-PositionsInBurst in SIB1" + * + * @params[in] SchCellCb *cell + * + * @return void + * + *************************************************************************/ +void schProcPagingCfg(SchCellCb *cell) +{ + SchPcchCfg *pageCfgRcvd = NULL; + uint8_t i_sIdx = 0; + + pageCfgRcvd = &(cell->cellCfg.dlCfgCommon.schPcchCfg); + + if(pageCfgRcvd->poPresent == TRUE) + { + /*Fetching first Pdcch Monitoring Occasion for SFN (i_s + 1)th*/ + for(i_sIdx = 0; i_sIdx < pageCfgRcvd->numPO; i_sIdx++) + { + cell->pageCb.pagMonOcc[i_sIdx].pagingOccSlot = pageCfgRcvd->pagingOcc[i_sIdx] / MAX_SYMB_PER_SLOT ; + if ((pageCfgRcvd->pagingOcc[i_sIdx] % MAX_SYMB_PER_SLOT) != 0 ) + { + cell->pageCb.pagMonOcc[i_sIdx].pagingOccSlot++; + } + + cell->pageCb.pagMonOcc[i_sIdx].frameOffset = 0; + + } + } + else + { + schCfgPdcchMonOccOfPO(cell); + } +} + +/**************************************************************************** + * + * @brief Calculate PO if not present in Configuration + * + * @details + * + * Function : schCfgPdcchMonOccOfPO + * + * Functionality: In this function, PO are calculated i_s * S because + * FirstPDCCHMonitoring_ForPO is not present. + * + * @params[in] SchCellCb *cellCb + * + * @return void + * + *************************************************************************/ +void schCfgPdcchMonOccOfPO(SchCellCb *cell) +{ + uint8_t cnt = 0, incr = 1, i_sIdx = 0, frameOffSet = 0; + uint8_t nsValue = cell->cellCfg.dlCfgCommon.schPcchCfg.numPO; + uint8_t totalNumSsb = countSetBits(cell->cellCfg.ssbPosInBurst[0]); + SlotTimingInfo tmpTimingInfo, pdcchTime; + + /*Starting with First Sfn and slot*/ + tmpTimingInfo.sfn = 0; + tmpTimingInfo.slot = 0; + + pdcchTime = tmpTimingInfo; + + while(i_sIdx < nsValue) + { + /*Increment frame Offset if PO falls on next SFN*/ + if(pdcchTime.sfn != tmpTimingInfo.sfn) + { + frameOffSet++; + } + pdcchTime = tmpTimingInfo; + schIncrSlot(&(tmpTimingInfo), incr, cell->numSlots); + + if (i_sIdx == 0) + { + cell->pageCb.pagMonOcc[i_sIdx].pagingOccSlot = pdcchTime.slot; + cell->pageCb.pagMonOcc[i_sIdx].frameOffset = frameOffSet; + i_sIdx++; + } + else + { + cnt++; + if((cnt == totalNumSsb) && (i_sIdx < MAX_PO_PER_PF)) + { + cell->pageCb.pagMonOcc[i_sIdx].pagingOccSlot = pdcchTime.slot; + cell->pageCb.pagMonOcc[i_sIdx].frameOffset = frameOffSet; + cnt = 0; + i_sIdx++; + } + } + } +} + +/**************************************************************************** + * + * @brief Storing the paging information in SCH database + * + * @details + * + * Function : schAddPagingIndtoList + * + * Functionality: Storing the paging information in SCH database + * + * @params[in] CmLListCp *storedPageList, CmLList *pageIndInfo + * + * @return ROK - sucess + * RFAILED - failure + * + *************************************************************************/ +uint8_t schAddPagingIndtoList(CmLListCp *storedPageList,void * pageIndInfo) +{ + CmLList *firstNodeOfList = NULLP; + CmLList *currentNodeInfo = NULLP; + SchPageInfo *tempNode = NULLP, *recvdNode = NULLP; + + recvdNode = (SchPageInfo*) pageIndInfo; + CM_LLIST_FIRST_NODE(storedPageList,firstNodeOfList); + + SCH_ALLOC(currentNodeInfo, sizeof(CmLList)); + if(!currentNodeInfo) + { + DU_LOG("\nERROR --> SCH : schAddPagingIndtoList() : Memory allocation failed"); + return RFAILED; + } + + currentNodeInfo->node = (PTR)pageIndInfo; + while(firstNodeOfList) + { + tempNode = (SchPageInfo*)(firstNodeOfList->node); + if ((recvdNode->pageTxTime.slot < tempNode->pageTxTime.slot)) + { + cmLListInsCrnt(storedPageList, currentNodeInfo); + break; + } + else if ((recvdNode->pageTxTime.slot == tempNode->pageTxTime.slot)) + { + DU_LOG("\nERROR --> SCH : schAddPagingIndtoList() : Slot[%d] is already present in the list", recvdNode->pageTxTime.slot); + return RFAILED; + } + else + { + CM_LLIST_NEXT_NODE(storedPageList, firstNodeOfList); + } + } + + if(!firstNodeOfList) + { + cmLListAdd2Tail(storedPageList, currentNodeInfo); + } + DU_LOG("\nDEBUG --> SCH : Paging information is stored successfully for PF:%d, Slot:%d",\ + recvdNode->pageTxTime.sfn, recvdNode->pageTxTime.slot); + return ROK; +} + +/**************************************************************************** + * + * @brief Process paging indication at SCH recevied form MAC + * + * @details + * + * Function : SchProcPagingInd + * + * Functionality: Process paging indication at SCH recevied form MAC + * + * @params[in] Pst *pst, SchPageInd *pageInd + * + * @return void + * + *************************************************************************/ +uint8_t SchProcPagingInd(Pst *pst, SchPageInd *pageInd) +{ + uint8_t ret = RFAILED; + uint16_t cellIdx = 0; + Inst inst = pst->dstInst - SCH_INST_START; + SchCellCb *cellCb = NULLP; + SchPageInfo *pageInfo = NULLP; + + if(pageInd) + { + DU_LOG("\nDEBUG --> SCH : Received paging indication from MAC for cellId[%d]",\ + pageInd->cellId); + + /* Fetch Cell CB */ + for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++) + { + if((schCb[inst].cells[cellIdx]) && (schCb[inst].cells[cellIdx]->cellId == pageInd->cellId)) + { + cellCb = schCb[inst].cells[cellIdx]; + break; + } + } + if(cellCb) + { + if(pageInd->i_s > cellCb->cellCfg.dlCfgCommon.schPcchCfg.numPO) + { + DU_LOG("\nERROR --> SCH : SchProcPagingInd(): i_s should not be greater than number of paging occasion"); + } + else + { + SCH_ALLOC(pageInfo, sizeof(SchPageInfo)); + if(pageInfo) + { + pageInfo->pf = pageInd->pf; + pageInfo->i_s = pageInd->i_s; + pageInfo->pageTxTime.cellId = pageInd->cellId; + pageInfo->pageTxTime.sfn = (pageInd->pf + cellCb->pageCb.pagMonOcc[pageInd->i_s].frameOffset) % MAX_SFN; + pageInfo->pageTxTime.slot = cellCb->pageCb.pagMonOcc[pageInd->i_s].pagingOccSlot; + pageInfo->mcs = DEFAULT_MCS; + pageInfo->msgLen = pageInd->pduLen; + SCH_ALLOC(pageInfo->pagePdu, pageInfo->msgLen); + if(!pageInfo->pagePdu) + { + DU_LOG("\nERROR --> SCH : SchProcPagingInd(): Failed to allocate memory"); + } + else + { + memcpy(pageInfo->pagePdu, pageInd->pagePdu, pageInfo->msgLen); + ret = schAddPagingIndtoList(&cellCb->pageCb.pageIndInfoRecord[pageInfo->pageTxTime.sfn], pageInfo); + if(ret != ROK) + { + DU_LOG("\nERROR --> SCH : SchProcPagingInd(): Failed to store paging record"); + } + } + } + else + { + DU_LOG("\nERROR --> SCH : SchProcPagingInd(): Failed to allocate memory"); + } + } + } + else + { + DU_LOG("\nERROR --> SCH : Cell ID [%d] not found", pageInd->cellId); + } + SCH_FREE(pageInd->pagePdu, pageInd->pduLen); + SCH_FREE(pageInd, sizeof(SchPageInd)); + } + else + { + DU_LOG("\nERROR --> SCH : SchProcPagingInd(): Received null pointer"); + } + return ret; +} + + +/*********************************************************** + * + * Func : SchFillCfmPst + * + * + * Desc : Fills the Confirmation Post Structure cfmPst using the reqPst + * and the cfm->hdr.response. + * + * + * Ret : Void + * + * Notes: + * + * File : rg_sch_lmm.c + * + **********************************************************/ +Void SchFillCfmPst +( +Pst *reqPst, +Pst *cfmPst, +RgMngmt *cfm +) +{ + Inst inst; + + inst = (reqPst->dstInst - SCH_INST_START); + + cfmPst->srcEnt = ENTMAC; + cfmPst->srcInst = (Inst) 1; + cfmPst->srcProcId = schCb[inst].schInit.procId; + cfmPst->dstEnt = ENTMAC; + cfmPst->dstInst = (Inst) 0; + cfmPst->dstProcId = reqPst->srcProcId; + + cfmPst->selector = cfm->hdr.response.selector; + cfmPst->region = cfm->hdr.response.mem.region; + cfmPst->pool = cfm->hdr.response.mem.pool; + + return; +} + +/******************************************************************* + * + * @brief Processes DL CQI ind from MAC + * + * @details + * + * Function : SchProcDlCqiInd + * + * Functionality: + * Processes DL CQI ind from MAC + * + * @params[in] + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t SchProcDlCqiInd(Pst *pst, SchDlCqiInd *dlCqiInd) +{ + uint8_t ret = ROK; + uint16_t ueId = 0, cellIdx = 0; + SchUeCb *ueCb = NULLP; + SchCellCb *cell = NULLP; + Inst inst = pst->dstInst-SCH_INST_START; + + if(!dlCqiInd) + { + DU_LOG("\nERROR --> SCH : SchProcDlCqiInd(): CQI Ind is empty"); + ret = RFAILED; + } + else + { + GET_CELL_IDX(dlCqiInd->cellId, cellIdx); + cell = schCb[inst].cells[cellIdx]; + if(cell == NULLP) + { + DU_LOG("\nERROR --> SCH : SchProcDlCqiInd(): cell Id[%d] not found", dlCqiInd->cellId); + ret = RFAILED; + } + else + { + if(cell->cellId == dlCqiInd->cellId) + { + GET_UE_ID(dlCqiInd->crnti, ueId); + ueCb = &cell->ueCb[ueId-1]; + if(ueCb->crnti != dlCqiInd->crnti) + { + DU_LOG("\nERROR --> SCH : SchProcDlCqiInd(): UeCb for received crnti[%d] not found", dlCqiInd->crnti); + ret = RFAILED; + } + else + { + /*TODO: complete the processing of DL CQI Ind*/ + } + } + else + { + DU_LOG("\nERROR --> SCH : SchProcDlCqiInd(): Received cell Id[%d] from MAC is not matching with CellID[%d] in SCH Cb",\ + dlCqiInd->cellId, cell->cellId); + ret = RFAILED; + } + } + } + return ret; +} + +/******************************************************************* + * + * @brief Processes UL CQI ind from MAC + * + * @details + * + * Function : SchProcUlCqiInd + * + * Functionality: + * Processes UL CQI ind from MAC + * + * @params[in] + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t SchProcUlCqiInd(Pst *pst, SchUlCqiInd *ulCqiInd) +{ + uint8_t ret = ROK; + uint16_t ueId = 0, cellIdx = 0; + SchUeCb *ueCb = NULLP; + SchCellCb *cell = NULLP; + Inst inst = pst->dstInst-SCH_INST_START; + + if(!ulCqiInd) + { + DU_LOG("\nERROR --> SCH : SchProcUlCqiInd(): CQI Ind is empty"); + ret = RFAILED; + } + else + { + GET_CELL_IDX(ulCqiInd->cellId, cellIdx); + cell = schCb[inst].cells[cellIdx]; + if(cell == NULLP) + { + DU_LOG("\nERROR --> SCH : SchProcUlCqiInd(): cell Id[%d] not found", ulCqiInd->cellId); + ret = RFAILED; + } + else + { + if(cell->cellId == ulCqiInd->cellId) + { + GET_UE_ID(ulCqiInd->crnti, ueId); + ueCb = &cell->ueCb[ueId-1]; + if(ueCb->crnti != ulCqiInd->crnti) + { + DU_LOG("\nERROR --> SCH : SchProcUlCqiInd(): UeCb for received crnti[%d] not found",ulCqiInd->crnti); + ret = RFAILED; + } + else + { + /*TODO: complete the processing of UL CQI Ind*/ + } + } + else + { + DU_LOG("\nERROR --> SCH : SchProcUlCqiInd(): Received cell Id[%d] from MAC is not matching with CellId[%d] in SCH Cb",\ + ulCqiInd->cellId, cell->cellId); + ret = RFAILED; + } + } + } + return ret; +} + +/******************************************************************* + * + * @brief Processes PHR ind from MAC + * + * @details + * + * Function : SchProcPhrInd + * + * Functionality: + * Processes PHR ind from MAC + * + * @params[in] + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t SchProcPhrInd(Pst *pst, SchPwrHeadroomInd *schPhrInd) +{ + uint8_t ret = ROK; + uint16_t ueId = 0, cellIdx = 0; + SchUeCb *ueCb = NULLP; + SchCellCb *cell = NULLP; + Inst inst = pst->dstInst-SCH_INST_START; + + if(!schPhrInd) + { + DU_LOG("\nERROR --> SCH : SchProcPhrInd(): PHR is empty"); + ret = RFAILED; + } + else + { + GET_CELL_IDX(schPhrInd->cellId, cellIdx); + cell = schCb[inst].cells[cellIdx]; + if(cell == NULLP) + { + DU_LOG("\nERROR --> SCH : schProcPhrInd(): cell Id[%d] is not found", schPhrInd->cellId); + ret = RFAILED; + } + else + { + if(cell->cellId == schPhrInd->cellId) + { + GET_UE_ID(schPhrInd->crnti, ueId); + ueCb = &cell->ueCb[ueId-1]; + if(ueCb->crnti != schPhrInd->crnti) + { + DU_LOG("\nERROR --> SCH : SchProcPhrInd(): UeCb for received crnti[%d] not found",schPhrInd->crnti); + ret = RFAILED; + } + else + { + /*TODO: complete the processing of PHR Ind*/ + } + } + else + { + DU_LOG("\nERROR --> SCH : SchProcPhrInd(): Mismatch between Received cell Id[%d] from MAC and CellID[%d] in SCH CB ",\ + schPhrInd->cellId, cell->cellId); + ret = RFAILED; + } + } + } + return ret; +} + +/******************************************************************* + * + * @brief Fill and send statistics response to MAC + * + * @details + * + * Function : SchSendStatsRspToMac + * + * Functionality: Fill and send statistics response to MAC + * + * @params[in] Inst inst, SchMacRsp result + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t SchSendStatsRspToMac(SchStatsRsp *statsRsp) +{ + Pst rspPst; + uint8_t ret = ROK; + SchStatsRsp *schStatsRsp; + + DU_LOG("\nINFO --> SCH : Filling statistics response"); + SCH_ALLOC(schStatsRsp, sizeof(SchStatsRsp)); + if(schStatsRsp == NULLP) + { + DU_LOG("\nERROR --> SCH : Failed to allocate memory in SchSendStatsRspToMac()"); + return RFAILED; + } + + memcpy(schStatsRsp, statsRsp, sizeof(SchStatsRsp)); + memset(statsRsp, 0, sizeof(SchStatsRsp)); + + /* Filling response post */ + memset(&rspPst, 0, sizeof(Pst)); + FILL_PST_SCH_TO_MAC(rspPst, inst); + rspPst.event = EVENT_STATISTICS_RSP_TO_MAC; + + ret = MacMessageRouter(&rspPst, (void *)schStatsRsp); + if(ret == RFAILED) + { + DU_LOG("\nERROR --> SCH : SchSendStatsRspToMac(): Failed to send Statistics Response"); + return ret; + } + return ret; +} + +/******************************************************************* + * + * @brief Rejects all statistics group requested by MAC + * + * @details + * + * Function : SchRejectAllStats + * + * Functionality: Add all statistics group received in statistics + * request from MAC, to Reject-Stats-Group-List in statistics + * response to MAC + * + * @params[in] Statistics request from MAC + * Cause of rejection + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t SchRejectAllStats(SchStatsReq *schStatsReq, CauseOfResult cause) +{ + uint8_t grpIdx = 0; + SchStatsRsp schStatsRsp; + + memset(&schStatsRsp, 0, sizeof(SchStatsRsp)); + + /* Copying all stats group from stats request to stats response */ + schStatsRsp.subscriptionId = schStatsReq->subscriptionId; + for(grpIdx = 0; grpIdx < schStatsReq->numStatsGroup; grpIdx++) + { + schStatsRsp.statsGrpRejectedList[grpIdx].groupId = schStatsReq->statsGrpList[grpIdx].groupId; + schStatsRsp.statsGrpRejectedList[grpIdx].cause = cause; + } + schStatsRsp.numGrpRejected = schStatsReq->numStatsGroup; + + return SchSendStatsRspToMac(&schStatsRsp); +} + +/******************************************************************* + * + * @brief Add active KPI pointers to KPI-Active-List + * + * @details + * + * Function : schAddToKpiActiveList + * + * Functionality: For each active statistics group for which timer + * is running, add its KPI pointer to KPI-Active-List. + * Use case : + * When it is needed to update a KPI parameters, we need not + * traverse all statistics group and all KPIs within a group + * to get the specific KPI pointer to be updated. + * Instead, we can traverse through KPI-Active-List and update + * all entries in this list. + * + * @params[in] Pointer to the prb usage info link list + * Pointer to the stats ccnfig which we need to add + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t schAddToKpiActiveList(CmLListCp *kpiList, PTR kpiStatsInfo) +{ + CmLList *node = NULLP; + + SCH_ALLOC(node, sizeof(CmLList)); + if(node) + { + node->node = kpiStatsInfo; + cmLListAdd2Tail(kpiList, node); + return ROK; + } + DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d",__func__, __LINE__); + return RFAILED; +} + + /******************************************************************* + * + * @brief add the stats group information in statistics's statsGrpList + * + * @details + * + * Function : schAddToStatsGrpList + * + * Functionality: add the stats group information in statsGrpList + * [Step 1] - Allocating the memory for the stats group in which + * we need to fill into the list as a node. + * [Step 2] - If allocation is successful then start traversing + * each measurment cfg index of received group info. + * [Step 2.1] Validate all measurements. If validation succeeds, go + * to [step 2.2]. Otherwise, reject the stats group and go to step 3. + * [Step 2.2] Add each KPI/measurementCfg into activeKpiList one by one. + * If it fails for any KPI, reject the whole statsGrp and go to step 3.. + * [Step 2.3] Fill other group related information + * [Step 2.4] Initialise and start timer + * [Step 2.5] Once all validation and configuration is successful, add + * statsGrp node into statistic's StatsGrpList. + * [Step 2.5.1] If node successfully added to the list, then + * fill the group related info in stats rsp's accepted list. + * [Step 2.5.2] Else goto step 3 + * [Step 3] - If failed fill the group related info in stats rsp's + * rejected list. + * + * @params[in] + * Inst + * Pointer to the stats rsp + * Subscription Id + * Stats Grp Info which needs to be store in the list + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ + +uint8_t schAddToStatsGrpList(Inst inst, struct schStatsRsp *statsRsp, uint64_t subscriptionId, SchStatsGrpInfo *grpInfo) +{ + uint8_t ret =ROK; + uint8_t grpIdx=0; + uint8_t reqMeasIdx=0; + CauseOfResult cause; + bool measTypeInvalid=false; + CmLList *statsGrpNode=NULLP; + SchStatsGrp *grpInfoDb = NULLP; + + /* Step 1 */ + SCH_ALLOC(grpInfoDb, sizeof(SchStatsGrp)); + if(grpInfoDb == NULLP) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d",__func__, __LINE__); + cause = RESOURCE_UNAVAILABLE; + ret = RFAILED; + } + else + { + /* Step 2 */ + for(reqMeasIdx = 0; reqMeasIdx < grpInfo->numStats; reqMeasIdx++) + { + /* Step 2.1 */ + switch(grpInfo->statsList[reqMeasIdx]) + { + case SCH_DL_TOTAL_PRB_USAGE: + { + SCH_ALLOC(grpInfoDb->kpiStats.dlTotalPrbUsage, sizeof(TotalPrbUsage)); + if(!grpInfoDb->kpiStats.dlTotalPrbUsage) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d",__func__, __LINE__); + measTypeInvalid = true; + cause = RESOURCE_UNAVAILABLE; + break; + } + break; + } + + case SCH_UL_TOTAL_PRB_USAGE: + { + SCH_ALLOC(grpInfoDb->kpiStats.ulTotalPrbUsage, sizeof(TotalPrbUsage)); + if(!grpInfoDb->kpiStats.ulTotalPrbUsage) + { + DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at line %d",__func__, __LINE__); + measTypeInvalid = true; + cause = RESOURCE_UNAVAILABLE; + break; + } + break; + } + + default: + { + DU_LOG("\nERROR --> SCH : SchProcStatsReq: Invalid measurement type [%d]", \ + grpInfo->statsList[reqMeasIdx]); + measTypeInvalid = true; + cause = PARAM_INVALID; + break; + } + } + + if(measTypeInvalid) + { + ret =RFAILED; + break; + } + } + + while(measTypeInvalid==false) + { + if(grpInfoDb->kpiStats.dlTotalPrbUsage) + { + /* Step 2.2 */ + if(schAddToKpiActiveList(&schCb[inst].statistics.activeKpiList.dlTotPrbUseList, (PTR)grpInfoDb->kpiStats.dlTotalPrbUsage)!=ROK) + { + DU_LOG("\nERROR --> E2AP : KPI addition failed in %s at %d",__func__,__LINE__); + cause = RESOURCE_UNAVAILABLE; + ret =RFAILED; + break; + } + } + + if(grpInfoDb->kpiStats.ulTotalPrbUsage) + { + /* Step 2.2 */ + if(schAddToKpiActiveList(&schCb[inst].statistics.activeKpiList.ulTotPrbUseList, (PTR)grpInfoDb->kpiStats.ulTotalPrbUsage) != ROK) + { + DU_LOG("\nERROR --> E2AP : KPI addition failed in %s at %d",__func__,__LINE__); + cause = RESOURCE_UNAVAILABLE; + ret =RFAILED; + break; + } + } + + /* Step 2.3 */ + grpInfoDb->schInst = inst; + grpInfoDb->groupId = grpInfo->groupId; + grpInfoDb->periodicity = grpInfo->periodicity; + grpInfoDb->subscriptionId = subscriptionId; + + /* Step 2.4 */ + cmInitTimers(&(grpInfoDb->periodTimer), 1); + schStartTmr(&schCb[inst], (PTR)(grpInfoDb), EVENT_STATISTICS_TMR, grpInfoDb->periodicity); + + /* Step 2.5 */ + SCH_ALLOC(statsGrpNode, sizeof(CmLList)); + if(statsGrpNode) + { + /* Step 2.5.1 */ + statsGrpNode->node = (PTR) grpInfoDb; + cmLListAdd2Tail(&schCb[inst].statistics.statsGrpList, statsGrpNode); + statsRsp->statsGrpAcceptedList[statsRsp->numGrpAccepted] = grpInfo->groupId; + statsRsp->numGrpAccepted++; + grpIdx++; + ret = ROK; + break; + } + else + { + /* Step 2.5.2 */ + DU_LOG("\nERROR --> E2AP : Memory allocation failed in %s at %d",__func__,__LINE__); + cause = RESOURCE_UNAVAILABLE; + ret = RFAILED; + break; + } + } + } + + if(ret != ROK) + { + /* Step 3 */ + if(grpInfoDb) + { + deleteStatsGrpInfo(inst, grpInfoDb); + SCH_FREE(grpInfoDb, sizeof(SchStatsGrp)); + } + statsRsp->statsGrpRejectedList[statsRsp->numGrpRejected].groupId = grpInfo->groupId; + statsRsp->statsGrpRejectedList[statsRsp->numGrpRejected].cause = cause; + statsRsp->numGrpRejected++; + return RFAILED; + } + return ROK; +} + +/******************************************************************* + * + * @brief Processes Statistics Request from MAC + * + * @details + * + * Function : SchProcStatsReq + * + * Functionality: + * + * This function process the statistics request from MAC: + * [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 + * sch-stats-response message. + * [Step 4] If a group passes all validation, it is added to SCH database. + * And the group is added to stats-group-accepted-list in sch-stats-response message. + * [Step 5] sch-stats-response is sent to du app with stats-group-rejected-list + * and stats-group-accepted-list. + * + * @params[in] Post structure + * Statistics Request from MAC + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t SchProcStatsReq(Pst *pst, SchStatsReq *statsReq) +{ + bool allocFailed = false; + uint8_t grpIdx = 0, reqGrpIdx = 0; + SchStatsGrpInfo *grpInfo = NULLP; + SchStatsRsp schStatsRsp; + Inst inst = pst->dstInst - SCH_INST_START; + + DU_LOG("\nINFO --> SCH : Received Statistics Request from MAC"); + + if(statsReq == NULLP) + { + DU_LOG("\nERROR --> SCH : SchProcStatsReq(): Received Null pointer"); + return RFAILED; + } + + /*Step -1*/ + if(schCb[inst].statistics.statsGrpList.count >= MAX_NUM_STATS_GRP) + { + DU_LOG("\nERROR --> SCH : SchProcStatsReq: Maximum number of statistics configured. \ + Cannot process new request."); + SchRejectAllStats(statsReq, RESOURCE_UNAVAILABLE); + SCH_FREE(statsReq, sizeof(SchStatsReq)); + return RFAILED; + } + + memset(&schStatsRsp, 0, sizeof(SchStatsRsp)); + + /*Step -2*/ + for(reqGrpIdx=0; reqGrpIdxnumStatsGroup && grpIdxstatsGrpList[reqGrpIdx]; + /*Step -3 */ + if(allocFailed == true) + { + schStatsRsp.statsGrpRejectedList[schStatsRsp.numGrpRejected].groupId = grpInfo->groupId; + schStatsRsp.statsGrpRejectedList[schStatsRsp.numGrpRejected].cause = RESOURCE_UNAVAILABLE; + schStatsRsp.numGrpRejected++; + } + else + { + /*Step -4 */ + if(schAddToStatsGrpList(inst, &schStatsRsp, statsReq->subscriptionId, grpInfo) != ROK) + { + DU_LOG("\nERROR --> SCH : SchProcStatsReq(): Failed to fill the stats group list"); + if((schStatsRsp.statsGrpRejectedList[schStatsRsp.numGrpRejected-1].groupId == grpInfo->groupId &&\ + (schStatsRsp.statsGrpRejectedList[schStatsRsp.numGrpRejected-1].cause == RESOURCE_UNAVAILABLE))) + { + allocFailed = true; + } + } + } + } + + schStatsRsp.subscriptionId = statsReq->subscriptionId; + SCH_FREE(statsReq, sizeof(SchStatsReq)); + + /*Step -5 */ + SchSendStatsRspToMac(&schStatsRsp); + + return ROK; +} + +/******************************************************************* + * + * @brief Fill and send statistics indication to MAC + * + * @details + * + * Function : SchSendStatsIndToMac + * + * Functionality: Fill and send statistics indication to MAC + * + * @params[in] SCH Instance + * Measurement Type + * Measurement Value + * Size of value parameter + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t SchSendStatsIndToMac(Inst inst, SchStatsInd *statsInd) +{ + Pst pst; + uint8_t ret = ROK; + +#ifdef DEBUG_PRINT + DU_LOG("\nDEBUG --> SCH : Filling statistics indication"); +#endif + + /* Filling post structure */ + memset(&pst, 0, sizeof(Pst)); + FILL_PST_SCH_TO_MAC(pst, inst); + pst.event = EVENT_STATISTICS_IND_TO_MAC; + + ret = MacMessageRouter(&pst, (void *)statsInd); + if(ret == RFAILED) + { + DU_LOG("\nERROR --> SCH : SchSendStatsIndToMac(): Failed to send Statistics Indication"); + } + return ret; +} + +/** + * @brief Handler to process Timer expiry of DL Total PRB Usage calculation + * + * @param[in] cb Control block depending on the type of the timer event. + * @param[in] tmrEvnt Timer event to be started + * + * @return Bool indicating whether the timer is running or not + * -# ROK + * -# RFAILED +*/ +double calcDlTotalPrbUsage(TotalPrbUsage *dlTotalPrbUsage) +{ + double percentageOfTotalPrbUsed = 0; + + if(dlTotalPrbUsage->totalPrbAvailForTx) + percentageOfTotalPrbUsed = ((100.0 * dlTotalPrbUsage->numPrbUsedForTx) / dlTotalPrbUsage->totalPrbAvailForTx); + + memset(dlTotalPrbUsage, 0, sizeof(TotalPrbUsage)); + + return percentageOfTotalPrbUsed; +} + +/** + * @brief Handler to check if the timer is running + * + * @param[in] cb Control block depending on the type of the timer event. + * @param[in] tmrEvnt Timer event to be started + * + * @return Bool indicating whether the timer is running or not + * -# ROK + * -# RFAILED +*/ +uint8_t calcUlTotalPrbUsage(TotalPrbUsage *ulTotalPrbUsage) +{ + double percentageOfTotalPrbUsed = 0; + + if(ulTotalPrbUsage->totalPrbAvailForTx) + percentageOfTotalPrbUsed = ((100.0 * ulTotalPrbUsage->numPrbUsedForTx) / ulTotalPrbUsage->totalPrbAvailForTx); + + memset(ulTotalPrbUsage, 0, sizeof(TotalPrbUsage)); + + return percentageOfTotalPrbUsed; +} + +/** + * @brief Calculates statistics in a group and sends + * statistics indication for this group + * + * @param[in] Statistics group info + * + * @return + * -# ROK + * -# RFAILED +*/ +uint8_t schCalcAndSendGrpStats(SchStatsGrp *grpInfo) +{ + uint8_t measStatsIdx = 0; + SchStatsInd statsInd; + + memset(&statsInd, 0, sizeof(SchStatsInd)); + statsInd.subscriptionId = grpInfo->subscriptionId; + statsInd.groupId = grpInfo->groupId; + + if(grpInfo->kpiStats.dlTotalPrbUsage) + { + statsInd.measuredStatsList[measStatsIdx].type = SCH_DL_TOTAL_PRB_USAGE; + statsInd.measuredStatsList[measStatsIdx].value = calcDlTotalPrbUsage(grpInfo->kpiStats.dlTotalPrbUsage); + measStatsIdx++; + } + + if(grpInfo->kpiStats.ulTotalPrbUsage) + { + statsInd.measuredStatsList[measStatsIdx].type = SCH_UL_TOTAL_PRB_USAGE; + statsInd.measuredStatsList[measStatsIdx].value = calcUlTotalPrbUsage(grpInfo->kpiStats.ulTotalPrbUsage); + measStatsIdx++; + } + + statsInd.numStats = measStatsIdx; + + return SchSendStatsIndToMac(grpInfo->schInst, &statsInd); +} + +/******************************************************************* + * + * @brief Delete node from active kpi list + * + * @details + * + * Function :deleteNodeFrmKpiList + * + * Functionality: + * Delete statistics group + * + * @params[in] + * Kpi list from which a node needs to be deleted + * Nodes info which a node needs to be deleted + * @return void + * ****************************************************************/ + +void deleteNodeFrmKpiList(CmLListCp *kpiList, PTR kpiNodeInfoToDel) +{ + CmLList *kpiNode=NULLP; + + CM_LLIST_FIRST_NODE(kpiList, kpiNode); + while(kpiNode) + { + if(kpiNode->node == kpiNodeInfoToDel) + { + cmLListDelFrm(kpiList, kpiNode); + SCH_FREE(kpiNode, sizeof(CmLList)); + break; + } + kpiNode = kpiNode->next; + } + +} + +/******************************************************************* + * + * @brief Delete statistics group info + * + * @details + * + * Function : deleteStatsGrpInfo + * + * Functionality: + * Delete statistics group info + * + * @params[in] + * Inst + * Stats Grp info + * @return void + * + * ****************************************************************/ +void deleteStatsGrpInfo(Inst inst, SchStatsGrp *statsGrpInfo) +{ + if(statsGrpInfo) + { + if(statsGrpInfo->kpiStats.dlTotalPrbUsage) + { + deleteNodeFrmKpiList(&schCb[inst].statistics.activeKpiList.dlTotPrbUseList, (PTR) statsGrpInfo->kpiStats.dlTotalPrbUsage); + SCH_FREE(statsGrpInfo->kpiStats.dlTotalPrbUsage, sizeof(TotalPrbUsage)); + } + + if(statsGrpInfo->kpiStats.ulTotalPrbUsage) + { + deleteNodeFrmKpiList(&schCb[inst].statistics.activeKpiList.ulTotPrbUseList, (PTR) statsGrpInfo->kpiStats.ulTotalPrbUsage); + SCH_FREE(statsGrpInfo->kpiStats.ulTotalPrbUsage, sizeof(TotalPrbUsage)); + } + + if(schChkTmr((PTR)statsGrpInfo, EVENT_STATISTICS_TMR) == true) + { + schStopTmr(&schCb[inst], (PTR)statsGrpInfo, EVENT_STATISTICS_TMR); + } + + memset(statsGrpInfo, 0, sizeof(SchStatsGrp)); + } +} + +/******************************************************************* + * + * @brief Delete statistics group Node + * + * @details + * + * Function : deleteStatsGrpNode + * + * Functionality: + * Delete statistics group node + * + * @params[in] + * Inst + * Stats Grp Node + * @return void + * + * ****************************************************************/ +void deleteStatsGrpNode(Inst inst, CmLList *grpNode) +{ + SchStatsGrp *statsGrpInfo=NULLP; + + if(grpNode) + { + statsGrpInfo = (SchStatsGrp*)grpNode->node; + deleteStatsGrpInfo(inst, statsGrpInfo); + memset(statsGrpInfo, 0, sizeof(SchStatsGrp)); + SCH_FREE(grpNode->node, sizeof(SchStatsGrp)); + SCH_FREE(grpNode, sizeof(CmLList)); + } +} + +/****************************************************************** + * + * @brief Deletion of node from statistics group list + * + * @details + * + * Function : deleteFromStatsGrpList + * + * Functionality: Deletion of node from statistics group list + * [Step 1]: Traverse each and every node of stats group list + * stored in the database + * [Step 2]: Check if the node's subscription id is same + * as the subscription id received. If same then go to step 3 + * else move to the next node of the list. + * [Step 3]: If deleteAllGrp == true, then delete the node and + * move to the next node of the list. + * [Step 4]: If deleteAllGrp != true, then check if the node's group + * id is same as group id received then delete the node and mark the + * status found true else move to the next node of the list. + * [Step 5]: Once the traversing complete, + * if deleteAllGrp is true, then return successful rsp; + * else if status found is true, then return successful rsp; + * else return failure. + * @params[in] + * Inst + * Stats Grp List + * Subscription Id + * Group Id + * boolen of deleteAllGrp + * @return void + * + * ****************************************************************/ +uint8_t deleteFromStatsGrpList(Inst inst, CmLListCp *statsGrpList, uint64_t subscriptionId, uint8_t groupId, bool deleteAllGrp) +{ + bool statsFound=false; + SchStatsGrp *statsGrpInfo=NULLP; + CmLList *grpNode=NULLP; + + /* [Step 1] */ + CM_LLIST_FIRST_NODE(statsGrpList, grpNode); + while(grpNode) + { + statsGrpInfo = (SchStatsGrp*)grpNode->node; + + /* [Step 2] */ + if(statsGrpInfo->subscriptionId== subscriptionId) + { + if(deleteAllGrp == true) + { + /* [Step 3] */ + cmLListDelFrm(statsGrpList, grpNode); + deleteStatsGrpNode(inst, grpNode); + } + else + { + /* [Step 4] */ + if(statsGrpInfo->groupId== groupId) + { + cmLListDelFrm(statsGrpList, grpNode); + deleteStatsGrpNode(inst, grpNode); + statsFound = true; + } + } + } + CM_LLIST_FIRST_NODE(statsGrpList, grpNode); + } + + /* [Step 5] */ + if(deleteAllGrp == true) + { + return ROK; + } + else + { + if(statsFound == true) + return ROK; + } + return RFAILED; +} + +/******************************************************************* + * + * @brief Delete statistics information + * + * @details + * + * Function : deleteStatsInfo + * + * Functionality: + * Delete statistics information base on numStatsGroup + * Info- If numStatsGroup = 0' indicates the Deletion procedure triggered by + * 'SUBS_DELETION_REQ' wherein all the groups of this particular + * Subscription has to be removed + * else when numStatsGroup != 0 then this is + * for SUBS_MOD_REQ's actionToBeDeleted wherein particular action(s) has + * to be removed thus need to pass groupId belonging to that subscription + * which has to be deleted.' + * + * [Step-1] If numStatsGroup = 0, Deletion of all stats group belonging to + * received subscription Id. + * [Step-2] Else if numStatsGroup > 0, Deletion of individual stats group + * from list whose information are present in stats delete request. + * [Step-3] Fill the result of the stats deletion in the SCH stats delete + * response + * @params[in] + * Instance + * Subscription delete req + * Subscription delete rsp + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t deleteStatsInfo(Inst inst, SchStatsDeleteReq *statsDeleteReq, SchStatsDeleteRsp *schStatsDeleteRsp) +{ + uint8_t statsGrpIdx=0; + CmLListCp *statsGrpList =NULLP; + + statsGrpList = &schCb[inst].statistics.statsGrpList; + + if(!statsDeleteReq->numStatsGroupToBeDeleted) + { + /* [Step-1] */ + if(deleteFromStatsGrpList(inst,statsGrpList, statsDeleteReq->subscriptionId, 0, true) == ROK) + { + /* [Step 3]*/ + schStatsDeleteRsp->subsDelRsp = RSP_OK; + schStatsDeleteRsp->subsDelCause = SUCCESSFUL; + } + else + { + /* [Step-3]*/ + schStatsDeleteRsp->subsDelRsp = RSP_NOK; + schStatsDeleteRsp->subsDelCause = STATS_ID_NOT_FOUND; + } + } + else + { + for(statsGrpIdx=0; statsGrpIdxnumStatsGroupToBeDeleted; statsGrpIdx++) + { + /* [Step-2] */ + if(deleteFromStatsGrpList(inst, statsGrpList, statsDeleteReq->subscriptionId,\ + statsDeleteReq->statsGrpIdToBeDelList[statsGrpIdx], false) == ROK) + { + /* [Step-3]*/ + schStatsDeleteRsp->statsGrpDelInfo[statsGrpIdx].statsGrpDelRsp = RSP_OK; + schStatsDeleteRsp->statsGrpDelInfo[statsGrpIdx].statsGrpDelCause = SUCCESSFUL; + } + else + { + /* [Step-3]*/ + schStatsDeleteRsp->statsGrpDelInfo[statsGrpIdx].statsGrpDelRsp = RSP_NOK; + schStatsDeleteRsp->statsGrpDelInfo[statsGrpIdx].statsGrpDelCause = STATS_ID_NOT_FOUND; + } + } + schStatsDeleteRsp->numStatsGroupDeleted = statsDeleteReq->numStatsGroupToBeDeleted; + } + return ROK; +} + +/******************************************************************* + * + * @brief Processes Statistics Delete Request from MAC + * + * @details + * + * Function : SchProcStatsDeleteReq + * + * Functionality: + * This function process the statistics delete request from MAC: + * + * @params[in] Post structure + * Statistics Delete Request from MAC + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t SchProcStatsDeleteReq(Pst *pst, SchStatsDeleteReq *statsDeleteReq) +{ + Pst rspPst; + uint8_t ret =ROK; + SchStatsDeleteRsp *schStatsDeleteRsp; + Inst inst = pst->dstInst - SCH_INST_START; + + DU_LOG("\nINFO --> SCH : Received Statistics Delete Request from MAC"); + + if(statsDeleteReq == NULLP) + { + DU_LOG("\nERROR --> SCH : SchProcStatsDeleteReq(): Received Null pointer"); + return RFAILED; + } + + /* Process Stats delete request and fill stats delete response simultaneously */ + SCH_ALLOC(schStatsDeleteRsp, sizeof(SchStatsDeleteRsp)); + if(schStatsDeleteRsp == NULLP) + { + DU_LOG("\nERROR --> SCH : Failed to allocate memory in SchProcStatsDeleteReq()"); + return RFAILED; + } + schStatsDeleteRsp->subscriptionId=statsDeleteReq->subscriptionId; + deleteStatsInfo(inst, statsDeleteReq, schStatsDeleteRsp); + + memset(&rspPst, 0, sizeof(Pst)); + FILL_PST_SCH_TO_MAC(rspPst, inst); + rspPst.event = EVENT_STATISTICS_DELETE_RSP_TO_MAC; + + ret = MacMessageRouter(&rspPst, (void *)schStatsDeleteRsp); + if(ret == RFAILED) + { + DU_LOG("\nERROR --> SCH : SchProcStatsDeleteReq(): Failed to send Statistics Response"); + } + SCH_FREE(statsDeleteReq, sizeof(SchStatsDeleteReq)); + + return ret; +} /* End of SchProcStatsDeleteReq */ + +/******************************************************************* + * + * @brief Fill and send statistics modification response to MAC + * + * @details + * + * Function : SchSendStatsRspToMac + * + * Functionality: Fill and send statistics + * modification response to MAC + * + * @params[in] Inst inst, SchMacRsp result + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t SchSendStatsModificationRspToMac(SchStatsModificationRsp *tmpSchStatsModRsp) +{ + Pst rspPst; + uint8_t ret = ROK; + SchStatsModificationRsp *schStatsModificationRsp=NULLP; + + DU_LOG("\nINFO --> SCH : Filling statistics modification response"); + SCH_ALLOC(schStatsModificationRsp, sizeof(SchStatsModificationRsp)); + if(schStatsModificationRsp == NULLP) + { + DU_LOG("\nERROR --> SCH : Failed to allocate memory in SchSendStatsModificationRspToMac()"); + return RFAILED; + } + + memcpy(schStatsModificationRsp, tmpSchStatsModRsp, sizeof(SchStatsModificationRsp)); + memset(tmpSchStatsModRsp, 0, sizeof(SchStatsModificationRsp)); + + /* Filling response post */ + memset(&rspPst, 0, sizeof(Pst)); + FILL_PST_SCH_TO_MAC(rspPst, inst); + rspPst.event = EVENT_STATISTICS_MODIFY_RSP_TO_MAC; + + ret = MacMessageRouter(&rspPst, (void *)schStatsModificationRsp); + if(ret == RFAILED) + { + DU_LOG("\nERROR --> SCH : SchSendStatsModificationRspToMac(): Failed to send Statistics Modification Response"); + return ret; + } + return ret; +} + +/******************************************************************* + * + * @brief Rejects all statistics modification group requested by MAC + * + * @details + * + * Function : SchRejectAllStatsModification + * + * Functionality: Add all statistics modification group received in statistics + * request from MAC, to Reject-StatsModification-Group-List in statistics + * response to MAC + * + * @params[in] Statistics request from MAC + * Cause of rejection + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t SchRejectAllStatsModification(SchStatsModificationReq *statsModificationReq, CauseOfResult cause) +{ + uint8_t grpIdx = 0; + SchStatsModificationRsp statsModificationRsp; + + memset(&statsModificationRsp, 0, sizeof(SchStatsModificationRsp)); + + /* fill the subscriptionId and the rejected list in stats modification rsp */ + statsModificationRsp.subscriptionId = statsModificationReq->subscriptionId; + for(grpIdx = 0; grpIdx < statsModificationReq->numStatsGroup; grpIdx++) + { + statsModificationRsp.statsGrpRejectedList[grpIdx].groupId = statsModificationReq->statsGrpList[grpIdx].groupId; + statsModificationRsp.statsGrpRejectedList[grpIdx].cause = cause; + } + statsModificationRsp.numGrpRejected = statsModificationReq->numStatsGroup; + + return SchSendStatsModificationRspToMac(&statsModificationRsp); +} + +/**************************************************************************************** +* +* @brief Processes Statistics modification Request from MAC +* +* @details +* +* Function :SchProcStatsModificationReq +* +* Functionality: +* This function process the statistics modification request from MAC: +* [Step -1] Check the stored stats group list empty. +* [Step - 1.1] If empty Send the rejected group list to MAC as a stats +* modification response. +* [Step - 1.2] Else go to step 2. +* [Step -2] Traverse all stats group and validate each measurement types in +* each group. +* [Step -3] Check for any failure and if failed fill the remaining group's +* info in rejected list. +* [Step -4] Else Check if the received subscriptionId and groupId match the +* values with the database node. +* [Step -4.1] If matches then follow the below mentioned steps. +* [Step -4.1.1] Stop the timer. +* [Step -4.1.2] Reconfigure stats group by adding a new entry for this +* statsGroup with updated configuration in database. +* [Step -4.1.3] if configured successfully, store stats info into +* stats mod rsp's accepted list, restart timer and go to step 4.1.4 +* [Step -4.1.4] Delete the old entry of this stats group.. +* [Step -4.2] Else fill the group related info in stats modification rsp's +* rejected list. +* [Step -5] Send the stats modification rsp to MAC +* @params[in] Post structure +* Statistics modification Request from MAC +* @return ROK - success +* RFAILED - failure +* +* *******************************************************************************************/ +uint8_t SchProcStatsModificationReq(Pst *pst, SchStatsModificationReq *statsModificationReq) +{ + Inst inst; + uint8_t reqGrpIdx=0; + uint64_t subscriptionId =0; + bool allocFailed = false; + bool statsGrpFound= false; + CmLList *grpNode = NULLP; + SchStatsGrp *statsGrpInfo=NULLP; + SchStatsGrpInfo statsGrpToModify; + SchStatsModificationRsp statsModificationRsp; + + inst=pst->dstInst - SCH_INST_START; + + DU_LOG("\nINFO --> SCH : Received Statistics modification request from MAC"); + + if(statsModificationReq == NULLP) + { + DU_LOG("\nERROR --> SCH : SchProcStatsModificationReq(): Received Null pointer"); + return RFAILED; + } + memset(&statsModificationRsp, 0, sizeof(SchStatsRsp)); + + /* [Step -1] */ + if(schCb[inst].statistics.statsGrpList.count) + { + /* [Step -1.2] */ + subscriptionId = statsModificationReq->subscriptionId; + + /* [Step - 2] */ + for(reqGrpIdx=0; reqGrpIdxnumStatsGroup; reqGrpIdx++) + { + /* [Step - 3] */ + statsGrpToModify = statsModificationReq->statsGrpList[reqGrpIdx]; + if(allocFailed != true) + { + CM_LLIST_FIRST_NODE(&schCb[inst].statistics.statsGrpList, grpNode); + while(grpNode) + { + /* [Step - 4] */ + statsGrpInfo = (SchStatsGrp*)grpNode->node; + if((statsGrpInfo->subscriptionId== subscriptionId) && (statsGrpInfo->groupId== statsGrpToModify.groupId)) + { + statsGrpFound= true; + break; + } + grpNode = grpNode->next; + } + + /* [Step - 4.1] */ + if(statsGrpFound== true) + { + /* [Step - 4.1.1] */ + if(schChkTmr((PTR)statsGrpInfo, EVENT_STATISTICS_TMR) == true) + { + schStopTmr(&schCb[inst], (PTR)statsGrpInfo, EVENT_STATISTICS_TMR); + } + + /* [Step - 4.1.2] */ + if(schAddToStatsGrpList(inst, &statsModificationRsp, subscriptionId, &statsGrpToModify) != ROK) + { + DU_LOG("\nERROR --> SCH : SchProcStatsReq(): Failed to fill the stats group list"); + if(statsModificationRsp.statsGrpRejectedList[statsModificationRsp.numGrpRejected-1].groupId == statsGrpToModify.groupId) + { + /* [Step - 4.1.3] */ + schStartTmr(&schCb[inst], (PTR)(statsGrpInfo), EVENT_STATISTICS_TMR, statsGrpInfo->periodicity); + if(statsModificationRsp.statsGrpRejectedList[statsModificationRsp.numGrpRejected-1].cause == RESOURCE_UNAVAILABLE) + { + allocFailed = true; + break; + } + } + } + else + { + /* [Step - 4.1.4] */ + deleteStatsGrpNode(inst, grpNode); + } + } + else + { + /* [Step - 4.2] */ + statsModificationRsp.statsGrpRejectedList[statsModificationRsp.numGrpRejected].groupId = statsGrpToModify.groupId; + statsModificationRsp.statsGrpRejectedList[statsModificationRsp.numGrpRejected].cause = STATS_ID_NOT_FOUND; + statsModificationRsp.numGrpRejected++; + } + } + else + { + statsModificationRsp.statsGrpRejectedList[statsModificationRsp.numGrpRejected].groupId = statsGrpToModify.groupId; + statsModificationRsp.statsGrpRejectedList[statsModificationRsp.numGrpRejected].cause = RESOURCE_UNAVAILABLE; + statsModificationRsp.numGrpRejected++; + } + } + + statsModificationRsp.subscriptionId = statsModificationReq->subscriptionId; + SchSendStatsModificationRspToMac(&statsModificationRsp); + } + else + { + /* [Step -1.1] */ + SchRejectAllStatsModification(statsModificationReq, STATS_ID_NOT_FOUND); + } + SCH_FREE(statsModificationReq, sizeof(SchStatsModificationReq)); + return ROK; +} /********************************************************************** End of file **********************************************************************/