X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrsch%2Fsch.c;h=ace885ea121d52bd03ea60a24b8d5c87438ab0dc;hb=6dc8a4c17da24847b3a3aee91b37151f77a8a5bc;hp=8d8dba6b924daee6b3de736db9c1d71452601766;hpb=d1f428c3527bfff3b3eae2715e91ae8449ad1784;p=o-du%2Fl2.git diff --git a/src/5gnrsch/sch.c b/src/5gnrsch/sch.c index 8d8dba6b9..ace885ea1 100644 --- a/src/5gnrsch/sch.c +++ b/src/5gnrsch/sch.c @@ -46,51 +46,11 @@ #include "rg_sch_inf.x" /* typedefs for Scheduler */ #include "mac_sch_interface.h" #include "sch.h" +#include "sch_tmr.h" #include "sch_utils.h" #include "sch_fcfs.h" #include "sch_slice_based.h" -/** - * @brief Task Initiation function. - * - * @details - * - * Function : schActvInit - * - * 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. - * - * @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 - **/ -uint8_t schActvInit(Ent entity, Inst instId, Region region, Reason reason) -{ - 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 */ - /** * @brief Scheduler All Apis initialized. * @@ -150,28 +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); } - + + /* 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"); @@ -381,7 +345,7 @@ 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; schFillSlotConfig(cell, schCellCfg->tddCfg); for(slotIdx = cell->numSlotsInPeriodicity-1; slotIdx >= 0; slotIdx--) @@ -434,7 +398,7 @@ void fillSsbStartSymb(SchCellCb *cellCb) { uint8_t cnt, scs, symbIdx, ssbStartSymbArr[SCH_MAX_SSB_BEAM]; - scs = cellCb->cellCfg.scsCommon; + scs = cellCb->cellCfg.ssbScs; memset(ssbStartSymbArr, 0, sizeof(SCH_MAX_SSB_BEAM)); symbIdx = 0; @@ -496,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) @@ -506,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: { @@ -534,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); @@ -795,7 +764,7 @@ uint8_t SchProcCellCfgReq(Pst *pst, SchCellCfg *schCellCfg) cellCb->macInst = pst->srcInst; /* derive the SIB1 config parameters */ - ret = fillSchSib1Cfg(schCellCfg->numerology, schCellCfg->dlBandwidth, cellCb->numSlots, + ret = fillSchSib1Cfg(cellCb->numerology, schCellCfg->dlBandwidth, cellCb->numSlots, &(schCellCfg->pdcchCfgSib1), &(cellCb->sib1SchCfg), schCellCfg->phyCellId, schCellCfg->dlCfgCommon.schFreqInfoDlSib.offsetToPointA, schCellCfg->sib1PduLen); @@ -1417,6 +1386,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); @@ -1551,6 +1524,10 @@ 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); @@ -2529,6 +2506,592 @@ uint8_t SchProcPhrInd(Pst *pst, SchPwrHeadroomInd *schPhrInd) 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] Statistics request from MAC + * Cause of rejection + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t schAddToKpiActiveList(Inst inst, SchStatsGrp *grpInfo) +{ + CmLList *node = NULLP; + + /* If DL Total PRB Usage configured for this stats group, add to list */ + if(grpInfo->kpiStats.dlTotalPrbUsage) + { + SCH_ALLOC(node, sizeof(CmLList)); + if(node) + { + node->node = (PTR)grpInfo->kpiStats.dlTotalPrbUsage; + cmLListAdd2Tail(&schCb[inst].statistics.activeKpiList.dlTotPrbUseList, node); + } + } + + /* If UL Total PRB Usage configured for this stats group, add to list */ + node = NULLP; + if(grpInfo->kpiStats.ulTotalPrbUsage) + { + SCH_ALLOC(node, sizeof(CmLList)); + if(node) + { + node->node = (PTR)grpInfo->kpiStats.ulTotalPrbUsage; + cmLListAdd2Tail(&schCb[inst].statistics.activeKpiList.ulTotPrbUseList, node); + } + } + + 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. + * A timer is started for this group. 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) +{ + uint8_t grpIdx = 0, reqGrpIdx = 0, reqMeasIdx = 0; + Inst inst = pst->dstInst - SCH_INST_START; + bool measTypeInvalid; + CauseOfResult cause; + SchStatsInfo *statsInfo = NULLP; + SchStatsGrpInfo *grpInfo = NULLP; + SchStatsGrp *grpInfoDb = NULLP; + SchStatsRsp schStatsRsp; + + DU_LOG("\nINFO --> SCH : Received Statistics Request from MAC"); + + if(statsReq == NULLP) + { + DU_LOG("\nERROR --> SCH : SchProcStatsReq(): Received Null pointer"); + return RFAILED; + } + + /* [Step 1] Basic validation. If fails, all stats group in stats request are rejected */ + + /* If maximum number of statistics already configured */ + if(schCb[inst].statistics.numOfStatsCfgd >= MAX_NUM_STATS_CFG) + { + 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] Traverse all stats group and validate each measurement types in each group */ + statsInfo = &schCb[inst].statistics.statsInfoList[schCb[inst].statistics.numOfStatsCfgd]; + statsInfo->numStatsGroup = 0; + for(reqGrpIdx=0; reqGrpIdxnumStatsGroup && grpIdxstatsGrpList[reqGrpIdx]; + grpInfoDb = &statsInfo->statsGrpList[grpIdx]; + for(reqMeasIdx = 0; reqMeasIdx < grpInfo->numStats; reqMeasIdx++) + { + switch(grpInfo->statsList[reqMeasIdx]) + { + case SCH_DL_TOTAL_PRB_USAGE: + { + /* Allocate memory */ + SCH_ALLOC(grpInfoDb->kpiStats.dlTotalPrbUsage, sizeof(TotalPrbUsage)); + if(!grpInfoDb->kpiStats.dlTotalPrbUsage) + { + DU_LOG("\nERROR --> SCH : Memory allocation failed for dlTotalPrbUsage in \ + SchProcStatsReq()"); + measTypeInvalid = true; + cause = RESOURCE_UNAVAILABLE; + } + break; + } + + case SCH_UL_TOTAL_PRB_USAGE: + { + /* Allocate memory */ + SCH_ALLOC(grpInfoDb->kpiStats.ulTotalPrbUsage, sizeof(TotalPrbUsage)); + if(!grpInfoDb->kpiStats.ulTotalPrbUsage) + { + DU_LOG("\nERROR --> SCH : Memory allocation failed for dlTotalPrbUsage in \ + SchProcStatsReq()"); + measTypeInvalid = true; + cause = RESOURCE_UNAVAILABLE; + } + break; + } + + default: + { + DU_LOG("\nERROR --> SCH : SchProcStatsReq: Invalid measurement type [%d]", \ + grpInfo->statsList[reqMeasIdx]); + measTypeInvalid = true; + cause = PARAM_INVALID; + break; + } + } + + /* [Step 3 a] If any measurement type validation fails in a group, that group + * is not configured */ + if(measTypeInvalid) + { + SCH_FREE(grpInfoDb->kpiStats.dlTotalPrbUsage, sizeof(TotalPrbUsage)); + SCH_FREE(grpInfoDb->kpiStats.ulTotalPrbUsage, sizeof(TotalPrbUsage)); + memset(grpInfoDb, 0, sizeof(SchStatsGrp)); + break; + } + } + + /* [Step 4] If a group passes all validation, it is added to SCH database. + * A timer is started for this group. And the group is added to + * stats-group-accepted-list in sch-stats-response message. */ + if(!measTypeInvalid) + { + /* Add this group's configured KPIs to list of Active KPIs */ + if(schAddToKpiActiveList(inst, grpInfoDb) == ROK) + { + grpInfoDb->schInst = inst; + grpInfoDb->subscriptionId = statsReq->subscriptionId; + grpInfoDb->groupId = grpInfo->groupId; + grpInfoDb->periodicity = grpInfo->periodicity; + + + /* Start timer */ + cmInitTimers(&(grpInfoDb->periodTimer), 1); + schStartTmr(&schCb[inst], (PTR)(grpInfoDb), EVENT_STATISTICS_TMR, grpInfoDb->periodicity); + + schStatsRsp.statsGrpAcceptedList[schStatsRsp.numGrpAccepted] = grpInfo->groupId; + schStatsRsp.numGrpAccepted++; + grpIdx++; + } + else + { + memset(grpInfoDb, 0, sizeof(SchStatsGrp)); + } + } + else + { + /* [Step 3 b] The rejected group is added to stats-group-rejected-list in + * sch-stats-response message */ + memset(grpInfoDb, 0, sizeof(SchStatsGrp)); + schStatsRsp.statsGrpRejectedList[schStatsRsp.numGrpRejected].groupId = grpInfo->groupId; + schStatsRsp.statsGrpRejectedList[schStatsRsp.numGrpRejected].cause = cause; + schStatsRsp.numGrpRejected++; + } + } + statsInfo->numStatsGroup = grpIdx; + if(statsInfo->numStatsGroup) + { + schCb[inst].statistics.numOfStatsCfgd++; + } + else + { + memset(statsInfo, 0, sizeof(SchStatsInfo)); + } + schStatsRsp.subscriptionId = statsReq->subscriptionId; + + SCH_FREE(statsReq, sizeof(SchStatsReq)); + + /* [Step 5] sch-stats-response is sent to du app with stats-group-rejected-list + * and stats-group-accepted-list. */ + SchSendStatsRspToMac(&schStatsRsp); + + return ROK; +} /* End of SchProcStatsReq */ + +/******************************************************************* + * + * @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 Fill and send Statistics Delete Response to MAC + * + * @details + * + * Function : SchSendStatsDeleteRspToMac + * + * Functionality: Fill and send Statistics Delete Response to MAC + * + * @params[in] + * Statistics Delete Request from MAC + * Statistics Delete result + * Cause of response + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t SchSendStatsDeleteRspToMac(SchStatsDeleteReq *statsDeleteReq, SchMacRsp rsp, CauseOfResult cause) +{ + Pst rspPst; + uint8_t ret = ROK; + SchStatsDeleteRsp *schStatsDeleteRsp; + + DU_LOG("\nINFO --> SCH : Filling Statistics Delete Response"); + SCH_ALLOC(schStatsDeleteRsp, sizeof(SchStatsDeleteRsp)); + if(schStatsDeleteRsp == NULLP) + { + DU_LOG("\nERROR --> SCH : Failed to allocate memory in SchSendStatsDeleteRspToMac()"); + return RFAILED; + } + + schStatsDeleteRsp->subscriptionId=statsDeleteReq->subscriptionId; + schStatsDeleteRsp->rsp=rsp; + schStatsDeleteRsp->cause=cause; + /* Filling response post */ + 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 : SchSendStatsDeleteRspToMac(): Failed to send Statistics Response"); + return ret; + } + return ret; +} + +/******************************************************************* + * + * @brief Delete statistics information + * + * @details + * + * Function : deleteStatsInfo + * + * Functionality: + * Delete statistics information + * + * @params[in] + * Instance + * Subscription id + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t deleteStatsInfo(Inst inst, uint64_t subscriptionId) +{ + bool statsFound=false; + uint8_t idx=0, statsGrpIdx=0; + SchStatsGrp *statsGrpInfo=NULLP; + + if(schCb[inst].statistics.numOfStatsCfgd) + { + for(idx=0;idxsubscriptionId ==subscriptionId) + { + SCH_FREE(statsGrpInfo->kpiStats.dlTotalPrbUsage, sizeof(TotalPrbUsage)); + 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)); + statsFound = true; + } + } + } + } + + if(statsFound ==false) + { + DU_LOG("\nERROR --> SCH : SchProcStatsDeleteReq(): Statistics information is not present"); + return RFAILED; + } + 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) +{ + uint8_t ret =ROK; + 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; + } + + ret = deleteStatsInfo(inst, statsDeleteReq->subscriptionId); + if(ret == ROK) + { + SchSendStatsDeleteRspToMac(statsDeleteReq, RSP_OK, SUCCESSFUL); + } + else + { + SchSendStatsDeleteRspToMac(statsDeleteReq, RSP_NOK, STATS_ID_NOT_FOUND); + } + SCH_FREE(statsDeleteReq, sizeof(SchStatsDeleteReq)); + + return ret; +} /* End of SchProcStatsDeleteReq */ + /********************************************************************** End of file **********************************************************************/