X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrsch%2Fsch.c;h=8e90431a2101d9f46c39ec18c778c6216cec03ac;hb=a14bf79bbc001990f96e01ada0dd291bcc9ddcad;hp=d11b611cf2a684b2a788f2b158e63a6c7cfc2a37;hpb=0ee9d868ee051d37995fa518c7f7c908d10ebc27;p=o-du%2Fl2.git diff --git a/src/5gnrsch/sch.c b/src/5gnrsch/sch.c index d11b611cf..8e90431a2 100644 --- a/src/5gnrsch/sch.c +++ b/src/5gnrsch/sch.c @@ -46,73 +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 */ -}; - -SchSliceCfgRspFunc SchSliceCfgRspOpts[] = -{ - packSchSliceCfgRsp, /* LC */ - MacProcSchSliceCfgRsp, /* TC */ - packSchSliceCfgRsp /* LWLC */ - -}; - -SchSliceRecfgRspFunc SchSliceRecfgRspOpts[] = -{ - packSchSliceRecfgRsp, /* LC */ - MacProcSchSliceRecfgRsp, /* TC */ - packSchSliceRecfgRsp /* 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. @@ -154,32 +110,32 @@ 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); } - + /* Set Config done in TskInit */ schCb[inst].schInit.cfgDone = TRUE; DU_LOG("\nINFO --> SCH : Scheduler gen config done"); - + + schAllApisInit(inst); return ret; } @@ -208,10 +164,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"); @@ -258,92 +210,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) -{ - Inst inst = pst->dstInst-SCH_INST_START; -#ifdef CALL_FLOW_DEBUG_LOG - DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_CRC_IND_TO_SCH\n"); -#endif - - schProcessCrcInd(crcInd, inst); - return ROK; -} - #ifdef NR_TDD /** *@brief Returns TDD periodicity in micro seconds @@ -412,6 +278,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 @@ -432,17 +340,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: { @@ -463,34 +371,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 @@ -513,7 +393,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; @@ -521,41 +401,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); - } @@ -576,6 +455,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) @@ -586,7 +466,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: { @@ -614,7 +498,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); @@ -665,7 +549,6 @@ 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)); @@ -693,7 +576,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; @@ -709,13 +593,15 @@ void fillSchSib1Cfg(uint8_t mu, uint8_t bandwidth, uint8_t numSlots, SchSib1Cfg 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]; @@ -784,11 +670,11 @@ void fillSchSib1Cfg(uint8_t mu, uint8_t bandwidth, uint8_t numSlots, SchSib1Cfg 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.beta_pdcch_1_0= 0; pdcch->dci.txPdcchPower.powerControlOffsetSS = 0; /* Storing pdschCfg pointer here. Required to access pdsch config while fillig up pdcch pdu */ - pdcch->dci.pdschCfg = pdsch; + pdsch = &pdcch->dci.pdschCfg; /* fill the PDSCH PDU */ uint8_t cwCount = 0; @@ -800,17 +686,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; @@ -822,13 +708,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; @@ -837,6 +723,7 @@ void fillSchSib1Cfg(uint8_t mu, uint8_t bandwidth, uint8_t numSlots, SchSib1Cfg pdsch->txPdschPower.powerControlOffset = 0; pdsch->txPdschPower.powerControlOffsetSS = 0; + return ROK; } /** @@ -854,7 +741,7 @@ 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; @@ -867,47 +754,63 @@ uint8_t SchHdlCellCfgReq(Pst *pst, SchCellCfg *schCellCfg) 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); + fillCoresetFeqDomAllocMap(((cellCb->cellCfg.dlCfgCommon.schFreqInfoDlSib.offsetToPointA - offset)/6), \ + (numRbs/6), freqDomainResource); covertFreqDomRsrcMapToIAPIFormat(freqDomainResource, \ - cellCb->cellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.freqDomainRsrc); + cellCb->cellCfg.dlCfgCommon.schInitialDlBwp.pdcchCommon.commonSearchSpace.freqDomainRsrc); /* 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.schInitialUlBwp.puschCommon.timeDomRsrcAllocList,\ - cellCb->cellCfg.schInitialUlBwp.puschCommon.numTimeDomRsrcAlloc, &cellCb->cellCfg.schInitialUlBwp.msg3K2InfoTbl, \ - &cellCb->cellCfg.schInitialUlBwp.k2InfoTbl); + BuildK2InfoTable(cellCb, cellCb->cellCfg.ulCfgCommon.schInitialUlBwp.puschCommon.timeDomRsrcAllocList,\ + cellCb->cellCfg.ulCfgCommon.schInitialUlBwp.puschCommon.numTimeDomRsrcAlloc, &cellCb->msg3K2InfoTbl, \ + &cellCb->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->cellCfg.schHqCfg.maxDlDataHqTx = SCH_MAX_NUM_DL_HQ_TX; - cellCb->cellCfg.schHqCfg.maxMsg4HqTx = SCH_MAX_NUM_MSG4_TX; - cellCb->cellCfg.schHqCfg.maxUlDataHqTx = SCH_MAX_NUM_UL_HQ_TX; - cellCb->cellCfg.schRachCfg.maxMsg3Tx = SCH_MAX_NUM_MSG3_TX; + 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); @@ -916,9 +819,201 @@ 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 Fill and send Cell delete response to MAC + * + * @details + * + * Function : SchSendCellDeleteRspToMac + * + * Functionality: Fill and send Cell delete response to MAC + * + * @params[in] SchCellDelete *ueDelete, Inst inst, SchMacRsp result + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t SchSendCellDeleteRspToMac(SchCellDeleteReq *ueDelete, Inst inst, SchMacRsp result) +{ + Pst rspPst; + uint8_t ret=0; + + SchCellDeleteRsp delRsp; + + DU_LOG("\nINFO --> SCH : Filling Cell Delete response"); + memset(&delRsp, 0, sizeof(SchCellDeleteRsp)); + delRsp.cellId = ueDelete->cellId; + delRsp.rsp = result; + + /* 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 : SchSendCellDeleteRspToMac(): failed to send the Cell Delete response"); + return ret; + } return ret; +} + +/******************************************************************* + * + * @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; + + if(cellCb->schDlSlotInfo) + { + for(slotIdx=0; slotIdxnumSlots; slotIdx++) + { + 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)); + } + SCH_FREE(cellCb->schDlSlotInfo, cellCb->numSlots *sizeof(SchDlSlotInfo*)); + } + + if(cellCb->schUlSlotInfo) + { + 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*)); + } + + for(plmnIdx = 0; plmnIdx < MAX_PLMN; plmnIdx++) + { + if(cellCb->cellCfg.plmnInfoList[plmnIdx].snssai) + { + for(sliceIdx=0; sliceIdxcellCfg.plmnInfoList[plmnIdx].numSliceSupport; sliceIdx++) + { + SCH_FREE(cellCb->cellCfg.plmnInfoList[plmnIdx].snssai[sliceIdx], sizeof(Snssai)); + } + SCH_FREE(cellCb->cellCfg.plmnInfoList[plmnIdx].snssai, cellCb->cellCfg.plmnInfoList[plmnIdx].numSliceSupport*sizeof(Snssai*)); + } + } + + for(uint16_t idx =0; idxpageCb.pageIndInfoRecord[idx]; + node = list->first; + while(node) + { + 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; + } + } + + cellCb->api->SchCellDeleteReq(cellCb); + + memset(cellCb, 0, sizeof(SchCellCb)); +} + +/******************************************************************* + * + * @brief Function for cell Delete request from MAC to SCH + * + * @details + * + * Function : SchProcCellDeleteReq + * + * Functionality: Function for cell Delete request from MAC to SCH + * + * @params[in] Pst *pst, SchCellDelete *cellDelete + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t SchProcCellDeleteReq(Pst *pst, SchCellDeleteReq *cellDelete) +{ + uint8_t cellIdx=0, ret = RFAILED; + Inst inst = pst->dstInst - SCH_INST_START; + SchMacRsp result= RSP_OK; + + if(!cellDelete) + { + DU_LOG("\nERROR --> SCH : SchProcCellDeleteReq(): Ue Delete request failed"); + } + 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; } /******************************************************************* @@ -927,7 +1022,7 @@ uint8_t SchHdlCellCfgReq(Pst *pst, SchCellCfg *schCellCfg) * * @details * - * Function : MacSchDlRlcBoInfo + * Function : SchProcDlRlcBoInfo * * Functionality: * Processes DL RLC BO info from MAC @@ -937,7 +1032,7 @@ uint8_t SchHdlCellCfgReq(Pst *pst, SchCellCfg *schCellCfg) * RFAILED - failure * * ****************************************************************/ -uint8_t MacSchDlRlcBoInfo(Pst *pst, DlRlcBoInfo *dlBoInfo) +uint8_t SchProcDlRlcBoInfo(Pst *pst, DlRlcBoInfo *dlBoInfo) { uint8_t lcId = 0; uint16_t ueId = 0; @@ -946,15 +1041,12 @@ uint8_t MacSchDlRlcBoInfo(Pst *pst, DlRlcBoInfo *dlBoInfo) SchCellCb *cell = NULLP; Inst inst = pst->dstInst-SCH_INST_START; -#ifdef CALL_FLOW_DEBUG_LOG - DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_DL_RLC_BO_INFO_TO_SCH\n"); -#endif 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 : MacSchDlRlcBoInfo(): Cell does not exists"); + DU_LOG("\nERROR --> SCH : SchProcDlRlcBoInfo(): Cell does not exists"); return RFAILED; } @@ -1005,7 +1097,7 @@ uint8_t MacSchDlRlcBoInfo(Pst *pst, DlRlcBoInfo *dlBoInfo) } } /* Adding UE Id to list of pending UEs to be scheduled */ - addUeToBeScheduled(cell, ueId); + cell->api->SchDlRlcBoInfo(cell, ueId); return ROK; } @@ -1015,7 +1107,7 @@ uint8_t MacSchDlRlcBoInfo(Pst *pst, DlRlcBoInfo *dlBoInfo) * * @details * - * Function : MacSchBsr + * Function : SchProcBsr * * Functionality: * Processes DL BSR from MAC @@ -1026,17 +1118,13 @@ uint8_t MacSchDlRlcBoInfo(Pst *pst, DlRlcBoInfo *dlBoInfo) * RFAILED - failure * * ****************************************************************/ -uint8_t MacSchBsr(Pst *pst, UlBufferStatusRptInd *bsrInd) +uint8_t SchProcBsr(Pst *pst, UlBufferStatusRptInd *bsrInd) { Inst schInst = pst->dstInst-SCH_INST_START; SchCellCb *cellCb = NULLP; SchUeCb *ueCb = NULLP; uint8_t lcgIdx = 0; -#ifdef CALL_FLOW_DEBUG_LOG - DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_SHORT_BSR\n"); -#endif - DU_LOG("\nDEBUG --> SCH : Received BSR"); if(bsrInd == NULLP) { @@ -1072,7 +1160,7 @@ uint8_t MacSchBsr(Pst *pst, UlBufferStatusRptInd *bsrInd) } /* Adding UE Id to list of pending UEs to be scheduled */ - addUeToBeScheduled(cellCb, ueCb->ueId); + cellCb->api->SchBsr(cellCb, ueCb->ueId); return ROK; } @@ -1082,7 +1170,7 @@ uint8_t MacSchBsr(Pst *pst, UlBufferStatusRptInd *bsrInd) * * @details * - * Function : MacSchSrUciInd + * Function : SchProcSrUciInd * * Functionality: * Processes SR UCI indication from MAC @@ -1093,17 +1181,13 @@ 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); @@ -1118,18 +1202,11 @@ uint8_t MacSchSrUciInd(Pst *pst, SrUciIndInfo *uciInd) DU_LOG("\nINFO --> SCH: UL Data transmission not allowed for UE %d", ueCb->ueCfg.ueId); return ROK; } -#ifdef NR_DRX - if(ueCb->ueDrxInfoPres) - { - if(!ueCb->drxUeCb.drxUlUeActiveStatus) - ueCb->drxUeCb.drxUlUeActiveStatus = true; - } -#endif if(uciInd->numSrBits) { ueCb->srRcvd = true; /* Adding UE Id to list of pending UEs to be scheduled */ - addUeToBeScheduled(cellCb, ueCb->ueId); + cellCb->api->SchSrUciInd(cellCb, ueCb->ueId); } return ROK; } @@ -1140,7 +1217,7 @@ uint8_t MacSchSrUciInd(Pst *pst, SrUciIndInfo *uciInd) * * @details * - * Function : MacSchDlHarqInd + * Function : SchProcDlHarqInd * * Functionality: * Processes DL HARQ indication from MAC @@ -1151,16 +1228,12 @@ uint8_t MacSchSrUciInd(Pst *pst, SrUciIndInfo *uciInd) * RFAILED - failure * * ****************************************************************/ -uint8_t MacSchDlHarqInd(Pst *pst, DlHarqInd *dlHarqInd) +uint8_t SchProcDlHarqInd(Pst *pst, DlHarqInd *dlHarqInd) { 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_DL_HARQ_IND_TO_SCH\n"); -#endif - DU_LOG("\nDEBUG --> SCH : Received HARQ"); ueCb = schGetUeCb(cellCb, dlHarqInd->crnti); @@ -1219,18 +1292,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.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.pdschCfg.pdschFreqAlloc.startPrb; + broadcastPrbEnd = broadcastPrbStart + cell->sib1SchCfg.sib1PdcchCfg.dci.pdschCfg.pdschFreqAlloc.numPrb -1; } /* Iterate through all free PRB blocks */ @@ -1308,6 +1381,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.dlTotalPrbUsage) + prbAlloc->numPrbAlloc += numPrb; /* Update the remaining number for free PRBs */ removeAllocatedPrbFromFreePrbList(&prbAlloc->freePrbBlockList, freePrbNode, *startPrb, numPrb); @@ -1362,7 +1439,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; } @@ -1442,64 +1519,16 @@ uint8_t allocatePrbUl(SchCellCb *cell, SlotTimingInfo slotTime, \ } } + /* Update statistics of PRB usage if stats calculation is enabled */ + if(schCb[cell->instIdx].statistics.ulTotalPrbUsage) + 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 ueId [%d] to cell->ueToBeScheduled list", *ueId); - return RFAILED; - } - return ROK; -} - /******************************************************************************* * * @brief Try to find Best Free Block with Max Num PRB @@ -1548,19 +1577,19 @@ uint16_t searchLargestFreeBlock(SchCellCb *cell, SlotTimingInfo slotTime,uint16_ checkOccasion = TRUE; if(ssbOccasion && sib1Occasion) { - reservedPrbStart = cell->cellCfg.ssbSchCfg.ssbOffsetPointA; + reservedPrbStart = cell->cellCfg.dlCfgCommon.schFreqInfoDlSib.offsetToPointA; reservedPrbEnd = reservedPrbStart + SCH_SSB_NUM_PRB + \ - cell->cellCfg.sib1SchCfg.sib1PdschCfg.pdschFreqAlloc.freqAlloc.numPrb -1; + cell->sib1SchCfg.sib1PdcchCfg.dci.pdschCfg.pdschFreqAlloc.numPrb -1; } else if(ssbOccasion) { - reservedPrbStart = cell->cellCfg.ssbSchCfg.ssbOffsetPointA; + reservedPrbStart = cell->cellCfg.dlCfgCommon.schFreqInfoDlSib.offsetToPointA; reservedPrbEnd = reservedPrbStart + SCH_SSB_NUM_PRB -1; } else if(sib1Occasion) { - reservedPrbStart = cell->cellCfg.sib1SchCfg.sib1PdschCfg.pdschFreqAlloc.freqAlloc.startPrb; - reservedPrbEnd = reservedPrbStart + cell->cellCfg.sib1SchCfg.sib1PdschCfg.pdschFreqAlloc.freqAlloc.numPrb -1; + reservedPrbStart = cell->sib1SchCfg.sib1PdcchCfg.dci.pdschCfg.pdschFreqAlloc.startPrb; + reservedPrbEnd = reservedPrbStart + cell->sib1SchCfg.sib1PdcchCfg.dci.pdschCfg.pdschFreqAlloc.numPrb -1; } else { @@ -1575,7 +1604,7 @@ uint16_t searchLargestFreeBlock(SchCellCb *cell, SlotTimingInfo slotTime,uint16_ checkOccasion = schCheckPrachOcc(cell, slotTime); if(checkOccasion) { - reservedPrbStart = cell->cellCfg.schRachCfg.msg1FreqStart; + reservedPrbStart = cell->cellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.prachCfgGeneric.msg1FreqStart; reservedPrbEnd = reservedPrbStart + (schCalcPrachNumRb(cell)) -1; } } @@ -1660,153 +1689,108 @@ void SchSendSliceCfgRspToMac(Inst inst, SchSliceCfgRsp sliceCfgRsp) FILL_PST_SCH_TO_MAC(rspPst, inst); rspPst.event = EVENT_SLICE_CFG_RSP_TO_MAC; - SchSliceCfgRspOpts[rspPst.selector](&rspPst, &sliceCfgRsp); + MacMessageRouter(&rspPst, (void *)&sliceCfgRsp); } + /******************************************************************************* * - * @brief fill slice configuration response + * @brief This function is used to store or modify the slice configuration Sch DB * * @details * - * Function : fillSliceCfgRsp + * Function : addOrModifySliceCfgInSchDb * * Functionality: - * fill slice configuration response + * function is used to store or modify the slice configuration Sch DB * - * @params[in] SchCellCb, SchSliceCfgReq, SchSliceCfgRsp,uint8_t count + * @params[in] SchSliceCfg *storeSliceCfg, SchSliceCfgReq *cfgReq, + * SchSliceCfgRsp cfgRsp, uint8_t count * * @return * ROK - Success * RFAILED - Failure * * ********************************************************************************/ -uint8_t fillSliceCfgRsp(bool sliceRecfg, SchSliceCfg *storedSliceCfg, SchCellCb *cellCb, SchSliceCfgReq *schSliceCfgReq, SchSliceCfgRsp *schSliceCfgRsp, uint8_t *count) +uint8_t addSliceCfgInSchDb(CmLListCp *sliceCfgInDb, SchRrmPolicyOfSlice *cfgReq) { - bool sliceFound = false; - uint8_t cfgIdx = 0, sliceIdx = 0; + SchRrmPolicyOfSlice *sliceToStore; - schSliceCfgRsp->numSliceCfgRsp = schSliceCfgReq->numOfConfiguredSlice; - SCH_ALLOC(schSliceCfgRsp->listOfSliceCfgRsp, schSliceCfgRsp->numSliceCfgRsp * sizeof(SliceRsp*)); - if(schSliceCfgRsp->listOfSliceCfgRsp == NULLP) + SCH_ALLOC(sliceToStore, sizeof(SchRrmPolicyOfSlice)); + if(sliceToStore) { - DU_LOG("\nERROR --> SCH : Memory allocation failed at fillSliceCfgRsp"); - return RFAILED; + memcpy(&sliceToStore->snssai, &cfgReq->snssai, sizeof(Snssai)); + memcpy(&sliceToStore->rrmPolicyRatioInfo, &cfgReq->rrmPolicyRatioInfo, sizeof(SchRrmPolicyRatio)); + addNodeToLList(sliceCfgInDb, sliceToStore, NULL); } - - for(cfgIdx = 0; cfgIdxnumSliceCfgRsp ; cfgIdx++) + else { - sliceFound = false; - /* Here comparing the slice cfg request with the slice stored in cellCfg */ - if(sliceRecfg != true) - { - for(sliceIdx = 0; sliceIdxcellCfg.plmnInfoList.numSliceSupport; sliceIdx++) - { - if(!memcmp(&schSliceCfgReq->listOfConfirguration[cfgIdx]->snssai, cellCb->cellCfg.plmnInfoList.snssai[sliceIdx], sizeof(Snssai))) - { - (*count)++; - sliceFound = true; - break; - } - } - } - else - { - /* Here comparing the slice cfg request with the slice stored in SchDb */ - if(storedSliceCfg->listOfConfirguration) - { - for(sliceIdx = 0; sliceIdxnumOfSliceConfigured; sliceIdx++) - { - if(!memcmp(&schSliceCfgReq->listOfConfirguration[cfgIdx]->snssai, &storedSliceCfg->listOfConfirguration[sliceIdx]->snssai,\ - sizeof(Snssai))) - { - (*count)++; - sliceFound = true; - break; - } - } - } - } - - SCH_ALLOC(schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx], sizeof(SliceRsp)); - if(schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx] == NULLP) - { - DU_LOG("\nERROR --> SCH : Failed to allocate memory in fillSliceCfgRsp"); - return RFAILED; - } - - - schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->snssai = schSliceCfgReq->listOfConfirguration[cfgIdx]->snssai; - if(sliceFound == true) - schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->rsp = RSP_OK; - else - { - schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->rsp = RSP_NOK; - schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->cause = SLICE_NOT_FOUND; - } + DU_LOG("\nERROR --> SCH : Memory allocation failed in addOrModifySliceCfgInSchDb"); + return RFAILED; } return ROK; } /******************************************************************************* * - * @brief This function is used to store the slice configuration Sch DB + * @brief fill slice configuration response * * @details * - * Function : addSliceCfgInSchDb + * Function : fillSliceCfgRsp * * Functionality: - * function is used to store the slice configuration Sch DB + * fill slice configuration response * - * @params[in] SchSliceCfg *storeSliceCfg, SchSliceCfgReq *cfgReq, - * SchSliceCfgRsp cfgRsp, uint8_t count + * @params[in] SchCellCb, SchSliceCfgReq, SchSliceCfgRsp,uint8_t count * * @return * ROK - Success * RFAILED - Failure * * ********************************************************************************/ -uint8_t addSliceCfgInSchDb(SchSliceCfg *storeSliceCfg, SchSliceCfgReq *cfgReq, SchSliceCfgRsp cfgRsp, uint8_t count) +uint8_t fillSliceCfgRsp(Inst inst, CmLListCp *storedSliceCfg, SchCellCb *cellCb, SchSliceCfgReq *schSliceCfgReq) { - uint8_t cfgIdx = 0, sliceIdx = 0; - - if(count) - { - storeSliceCfg->numOfSliceConfigured = count; - SCH_ALLOC(storeSliceCfg->listOfConfirguration, storeSliceCfg->numOfSliceConfigured * sizeof(SchRrmPolicyOfSlice*)); - if(storeSliceCfg->listOfConfirguration == NULLP) - { - DU_LOG("\nERROR --> SCH : Failed to allocate memory in addSliceCfgInSchDb"); - return RFAILED; - } + SchMacRsp sliceFound; + uint8_t cfgIdx = 0, sliceIdx = 0, plmnIdx = 0, ret =ROK; + SchSliceCfgRsp schSliceCfgRsp; - for(cfgIdx = 0; cfgIdxnumOfSliceConfigured; cfgIdx++) + 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++) { - if(cfgRsp.listOfSliceCfgRsp[cfgIdx]->rsp == RSP_OK) + for(sliceIdx = 0; sliceIdxcellCfg.plmnInfoList[plmnIdx].numSliceSupport; sliceIdx++) { - SCH_ALLOC(storeSliceCfg->listOfConfirguration[sliceIdx], sizeof(SchRrmPolicyOfSlice)); - if(storeSliceCfg->listOfConfirguration[sliceIdx] == NULLP) - { - DU_LOG("\nERROR --> SCH : Failed to allocate memory in addSliceCfgInSchDb"); - return RFAILED; - } - - SCH_ALLOC(storeSliceCfg->listOfConfirguration[sliceIdx]->rrmPolicyRatioInfo, sizeof(SchRrmPolicyRatio)); - if(storeSliceCfg->listOfConfirguration[sliceIdx]->rrmPolicyRatioInfo == NULLP) + /* 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].snssai[sliceIdx], sizeof(Snssai))) { - DU_LOG("\nERROR --> SCH : Failed to allocate memory in addSliceCfgInSchDb"); - return RFAILED; + 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; } - - memcpy(&storeSliceCfg->listOfConfirguration[sliceIdx]->snssai, &cfgReq->listOfConfirguration[sliceIdx]->snssai, sizeof(Snssai)); - memcpy(storeSliceCfg->listOfConfirguration[sliceIdx]->rrmPolicyRatioInfo, cfgReq->listOfConfirguration[sliceIdx]->rrmPolicyRatioInfo, - sizeof(SchRrmPolicyRatio)); - sliceIdx++; } } + + 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 ROK; + return ret; } /******************************************************************************* @@ -1836,13 +1820,12 @@ void freeSchSliceCfgReq(SchSliceCfgReq *sliceCfgReq) { for(cfgIdx = 0; cfgIdxnumOfConfiguredSlice; cfgIdx++) { - if(sliceCfgReq->listOfConfirguration[cfgIdx]) + if(sliceCfgReq->listOfSlices[cfgIdx]) { - SCH_FREE(sliceCfgReq->listOfConfirguration[cfgIdx]->rrmPolicyRatioInfo, sizeof(SchRrmPolicyRatio)); - SCH_FREE(sliceCfgReq->listOfConfirguration[cfgIdx], sizeof(SchRrmPolicyOfSlice)); + SCH_FREE(sliceCfgReq->listOfSlices[cfgIdx], sizeof(SchRrmPolicyOfSlice)); } } - SCH_FREE(sliceCfgReq->listOfConfirguration, sliceCfgReq->numOfConfiguredSlice * sizeof(SchRrmPolicyOfSlice*)); + SCH_FREE(sliceCfgReq->listOfSlices, sliceCfgReq->numOfConfiguredSlice * sizeof(SchRrmPolicyOfSlice*)); } SCH_FREE(sliceCfgReq, sizeof(SchSliceCfgReq)); } @@ -1853,7 +1836,7 @@ void freeSchSliceCfgReq(SchSliceCfgReq *sliceCfgReq) * * @details * - * Function : MacSchSliceCfgReq + * Function : SchProcSliceCfgReq * * Functionality: * function is used to store the slice configuration Sch DB @@ -1865,89 +1848,33 @@ void freeSchSliceCfgReq(SchSliceCfgReq *sliceCfgReq) * RFAILED - Failure * * ********************************************************************************/ -uint8_t MacSchSliceCfgReq(Pst *pst, SchSliceCfgReq *schSliceCfgReq) +uint8_t SchProcSliceCfgReq(Pst *pst, SchSliceCfgReq *schSliceCfgReq) { - uint8_t count = 0; + uint8_t ret = ROK; Inst inst = pst->dstInst - SCH_INST_START; - SchSliceCfgRsp sliceCfgRsp; DU_LOG("\nINFO --> SCH : Received Slice Cfg request from MAC"); if(schSliceCfgReq) { - if(schSliceCfgReq->listOfConfirguration) + if(schSliceCfgReq->listOfSlices) { /* filling the slice configuration response of each slice */ - if(fillSliceCfgRsp(false, NULLP, schCb[inst].cells[0], schSliceCfgReq, &sliceCfgRsp, &count) != ROK) + if(fillSliceCfgRsp(inst, &schCb[inst].sliceCfg, schCb[inst].cells[0], schSliceCfgReq) != ROK) { DU_LOG("\nERROR --> SCH : Failed to fill the slice cfg rsp"); - return RFAILED; - } - - if(addSliceCfgInSchDb(&schCb[inst].sliceCfg, schSliceCfgReq, sliceCfgRsp, count) != ROK) - { - DU_LOG("\nERROR --> SCH : Failed to add slice cfg in sch database"); - return RFAILED; + ret = RFAILED; } freeSchSliceCfgReq(schSliceCfgReq); - SchSendSliceCfgRspToMac(inst, sliceCfgRsp); } } else { DU_LOG("\nERROR --> SCH : Received SchSliceCfgReq is NULL"); + ret = RFAILED; } - return ROK; + return ret; } -/******************************************************************************* - * - * @brief This function is used to store the slice reconfiguration Sch DB - * - * @details - * - * Function : modifySliceCfgInSchDb - * - * Functionality: - * function is used to store the slice re configuration Sch DB - * - * @params[in] Pst *pst, SchSliceCfgReq *schSliceCfgReq - * - * @return - * ROK - Success - * RFAILED - Failure - * - * ********************************************************************************/ -uint8_t modifySliceCfgInSchDb(SchSliceCfg *storeSliceCfg, SchSliceRecfgReq *recfgReq, SchSliceRecfgRsp recfgRsp, uint8_t count) -{ - uint8_t cfgIdx = 0, sliceIdx = 0; - - if(count) - { - if(storeSliceCfg->listOfConfirguration == NULLP) - { - DU_LOG("\nINFO --> SCH : Memory allocation failed in modifySliceCfgInSchDb"); - return RFAILED; - } - - for(cfgIdx = 0; cfgIdxnumOfConfiguredSlice; cfgIdx++) - { - if(recfgRsp.listOfSliceCfgRsp[cfgIdx]->rsp == RSP_OK) - { - for(sliceIdx = 0; sliceIdxnumOfSliceConfigured; sliceIdx++) - { - if(!memcmp(&storeSliceCfg->listOfConfirguration[sliceIdx]->snssai, &recfgReq->listOfConfirguration[cfgIdx]->snssai, sizeof(Snssai))) - { - memcpy(storeSliceCfg->listOfConfirguration[sliceIdx]->rrmPolicyRatioInfo, recfgReq->listOfConfirguration[cfgIdx]->rrmPolicyRatioInfo, - sizeof(SchRrmPolicyRatio)); - break; - } - } - } - } - } - freeSchSliceCfgReq(recfgReq); - return ROK; -} /******************************************************************************* * * @brief This function is used to send Slice re Cfg rsp to MAC @@ -1972,7 +1899,62 @@ void SchSendSliceRecfgRspToMac(Inst inst, SchSliceRecfgRsp schSliceRecfgRsp) FILL_PST_SCH_TO_MAC(rspPst, inst); rspPst.event = EVENT_SLICE_RECFG_RSP_TO_MAC; - SchSliceRecfgRspOpts[rspPst.selector](&rspPst, &schSliceRecfgRsp); + 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; } /******************************************************************************* * @@ -1980,7 +1962,7 @@ void SchSendSliceRecfgRspToMac(Inst inst, SchSliceRecfgRsp schSliceRecfgRsp) * * @details * - * Function : MacSchSliceRecfgReq + * Function : SchProcSliceRecfgReq * * Functionality: * function is used to store the slice re configuration Sch DB @@ -1992,38 +1974,31 @@ void SchSendSliceRecfgRspToMac(Inst inst, SchSliceRecfgRsp schSliceRecfgRsp) * RFAILED - Failure * * ********************************************************************************/ -uint8_t MacSchSliceRecfgReq(Pst *pst, SchSliceRecfgReq *schSliceRecfgReq) +uint8_t SchProcSliceRecfgReq(Pst *pst, SchSliceRecfgReq *schSliceRecfgReq) { - uint8_t count = 0; + uint8_t ret = ROK; Inst inst = pst->dstInst - SCH_INST_START; - SchSliceRecfgRsp schSliceRecfgRsp; DU_LOG("\nINFO --> SCH : Received Slice ReCfg request from MAC"); if(schSliceRecfgReq) { - if(schSliceRecfgReq->listOfConfirguration) + if(schSliceRecfgReq->listOfSlices) { /* filling the slice configuration response of each slice */ - if(fillSliceCfgRsp(true, &schCb[inst].sliceCfg, NULLP, schSliceRecfgReq, &schSliceRecfgRsp, &count) != ROK) + if(fillSliceRecfgRsp(inst, &schCb[inst].sliceCfg, schSliceRecfgReq) != ROK) { DU_LOG("\nERROR --> SCH : Failed to fill sch slice cfg response"); - return RFAILED; + ret = RFAILED; } - - /* Modify the slice configuration stored in schCb */ - if(modifySliceCfgInSchDb(&schCb[inst].sliceCfg, schSliceRecfgReq, schSliceRecfgRsp, count) != ROK) - { - DU_LOG("\nERROR --> SCH : Failed to modify slice cfg of SchDb"); - return RFAILED; - } - SchSendSliceRecfgRspToMac(inst, schSliceRecfgRsp); + freeSchSliceCfgReq(schSliceRecfgReq); } } else { DU_LOG("\nERROR --> SCH : Received SchSliceRecfgReq is NULL"); + } - return ROK; + return ret; } /**************************************************************************** @@ -2053,10 +2028,10 @@ uint8_t MacSchSliceRecfgReq(Pst *pst, SchSliceRecfgReq *schSliceRecfgReq) *************************************************************************/ void schProcPagingCfg(SchCellCb *cell) { - PageCfg *pageCfgRcvd = NULL; + SchPcchCfg *pageCfgRcvd = NULL; uint8_t i_sIdx = 0; - pageCfgRcvd = &(cell->cellCfg.sib1SchCfg.pageCfg); + pageCfgRcvd = &(cell->cellCfg.dlCfgCommon.schPcchCfg); if(pageCfgRcvd->poPresent == TRUE) { @@ -2098,8 +2073,8 @@ void schProcPagingCfg(SchCellCb *cell) void schCfgPdcchMonOccOfPO(SchCellCb *cell) { uint8_t cnt = 0, incr = 1, i_sIdx = 0, frameOffSet = 0; - uint8_t nsValue = cell->cellCfg.sib1SchCfg.pageCfg.numPO; - uint8_t totalNumSsb = cell->cellCfg.ssbSchCfg.totNumSsb; + 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*/ @@ -2205,7 +2180,7 @@ uint8_t schAddPagingIndtoList(CmLListCp *storedPageList,void * pageIndInfo) * * @details * - * Function : MacSchPagingInd + * Function : SchProcPagingInd * * Functionality: Process paging indication at SCH recevied form MAC * @@ -2214,7 +2189,7 @@ uint8_t schAddPagingIndtoList(CmLListCp *storedPageList,void * pageIndInfo) * @return void * *************************************************************************/ -uint8_t MacSchPagingInd(Pst *pst, SchPageInd *pageInd) +uint8_t SchProcPagingInd(Pst *pst, SchPageInd *pageInd) { uint8_t ret = RFAILED; uint16_t cellIdx = 0; @@ -2238,9 +2213,9 @@ uint8_t MacSchPagingInd(Pst *pst, SchPageInd *pageInd) } if(cellCb) { - if(pageInd->i_s > cellCb->cellCfg.sib1SchCfg.pageCfg.numPO) + if(pageInd->i_s > cellCb->cellCfg.dlCfgCommon.schPcchCfg.numPO) { - DU_LOG("\nERROR --> SCH : MacSchPagingInd(): i_s should not be greater than number of paging occasion"); + DU_LOG("\nERROR --> SCH : SchProcPagingInd(): i_s should not be greater than number of paging occasion"); } else { @@ -2257,7 +2232,7 @@ uint8_t MacSchPagingInd(Pst *pst, SchPageInd *pageInd) SCH_ALLOC(pageInfo->pagePdu, pageInfo->msgLen); if(!pageInfo->pagePdu) { - DU_LOG("\nERROR --> SCH : MacSchPagingInd(): Failed to allocate memory"); + DU_LOG("\nERROR --> SCH : SchProcPagingInd(): Failed to allocate memory"); } else { @@ -2265,13 +2240,13 @@ uint8_t MacSchPagingInd(Pst *pst, SchPageInd *pageInd) ret = schAddPagingIndtoList(&cellCb->pageCb.pageIndInfoRecord[pageInfo->pageTxTime.sfn], pageInfo); if(ret != ROK) { - DU_LOG("\nERROR --> SCH : MacSchPagingInd(): Failed to store paging record"); + DU_LOG("\nERROR --> SCH : SchProcPagingInd(): Failed to store paging record"); } } } else { - DU_LOG("\nERROR --> SCH : MacSchPagingInd(): Failed to allocate memory"); + DU_LOG("\nERROR --> SCH : SchProcPagingInd(): Failed to allocate memory"); } } } @@ -2284,10 +2259,437 @@ uint8_t MacSchPagingInd(Pst *pst, SchPageInd *pageInd) } else { - DU_LOG("\nERROR --> SCH : MacSchPagingInd(): Received null pointer"); + 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(Inst inst, SchMacRsp result, CauseOfResult cause) +{ + Pst rspPst; + uint8_t ret = ROK; + SchStatsRsp *statsRsp; + + DU_LOG("\nINFO --> SCH : Filling statistics response"); + SCH_ALLOC(statsRsp, sizeof(SchStatsRsp)); + if(statsRsp == NULLP) + { + DU_LOG("\nERROR --> SCH : Failed to allocate memory in SchSendStatsRspToMac()"); + return RFAILED; + } + memset(statsRsp, 0, sizeof(SchStatsRsp)); + statsRsp->rsp = result; + statsRsp->cause = cause; + + /* 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 *)statsRsp); + if(ret == RFAILED) + { + DU_LOG("\nERROR --> SCH : SchSendStatsRspToMac(): Failed to send Statistics Response"); + return ret; } return ret; } + +/******************************************************************* + * + * @brief Processes Statistics Request from MAC + * + * @details + * + * Function : SchProcStatsReq + * + * Functionality: + * Processes Statistics Request from MAC + * + * @params[in] + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t SchProcStatsReq(Pst *pst, SchStatsReq *statsReq) +{ + uint8_t idx; + Inst inst = pst->dstInst - SCH_INST_START; + SchMacRsp rsp = RSP_OK; + CauseOfResult cause = SUCCESSFUL; + bool isDlTotlPrbUseCfgd = false, isUlTotlPrbUseCfgd = false; + + DU_LOG("\nINFO --> SCH : Received Statistics Request from MAC"); + + for(idx=0; idx < statsReq->numStats; idx++) + { + switch(statsReq->statsList[idx].type) + { + case SCH_DL_TOTAL_PRB_USAGE: + { + /* Check if duplicate configuration */ + if(schCb[inst].statistics.dlTotalPrbUsage) + { + DU_LOG("\nERROR --> SCH : SCH_DL_TOTAL_PRB_USAGE stats already configured"); + rsp = RSP_NOK; + cause = DUPLICATE_ENTRY; + } + + /* Allocate memory */ + SCH_ALLOC(schCb[inst].statistics.dlTotalPrbUsage, sizeof(TotalPrbUsage)); + if(!schCb[inst].statistics.dlTotalPrbUsage) + { + DU_LOG("\nERROR --> SCH : Memory allocation failed for dlTotalPrbUsage in \ + SchProcStatsReq()"); + rsp = RSP_NOK; + cause = RESOURCE_UNAVAILABLE; + break; + } + + /* Initialize */ + memset(schCb[inst].statistics.dlTotalPrbUsage, 0, sizeof(TotalPrbUsage)); + + /* Configure */ + schCb[inst].statistics.dlTotalPrbUsage->schInst = inst; + schCb[inst].statistics.dlTotalPrbUsage->periodicity = statsReq->statsList[idx].periodicity; + cmInitTimers(&(schCb[inst].statistics.dlTotalPrbUsage->periodTimer), 1); + + /* Start timer */ + schStartTmr(&schCb[inst], (PTR)(schCb[inst].statistics.dlTotalPrbUsage), \ + EVENT_DL_TOTAL_PRB_USAGE_TMR, schCb[inst].statistics.dlTotalPrbUsage->periodicity); + + isDlTotlPrbUseCfgd = true; + break; + } + + case SCH_UL_TOTAL_PRB_USAGE: + { + /* Check if duplicate configuration */ + if(schCb[inst].statistics.ulTotalPrbUsage) + { + DU_LOG("\nERROR --> SCH : SCH_UL_TOTAL_PRB_USAGE stats already configured"); + rsp = RSP_NOK; + cause = DUPLICATE_ENTRY; + } + + /* Allocate memory */ + SCH_ALLOC(schCb[inst].statistics.ulTotalPrbUsage, sizeof(TotalPrbUsage)); + if(!schCb[inst].statistics.ulTotalPrbUsage) + { + DU_LOG("\nERROR --> SCH : Memory allocation failed for ulTotalPrbUsage in \ + SchProcStatsReq()"); + rsp = RSP_NOK; + cause = RESOURCE_UNAVAILABLE; + break; + } + + /* Initialize */ + memset(schCb[inst].statistics.ulTotalPrbUsage, 0, sizeof(TotalPrbUsage)); + + /* Configure */ + schCb[inst].statistics.ulTotalPrbUsage->schInst = inst; + schCb[inst].statistics.ulTotalPrbUsage->periodicity = statsReq->statsList[idx].periodicity; + cmInitTimers(&(schCb[inst].statistics.ulTotalPrbUsage->periodTimer), 1); + + /* Start timer */ + schStartTmr(&schCb[inst], (PTR)(schCb[inst].statistics.ulTotalPrbUsage), \ + EVENT_UL_TOTAL_PRB_USAGE_TMR, schCb[inst].statistics.ulTotalPrbUsage->periodicity); + + isUlTotlPrbUseCfgd = true; + break; + } + default: + { + DU_LOG("\nERROR --> SCH : Invalid statistics type [%d]", statsReq->statsList[idx].type); + rsp = RSP_NOK; + cause = PARAM_INVALID; + } + } /* End of switch */ + + if(rsp == RSP_NOK) + { + /* If failed to configure any KPI, then clear configuration of other + * KPIs that were configured successfully as part of this statsReq */ + if(isDlTotlPrbUseCfgd) + { + if((schChkTmr((PTR)(schCb[inst].statistics.dlTotalPrbUsage), EVENT_DL_TOTAL_PRB_USAGE_TMR)) == FALSE) + { + schStopTmr(&schCb[inst], (PTR)(schCb[inst].statistics.dlTotalPrbUsage), EVENT_DL_TOTAL_PRB_USAGE_TMR); + } + SCH_FREE(schCb[inst].statistics.dlTotalPrbUsage, sizeof(TotalPrbUsage)); + } + + if(isUlTotlPrbUseCfgd) + { + if((schChkTmr((PTR)(schCb[inst].statistics.ulTotalPrbUsage), EVENT_UL_TOTAL_PRB_USAGE_TMR)) == FALSE) + { + schStopTmr(&schCb[inst], (PTR)(schCb[inst].statistics.ulTotalPrbUsage), EVENT_UL_TOTAL_PRB_USAGE_TMR); + } + SCH_FREE(schCb[inst].statistics.ulTotalPrbUsage, sizeof(TotalPrbUsage)); + } + break; + } + } /* End of FOR */ + + SCH_FREE(statsReq, sizeof(SchStatsReq)); + + SchSendStatsRspToMac(inst, rsp, cause); + + return ROK; +} /* End of SchProcStatsReq */ + /********************************************************************** End of file **********************************************************************/