1 /*******************************************************************************
2 ################################################################################
3 # Copyright (c) [2017-2019] [Radisys] #
5 # Licensed under the Apache License, Version 2.0 (the "License"); #
6 # you may not use this file except in compliance with the License. #
7 # You may obtain a copy of the License at #
9 # http://www.apache.org/licenses/LICENSE-2.0 #
11 # Unless required by applicable law or agreed to in writing, software #
12 # distributed under the License is distributed on an "AS IS" BASIS, #
13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
14 # See the License for the specific language governing permissions and #
15 # limitations under the License. #
16 ################################################################################
17 *******************************************************************************/
19 /************************************************************************
25 Desc: C source code for L2 Measurement fucntions
29 **********************************************************************/
31 /** @file rg_sch_l2m.c
32 @brief This file implements the L2 Measurement feature code.
35 /* header include files -- defines (.h) */
36 #include "common_def.h"
43 #include "rg_sch_cmn.h"
44 #include "rg_sch_inf.h" /* typedefs for Scheduler */
45 #include "rg_sch_err.h"
47 /* header/extern include files (.x) */
48 #include "tfu.x" /* TFU types */
49 #include "lrg.x" /* layer management typedefs for MAC */
50 #include "rgr.x" /* layer management typedefs for MAC */
51 #include "rgm.x" /* layer management typedefs for MAC */
52 #include "rg_sch_inf.x" /* typedefs for Scheduler */
53 #include "rg_sch.x" /* typedefs for Scheduler */
54 #include "rg_sch_cmn.x" /* typedefs for Scheduler */
60 static S16 rgSchL2mInsertMeasCb ARGS((
62 RgSchL2MeasCb *measCb,
63 LrgSchMeasReqInfo *measInfo ));
65 static RgSchL2MeasCb * rgSchL2mAllocMeasCb ARGS((
67 LrgSchMeasReqInfo *measInfo,
70 /* Function definitions */
72 /** @brief This function fills the L2 measurement confirm structure
76 * Function: rgSchFillL2MeasCfm
78 * @param [in] RgSchCellCb *cell
79 * @param [in] RgSchL2MeasCb *measCb
80 * @param [out] LrgSchMeasCfmInfo *measCfm
81 * @param [in] measTime
84 S16 rgSchFillL2MeasCfm
87 RgSchL2MeasCb *measCb,
88 LrgSchMeasCfmInfo *cfm,
93 LrgSchMeasReqInfo *measInfo;
97 measInfo = &measCb->measReq;
99 cfm->hdr.transId = measInfo->hdr.transId;
100 cfm->measType = measInfo->measType;
101 cfm->cellId = measInfo->cellId;
102 cfm->cfm.status = LCM_PRIM_OK;
103 if((measCb->measReq.measType & LRG_L2MEAS_AVG_PRB_DL) &&
106 cfm->avgPrbDl.prbPerc = ((cell->avgPrbDl.prbCount * 100) /
108 /* Resetting the prbCount to 0, fix for ccpu00125002 */
109 cell->avgPrbDl.prbCount = 0;
111 if((measCb->measReq.measType & LRG_L2MEAS_AVG_PRB_UL) &&
114 cfm->avgPrbUl.prbPerc = ((cell->avgPrbUl.prbCount * 100) /
116 /* Resetting the prbCount to 0, fix for ccpu00125002 */
117 cell->avgPrbUl.prbCount = 0;
119 if((measCb->measReq.measType & LRG_L2MEAS_AVG_PRB_PER_QCI_DL) &&
122 cfm->avgPrbQciDlCfm.numQci = measCb->measReq.avgPrbQciDl.numQci;
123 for(idx = 0; idx < measCb->measReq.avgPrbQciDl.numQci; idx++)
125 qciVal = measCb->measReq.avgPrbQciDl.qci[idx];
126 cfm->avgPrbQciDlCfm.prbPercQci[idx].prbPercQci =
127 ((cell->qciArray[qciVal].dlPrbCount * 100) /
129 cfm->avgPrbQciDlCfm.prbPercQci[idx].qciValue = qciVal;
130 cell->qciArray[qciVal].dlPrbCount = 0;
133 if((measCb->measReq.measType & LRG_L2MEAS_AVG_PRB_PER_QCI_UL) &&
136 cfm->avgPrbQciUlCfm.numQci = measCb->measReq.avgPrbQciUl.numQci;
137 for(idx = 0; idx < measCb->measReq.avgPrbQciUl.numQci; idx++)
139 cfm->avgPrbQciUlCfm.prbPercQci[idx].qciValue =
140 measCb->avgPrbQciUl.prbUsage[idx].qciValue;
142 if(measCb->avgPrbQciUl.prbUsage[idx].prbUsage > measCb->ulTotalBw)
144 measCb->avgPrbQciUl.prbUsage[idx].prbUsage = measCb->ulTotalBw;
147 cfm->avgPrbQciUlCfm.prbPercQci[idx].prbPercQci =
148 ((measCb->avgPrbQciUl.prbUsage[idx].prbUsage * 100) /
152 if(measCb->measReq.measType & LRG_L2MEAS_RA_PREAMBLE)
154 cfm->raPrmbsCfm.dedPreambles = cell->raPrmbs.dedPream;
155 cfm->raPrmbsCfm.randSelPreLowRange = cell->raPrmbs.preamGrpA;
156 cfm->raPrmbsCfm.randSelPreHighRange = cell->raPrmbs.preamGrpB;
157 cell->raPrmbs.dedPream = 0;
158 cell->raPrmbs.preamGrpA = 0;
159 cell->raPrmbs.preamGrpB = 0;
161 if(measCb->measReq.measType & LRG_L2MEAS_NMB_ACTV_UE_PER_QCI_DL)
163 cfm->numUeQciDlCfm.numQci = measInfo->nmbActvUeQciDl.numQci;
164 sampOc = (measTime / measInfo->nmbActvUeQciDl.sampPrd);
168 if (measCb->measReq.nmbActvUeQciDl.numQci)
170 for(idx = 0; idx < measCb->measReq.nmbActvUeQciDl.numQci; idx++)
172 qciVal = measCb->measReq.nmbActvUeQciDl.qci[idx];
174 cell->qciArray[qciVal].dlTotal_UeCount +=
175 cell->qciArray[qciVal].dlUeCount;
176 cfm->numUeQciDlCfm.numActvUeQci[idx].numActvUeQci =
177 cell->qciArray[qciVal].dlTotal_UeCount / sampOc;
178 cfm->numUeQciDlCfm.numActvUeQci[idx].qciValue = qciVal;
180 DU_LOG("\nDEBUG --> SCH : L2_MEAS:CFM DL QCI %u TOTAL Count %lu Active UE %d ",
181 qciVal,cell->qciArray[qciVal].dlTotal_UeCount,
182 cfm->numUeQciDlCfm.numActvUeQci[idx].numActvUeQci);
184 cell->qciArray[qciVal].dlTotal_UeCount = 0;
190 for(qciVal = 1; qciVal < LRG_MAX_QCI_PER_REQ; qciVal++)
193 cell->qciArray[qciVal].dlTotal_UeCount +=
194 cell->qciArray[qciVal].dlUeCount;
195 if (cell->qciArray[qciVal].dlTotal_UeCount)
197 cfm->numUeQciDlCfm.numActvUeQci[idx].numActvUeQci =
198 cell->qciArray[qciVal].dlTotal_UeCount / sampOc;
199 cfm->numUeQciDlCfm.numActvUeQci[idx].qciValue = qciVal;
201 DU_LOG("\nDEBUG --> SCH : L2_MEAS:CFM DL QCI %u TOTAL Count %lu Active UE %d ",
202 qciVal,cell->qciArray[qciVal].dlTotal_UeCount,
203 cfm->numUeQciDlCfm.numActvUeQci[idx].numActvUeQci);
205 cell->qciArray[qciVal].dlTotal_UeCount = 0;
209 cfm->numUeQciDlCfm.numQci = idx;
213 if(measCb->measReq.measType & LRG_L2MEAS_NMB_ACTV_UE_PER_QCI_UL)
215 cfm->numUeQciUlCfm.numQci = measInfo->nmbActvUeQciUl.numQci;
216 sampOc = (measTime / measInfo->nmbActvUeQciUl.sampPrd);
221 if (measCb->measReq.nmbActvUeQciUl.numQci)
223 for(idx = 0; idx < measCb->measReq.nmbActvUeQciUl.numQci; idx++)
225 cell->qciArray[qciVal].ulTotal_UeCount +=
226 cell->qciArray[qciVal].ulUeCount;
227 qciVal = measCb->measReq.nmbActvUeQciUl.qci[idx];
228 cfm->numUeQciUlCfm.numActvUeQci[idx].numActvUeQci =
229 cell->qciArray[qciVal].ulTotal_UeCount/ sampOc;
230 cfm->numUeQciUlCfm.numActvUeQci[idx].qciValue = qciVal;
232 DU_LOG("\nDEBUG --> SCH : L2_MEAS:CFM UL QCI %d TOTAL Count %lu Active UE %d ",
233 qciVal,cell->qciArray[qciVal].ulTotal_UeCount,
234 cfm->numUeQciUlCfm.numActvUeQci[idx].numActvUeQci);
236 cell->qciArray[qciVal].ulTotal_UeCount = 0;
242 for(qciVal = 1; qciVal < LRG_MAX_QCI_PER_REQ; qciVal++)
244 cell->qciArray[qciVal].ulTotal_UeCount +=
245 cell->qciArray[qciVal].ulUeCount;
246 if (cell->qciArray[qciVal].ulTotal_UeCount)
248 cfm->numUeQciUlCfm.numActvUeQci[idx].numActvUeQci =
249 cell->qciArray[qciVal].ulTotal_UeCount/ sampOc;
250 cfm->numUeQciUlCfm.numActvUeQci[idx].qciValue = qciVal;
252 DU_LOG("\nDEBUG --> SCH : L2_MEAS:CFM UL QCI %d TOTAL Count %lu Active UE %d ",
253 qciVal,cell->qciArray[qciVal].ulTotal_UeCount,
254 cfm->numUeQciUlCfm.numActvUeQci[idx].numActvUeQci);
256 cell->qciArray[qciVal].ulTotal_UeCount = 0;
260 cfm->numUeQciUlCfm.numQci = idx;
264 if(measCb->measReq.measType & LRG_L2MEAS_TB_TRANS_DL_COUNT)
266 cfm->tbTransDlTotalCnt = cell->dlUlTbCnt.tbTransDlTotalCnt;
267 cell->dlUlTbCnt.tbTransDlTotalCnt = 0;
269 if(measCb->measReq.measType & LRG_L2MEAS_TB_TRANS_DL_FAULTY_COUNT)
271 cfm->tbTransDlFaulty = cell->dlUlTbCnt.tbTransDlFaulty;
272 cell->dlUlTbCnt.tbTransDlFaulty = 0;
274 if(measCb->measReq.measType & LRG_L2MEAS_TB_TRANS_UL_COUNT)
276 cfm->tbTransUlTotalCnt = cell->dlUlTbCnt.tbTransUlTotalCnt;
277 cell->dlUlTbCnt.tbTransUlTotalCnt = 0;
279 if(measCb->measReq.measType & LRG_L2MEAS_TB_TRANS_UL_FAULTY_COUNT)
281 cfm->tbTransUlFaulty = cell->dlUlTbCnt.tbTransUlFaulty;
282 cell->dlUlTbCnt.tbTransUlFaulty = 0;
285 measCb->dlTotalBw = 0;
286 measCb->ulTotalBw = 0;
289 } /* rgSchFillL2MeasCfm */
291 /** @brief This function sends the L2 measurement confirm to LM
296 * Function: rgSchL2mSndCfm
298 * @param [in] Pst *pst
299 * @param [in] RgSchL2MeasCb *measCb
300 * @param [in] Bool isErr
306 RgSchL2MeasCb *measCb,
307 LrgSchMeasReqInfo *measInfo,
311 LrgSchMeasCfmInfo cfm;
313 memset(&cfm, 0, sizeof(LrgSchMeasCfmInfo));
314 cfm.hdr.transId = measInfo->hdr.transId;
315 cfm.measType = measInfo->measType;
316 cfm.cellId = measInfo->cellId;
317 cfm.cfm.status = LCM_PRIM_OK;
320 cfm.cfm.status = LCM_PRIM_NOK;
321 cfm.cfm.reason = LCM_REASON_INVALID_PAR_VAL;
322 RgMiLrgSchL2MeasCfm(pst, &cfm);
326 } /* rgSchL2mSndCfm */
328 /** @brief This function fills the LM confirmation pst structure
332 * Function: rgSchL2mFillCfmPst
334 * @param [in] Pst *pst
335 * @param [out] Pst *cfmPst
336 * @param [in] LrgSchMeasReqInfo *measInfo
339 Void rgSchL2mFillCfmPst
343 LrgSchMeasReqInfo *measInfo
347 cfmPst->srcEnt = pst->dstEnt;
348 cfmPst->srcInst = pst->dstInst;
349 cfmPst->srcProcId = pst->dstProcId;
350 cfmPst->dstEnt = pst->srcEnt;
351 cfmPst->dstInst = pst->srcInst;
352 cfmPst->dstProcId = pst->srcProcId;
354 cfmPst->selector = measInfo->hdr.response.selector;
355 cfmPst->prior = measInfo->hdr.response.prior;
356 cfmPst->route = measInfo->hdr.response.route;
357 cfmPst->region = measInfo->hdr.response.mem.region;
358 cfmPst->pool = measInfo->hdr.response.mem.pool;
361 } /* rgSchL2mFillCfmPst */
363 /** @brief This function inserts the MeasCb in to data base
367 * Function: rgSchL2mInsertMeasCb
369 * @param [in] RgSchCellCb *cell
370 * @param [in] RgSchL2MeasCb *measCb
371 * @param [in] LrgSchMeasReqInfo *measInfo
376 static S16 rgSchL2mInsertMeasCb
379 RgSchL2MeasCb *measCb,
380 LrgSchMeasReqInfo *measInfo
384 RgSchL2MeasCb *oldMeasCb;
388 * 1. Check if l2mList has any entries.
390 * 1. Take the first entrie's time period and find the diff with
392 * 2. If the diff is > measInfo->timePeriod then insert before this
394 * 3. Else take the next entry in list
395 * 4. If reached without adding to list . Append at the end of list.
396 * 3. If no entries in l2mList add at the first.
398 lnk = cell->l2mList.first;
399 node = &measCb->measLnk;
400 node->node = (PTR)measCb;
403 oldMeasCb = (RgSchL2MeasCb *)lnk->node;
404 diffTime = (oldMeasCb->measReq.timePrd -
405 (RGSCH_CALC_SF_DIFF(cell->crntTime, oldMeasCb->startTime)));
406 if (diffTime > measInfo->timePrd)
408 cell->l2mList.crnt = lnk;
409 cmLListInsCrnt(&(cell->l2mList), node);
417 cmLListAdd2Tail(&(cell->l2mList), node);
419 } /* rgSchL2mInsertMeasCb */
421 /** @brief This function calculates the Down link prb count
426 * Function: rgSchL2CalDlPrbCount
428 * @param [in] RgSchCellCb *cell
430 static Void rgSchL2CalDlPrbCount(RgSchCellCb *cell)
433 RgSchDlSf *sf = NULLP;
438 frm = cell->crntTime;
439 RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
440 sf = rgSCHUtlSubFrmGet(cell, frm);
442 idx = (cell->crntTime.slot + RG_SCH_CMN_DL_DELTA) %
443 RGSCH_NUM_SUB_FRAMES;
444 if(RG_SCH_CMN_CHK_DL_DATA_ALLOWED(cell, idx))
446 cell->avgPrbDl.prbCount += sf->bwAssigned;
447 dlPrbCnt += sf->bwAssigned;
450 cell->avgPrbDl.prbCount += sf->bwAssigned;
455 /** @brief This function calculates the up link prb count
460 * Function: rgSchL2CalUlPrbCount
462 * @param [in] RgSchCellCb *cell
464 static Void rgSchL2CalUlPrbCount(RgSchCellCb *cell)
466 RgSchUlSf *sf = NULLP;
467 RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
473 idx = cellUl->schdIdx;
474 if(idx < cellUl->numUlSubfrms)
476 sf = &cellUl->ulSfArr[idx];
477 cell->avgPrbUl.prbCount += sf->totPrb;
480 sf = &cellUl->ulSfArr[cellUl->schdIdx];
481 cell->avgPrbUl.prbCount += sf->totPrb;
485 /** @brief This function allocates memory from the heap
489 * Function: rgSchL2mAllocMeasCb
491 * @param [in] RgSchCellCb *cell
492 * @param [in] RgSchL2MeasCb *measInfo
493 * @param [out] RgSchErrInfo *err
494 * @return RgSchL2MeasCb *
496 static RgSchL2MeasCb * rgSchL2mAllocMeasCb
499 LrgSchMeasReqInfo *measInfo,
503 RgSchL2MeasCb *measCb = NULLP;
504 Inst inst = cell->instIdx;
507 if((rgSCHUtlAllocSBuf(inst, (Data **)&measCb,
508 sizeof(RgSchL2MeasCb))) == RFAILED)
510 DU_LOG("\nERROR --> SCH : Allocation of RgSchL2MeasCb failed");
513 memcpy(&measCb->measReq, measInfo, sizeof(LrgSchMeasReqInfo));
514 RGSCHCPYTIMEINFO(cell->crntTime, measCb->startTime);
516 measCb->dlTotalBw = 0;
517 measCb->ulTotalBw = 0;
520 } /* rgSchL2mAllocMeasCb */
523 * @brief Layer Manager Measurement request handler.
527 * Function : rgSchL2mMeasReq
529 * This function handles measurement request received at scheduler instance
530 * from the Layer Manager.
531 * -# Measurement request will be stored in the list in ascending order of
534 * @param[in] Pst *pst, the post structure
535 * @param[in] LrgSchMeasReqInfo *measInfo, the measurement request structure
536 * @param[out] RgSchErrInfo *err, error information
544 LrgSchMeasReqInfo *measInfo,
548 RgSchL2MeasCb *measCb;
554 if ((measCb = rgSchL2mAllocMeasCb(cell, measInfo, err)) == NULLP)
556 RGSCHFILLERR(err, RGSCHERR_L2M_MEASREQ,
557 RGSCHERR_SCH_ALLOC_FAILED);
558 DU_LOG("\nERROR --> SCH : Allocation of RgSchL2MeasCb failed");
561 /*memcpy(&measCb->measReq, measInfo,\
562 sizeof(LrgSchMeasReqInfo));*/
563 rgSchL2mInsertMeasCb(cell, measCb, measInfo);
565 if (measInfo->timePrd == 0)
567 cell->sndL2Meas = FALSE;
568 if (measInfo->measType & LRG_L2MEAS_AVG_PRB_PER_QCI_DL)
570 for (idx = 0; idx < measInfo->avgPrbQciDl.numQci; idx++)
572 qciVal = measInfo->avgPrbQciDl.qci[idx];
573 cell->qciArray[qciVal].qci = qciVal;
576 if (measInfo->measType & LRG_L2MEAS_NMB_ACTV_UE_PER_QCI_DL)
578 for (idx = 0; idx < measInfo->nmbActvUeQciDl.numQci; idx++)
580 qciVal = measInfo->nmbActvUeQciDl.qci[idx];
581 cell->qciArray[qciVal].qci = qciVal;
584 if (measInfo->measType & LRG_L2MEAS_NMB_ACTV_UE_PER_QCI_UL)
586 for (idx = 0; idx < measInfo->nmbActvUeQciUl.numQci; idx++)
588 qciVal = measInfo->nmbActvUeQciUl.qci[idx];
589 cell->qciArray[qciVal].qci = qciVal;
593 /* Here post the message to MAC */
594 if(measInfo->measType & LRG_L2MEAS_AVG_PRB_PER_QCI_UL)
596 RgInfL2MeasReq measReq;
598 memset(&measReq, 0, sizeof(RgInfL2MeasReq));
599 measReq.transId = measInfo->hdr.transId;
600 measReq.measType = measInfo->measType;
601 measReq.timePrd = measInfo->timePrd;
602 measReq.cellId = measInfo->cellId;
603 measReq.t.prbReq.numQci = measInfo->avgPrbQciUl.numQci;
604 for (idx = 0; idx < measInfo->avgPrbQciUl.numQci; idx++)
606 measReq.t.prbReq.qci[idx] = measInfo->avgPrbQciUl.qci[idx];
608 /* Send measReq to MAC */
609 rgSCHUtlGetPstToLyr(&pst, &rgSchCb[cell->instIdx], cell->macInst);
610 RgSchMacL2Meas(&pst, &measReq);
613 } /* rgSchL2mMeasReq */
616 * @brief This function calculates the measurement for differnt measurement type
617 * and send the end result to the layer manager
621 * Function : rgSCHL2Meas
623 * @param[in] RgSchCellCb *cell
634 CmLList *node = NULLP;
635 RgSchL2MeasCb *measCb = NULLP;
637 LrgSchMeasCfmInfo measCfm;
643 Bool isDlDataAllowed;
649 node = cell->l2mList.first;
650 memset(&measCfm, 0, sizeof(LrgSchMeasCfmInfo));
653 measCb = (RgSchL2MeasCb *)node->node;
655 if(cell->crntTime.sfn == 1023 && cell->crntTime.slot == 9)
657 /*calculates diff between crnt time and start time*/
658 meas = RGSCH_CALC_SFN_SF_DIFF(cell->crntTime,
659 measCb->sfnCycle, measCb->startTime);
664 /*calculates diff between crnt time and start time*/
665 meas = RGSCH_CALC_SFN_SF_DIFF(cell->crntTime,
666 measCb->sfnCycle, measCb->startTime);
669 if (cell->sndL2Meas || meas == measCb->measReq.timePrd)
672 rem = meas % RGSCH_NUM_SUB_FRAMES;
673 /* Get the total number of DL and UL subframes within the reporting period*/
674 numDlSf = (meas / RGSCH_NUM_SUB_FRAMES) * rgSchTddNumDlSubfrmTbl[cell->ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
675 numUlSf = (meas / RGSCH_NUM_SUB_FRAMES) * rgSchTddNumUlSubfrmTbl[cell->ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
677 sfIdx = (measCb->startTime.slot + 1) % RGSCH_NUM_SUB_FRAMES;
681 isDlDataAllowed = RG_SCH_CMN_CHK_DL_DATA_ALLOWED(cell, sfIdx);
686 else if(rgSchTddUlDlSubfrmTbl[cell->ulDlCfgIdx][sfIdx] ==
687 RG_SCH_TDD_UL_SUBFRAME)
691 sfIdx = (sfIdx + 1) % RGSCH_NUM_SUB_FRAMES;
695 measCb->dlTotalBw = numDlSf * cell->bwCfg.dlTotalBw;
696 measCb->ulTotalBw = numUlSf * cell->bwCfg.ulTotalBw;
699 measCb->dlTotalBw = meas * cell->bwCfg.dlTotalBw;
700 measCb->ulTotalBw = meas * cell->bwCfg.ulTotalBw;
702 if((measCb->measReq.measType & LRG_L2MEAS_AVG_PRB_PER_QCI_UL))
706 rgSchFillL2MeasCfm(cell, measCb, &measCfm, meas);
715 rgSchFillL2MeasCfm(cell, measCb, &measCfm, meas);
717 RgMiLrgSchL2MeasCfm(&(rgSchCb[cell->instIdx].rgSchInit.lmPst),
719 memset(&measCfm, 0, sizeof(LrgSchMeasCfmInfo));
721 /* Delete this measCb from the list */
722 if(measCb->measReq.timePrd > 0)
724 cmLListDelFrm(&cell->l2mList, &measCb->measLnk);
725 rgSCHUtlFreeSBuf(cell->instIdx, (Data **)&measCb,
726 sizeof(RgSchL2MeasCb));
728 else/*do not delete measCb, will use for next measurement*/
730 measCb->startTime = cell->crntTime;
731 measCb->sfnCycle = 0;
732 measCb->cfmRcvd = FALSE;
733 memset(&measCb->avgPrbQciUl, 0, sizeof(LrgAvgPrbQCICfm));
734 cell->sndL2Meas = FALSE;
736 /* ccpu00117052 - MOD - Passing double pointer
737 for proper NULLP assignment*/
741 /* Just update the AVERAGE UL PRB counter here and return
742 * if the caller is CRCIndication() and the UL scheduling happens
744 #ifdef RG_ULSCHED_AT_CRC
747 if(measCb->measReq.measType & LRG_L2MEAS_AVG_PRB_UL)
749 rgSchL2CalUlPrbCount(cell);
754 /* UL PRB counter gets updated as a part of CRC indication
755 * if the UL scheduling happens there */
756 if((measCb->measReq.measType & LRG_L2MEAS_AVG_PRB_UL))
758 rgSchL2CalUlPrbCount(cell);
761 if((measCb->measReq.measType & LRG_L2MEAS_AVG_PRB_DL))
763 rgSchL2CalDlPrbCount(cell);
765 if(measCb->measReq.measType & LRG_L2MEAS_NMB_ACTV_UE_PER_QCI_DL)
767 sfDiff = RGSCH_CALC_SF_DIFF(cell->crntTime, measCb->startTime);
769 if((sfDiff % measCb->measReq.nmbActvUeQciDl.sampPrd) == 0)
771 if (measCb->measReq.nmbActvUeQciDl.numQci)
773 for (idx = 0; idx < measCb->measReq.nmbActvUeQciDl.numQci;
776 qciVal = measCb->measReq.nmbActvUeQciDl.qci[idx];
777 cell->qciArray[qciVal].dlTotal_UeCount +=
778 cell->qciArray[qciVal].dlUeCount;
783 for (qciVal = 1; qciVal < LRG_MAX_QCI_PER_REQ; qciVal++)
785 cell->qciArray[qciVal].dlTotal_UeCount +=
786 cell->qciArray[qciVal].dlUeCount;
791 if(measCb->measReq.measType & LRG_L2MEAS_NMB_ACTV_UE_PER_QCI_UL)
793 sfDiff = RGSCH_CALC_SF_DIFF(cell->crntTime , measCb->startTime);
794 if((sfDiff % measCb->measReq.nmbActvUeQciUl.sampPrd) == 0)
796 if (measCb->measReq.nmbActvUeQciUl.numQci)
798 for (idx = 0; idx < measCb->measReq.nmbActvUeQciUl.numQci;
801 qciVal = measCb->measReq.nmbActvUeQciUl.qci[idx];
802 cell->qciArray[qciVal].ulTotal_UeCount +=
803 cell->qciArray[qciVal].ulUeCount;
808 for (qciVal = 1; qciVal < LRG_MAX_QCI_PER_REQ; qciVal++)
810 cell->qciArray[qciVal].ulTotal_UeCount +=
811 cell->qciArray[qciVal].ulUeCount;
820 #endif /* LTE_L2_MEAS */
821 /**********************************************************************
824 **********************************************************************/