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"
46 #include "rl_interface.h"
47 #include "rl_common.h"
49 /* header/extern include files (.x) */
50 #include "tfu.x" /* TFU types */
51 #include "lrg.x" /* layer management typedefs for MAC */
52 #include "rgr.x" /* layer management typedefs for MAC */
53 #include "rgm.x" /* layer management typedefs for MAC */
54 #include "rg_sch_inf.x" /* typedefs for Scheduler */
55 #include "rg_sch.x" /* typedefs for Scheduler */
56 #include "rg_sch_cmn.x" /* typedefs for Scheduler */
61 static const char* RLOG_MODULE_NAME="MAC";
62 static int RLOG_MODULE_ID=4096;
63 static int RLOG_FILE_ID=166;
65 static S16 rgSchL2mInsertMeasCb ARGS((
67 RgSchL2MeasCb *measCb,
68 LrgSchMeasReqInfo *measInfo ));
70 static RgSchL2MeasCb * rgSchL2mAllocMeasCb ARGS((
72 LrgSchMeasReqInfo *measInfo,
75 /* Function definitions */
77 /** @brief This function fills the L2 measurement confirm structure
81 * Function: rgSchFillL2MeasCfm
83 * @param [in] RgSchCellCb *cell
84 * @param [in] RgSchL2MeasCb *measCb
85 * @param [out] LrgSchMeasCfmInfo *measCfm
86 * @param [in] measTime
89 S16 rgSchFillL2MeasCfm
92 RgSchL2MeasCb *measCb,
93 LrgSchMeasCfmInfo *cfm,
98 LrgSchMeasReqInfo *measInfo;
102 measInfo = &measCb->measReq;
104 cfm->hdr.transId = measInfo->hdr.transId;
105 cfm->measType = measInfo->measType;
106 cfm->cellId = measInfo->cellId;
107 cfm->cfm.status = LCM_PRIM_OK;
108 if((measCb->measReq.measType & LRG_L2MEAS_AVG_PRB_DL) &&
111 cfm->avgPrbDl.prbPerc = ((cell->avgPrbDl.prbCount * 100) /
113 /* Resetting the prbCount to 0, fix for ccpu00125002 */
114 cell->avgPrbDl.prbCount = 0;
116 if((measCb->measReq.measType & LRG_L2MEAS_AVG_PRB_UL) &&
119 cfm->avgPrbUl.prbPerc = ((cell->avgPrbUl.prbCount * 100) /
121 /* Resetting the prbCount to 0, fix for ccpu00125002 */
122 cell->avgPrbUl.prbCount = 0;
124 if((measCb->measReq.measType & LRG_L2MEAS_AVG_PRB_PER_QCI_DL) &&
127 cfm->avgPrbQciDlCfm.numQci = measCb->measReq.avgPrbQciDl.numQci;
128 for(idx = 0; idx < measCb->measReq.avgPrbQciDl.numQci; idx++)
130 qciVal = measCb->measReq.avgPrbQciDl.qci[idx];
131 cfm->avgPrbQciDlCfm.prbPercQci[idx].prbPercQci =
132 ((cell->qciArray[qciVal].dlPrbCount * 100) /
134 cfm->avgPrbQciDlCfm.prbPercQci[idx].qciValue = qciVal;
135 cell->qciArray[qciVal].dlPrbCount = 0;
138 if((measCb->measReq.measType & LRG_L2MEAS_AVG_PRB_PER_QCI_UL) &&
141 cfm->avgPrbQciUlCfm.numQci = measCb->measReq.avgPrbQciUl.numQci;
142 for(idx = 0; idx < measCb->measReq.avgPrbQciUl.numQci; idx++)
144 cfm->avgPrbQciUlCfm.prbPercQci[idx].qciValue =
145 measCb->avgPrbQciUl.prbUsage[idx].qciValue;
147 if(measCb->avgPrbQciUl.prbUsage[idx].prbUsage > measCb->ulTotalBw)
149 measCb->avgPrbQciUl.prbUsage[idx].prbUsage = measCb->ulTotalBw;
152 cfm->avgPrbQciUlCfm.prbPercQci[idx].prbPercQci =
153 ((measCb->avgPrbQciUl.prbUsage[idx].prbUsage * 100) /
157 if(measCb->measReq.measType & LRG_L2MEAS_RA_PREAMBLE)
159 cfm->raPrmbsCfm.dedPreambles = cell->raPrmbs.dedPream;
160 cfm->raPrmbsCfm.randSelPreLowRange = cell->raPrmbs.preamGrpA;
161 cfm->raPrmbsCfm.randSelPreHighRange = cell->raPrmbs.preamGrpB;
162 cell->raPrmbs.dedPream = 0;
163 cell->raPrmbs.preamGrpA = 0;
164 cell->raPrmbs.preamGrpB = 0;
166 if(measCb->measReq.measType & LRG_L2MEAS_NMB_ACTV_UE_PER_QCI_DL)
168 cfm->numUeQciDlCfm.numQci = measInfo->nmbActvUeQciDl.numQci;
169 sampOc = (measTime / measInfo->nmbActvUeQciDl.sampPrd);
173 if (measCb->measReq.nmbActvUeQciDl.numQci)
175 for(idx = 0; idx < measCb->measReq.nmbActvUeQciDl.numQci; idx++)
177 qciVal = measCb->measReq.nmbActvUeQciDl.qci[idx];
179 cell->qciArray[qciVal].dlTotal_UeCount +=
180 cell->qciArray[qciVal].dlUeCount;
181 cfm->numUeQciDlCfm.numActvUeQci[idx].numActvUeQci =
182 cell->qciArray[qciVal].dlTotal_UeCount / sampOc;
183 cfm->numUeQciDlCfm.numActvUeQci[idx].qciValue = qciVal;
185 RLOG_ARG3(L_DEBUG,DBG_CELLID,cell->cellId,
186 "L2_MEAS:CFM DL QCI %u TOTAL Count %lu Active UE %d ",
187 qciVal,cell->qciArray[qciVal].dlTotal_UeCount,
188 cfm->numUeQciDlCfm.numActvUeQci[idx].numActvUeQci);
190 cell->qciArray[qciVal].dlTotal_UeCount = 0;
196 for(qciVal = 1; qciVal < LRG_MAX_QCI_PER_REQ; qciVal++)
199 cell->qciArray[qciVal].dlTotal_UeCount +=
200 cell->qciArray[qciVal].dlUeCount;
201 if (cell->qciArray[qciVal].dlTotal_UeCount)
203 cfm->numUeQciDlCfm.numActvUeQci[idx].numActvUeQci =
204 cell->qciArray[qciVal].dlTotal_UeCount / sampOc;
205 cfm->numUeQciDlCfm.numActvUeQci[idx].qciValue = qciVal;
207 RLOG_ARG3(L_DEBUG,DBG_CELLID,cell->cellId,
208 "L2_MEAS:CFM DL QCI %u TOTAL Count %lu Active UE %d ",
209 qciVal,cell->qciArray[qciVal].dlTotal_UeCount,
210 cfm->numUeQciDlCfm.numActvUeQci[idx].numActvUeQci);
212 cell->qciArray[qciVal].dlTotal_UeCount = 0;
216 cfm->numUeQciDlCfm.numQci = idx;
220 if(measCb->measReq.measType & LRG_L2MEAS_NMB_ACTV_UE_PER_QCI_UL)
222 cfm->numUeQciUlCfm.numQci = measInfo->nmbActvUeQciUl.numQci;
223 sampOc = (measTime / measInfo->nmbActvUeQciUl.sampPrd);
228 if (measCb->measReq.nmbActvUeQciUl.numQci)
230 for(idx = 0; idx < measCb->measReq.nmbActvUeQciUl.numQci; idx++)
232 cell->qciArray[qciVal].ulTotal_UeCount +=
233 cell->qciArray[qciVal].ulUeCount;
234 qciVal = measCb->measReq.nmbActvUeQciUl.qci[idx];
235 cfm->numUeQciUlCfm.numActvUeQci[idx].numActvUeQci =
236 cell->qciArray[qciVal].ulTotal_UeCount/ sampOc;
237 cfm->numUeQciUlCfm.numActvUeQci[idx].qciValue = qciVal;
239 RLOG_ARG3(L_DEBUG,DBG_CELLID,cell->cellId,
240 "L2_MEAS:CFM UL QCI %d TOTAL Count %lu Active UE %d ",
241 qciVal,cell->qciArray[qciVal].ulTotal_UeCount,
242 cfm->numUeQciUlCfm.numActvUeQci[idx].numActvUeQci);
244 cell->qciArray[qciVal].ulTotal_UeCount = 0;
250 for(qciVal = 1; qciVal < LRG_MAX_QCI_PER_REQ; qciVal++)
252 cell->qciArray[qciVal].ulTotal_UeCount +=
253 cell->qciArray[qciVal].ulUeCount;
254 if (cell->qciArray[qciVal].ulTotal_UeCount)
256 cfm->numUeQciUlCfm.numActvUeQci[idx].numActvUeQci =
257 cell->qciArray[qciVal].ulTotal_UeCount/ sampOc;
258 cfm->numUeQciUlCfm.numActvUeQci[idx].qciValue = qciVal;
260 RLOG_ARG3(L_DEBUG,DBG_CELLID,cell->cellId,
261 "L2_MEAS:CFM UL QCI %d TOTAL Count %lu Active UE %d ",
262 qciVal,cell->qciArray[qciVal].ulTotal_UeCount,
263 cfm->numUeQciUlCfm.numActvUeQci[idx].numActvUeQci);
265 cell->qciArray[qciVal].ulTotal_UeCount = 0;
269 cfm->numUeQciUlCfm.numQci = idx;
273 if(measCb->measReq.measType & LRG_L2MEAS_TB_TRANS_DL_COUNT)
275 cfm->tbTransDlTotalCnt = cell->dlUlTbCnt.tbTransDlTotalCnt;
276 cell->dlUlTbCnt.tbTransDlTotalCnt = 0;
278 if(measCb->measReq.measType & LRG_L2MEAS_TB_TRANS_DL_FAULTY_COUNT)
280 cfm->tbTransDlFaulty = cell->dlUlTbCnt.tbTransDlFaulty;
281 cell->dlUlTbCnt.tbTransDlFaulty = 0;
283 if(measCb->measReq.measType & LRG_L2MEAS_TB_TRANS_UL_COUNT)
285 cfm->tbTransUlTotalCnt = cell->dlUlTbCnt.tbTransUlTotalCnt;
286 cell->dlUlTbCnt.tbTransUlTotalCnt = 0;
288 if(measCb->measReq.measType & LRG_L2MEAS_TB_TRANS_UL_FAULTY_COUNT)
290 cfm->tbTransUlFaulty = cell->dlUlTbCnt.tbTransUlFaulty;
291 cell->dlUlTbCnt.tbTransUlFaulty = 0;
294 measCb->dlTotalBw = 0;
295 measCb->ulTotalBw = 0;
298 } /* rgSchFillL2MeasCfm */
300 /** @brief This function sends the L2 measurement confirm to LM
305 * Function: rgSchL2mSndCfm
307 * @param [in] Pst *pst
308 * @param [in] RgSchL2MeasCb *measCb
309 * @param [in] Bool isErr
315 RgSchL2MeasCb *measCb,
316 LrgSchMeasReqInfo *measInfo,
320 LrgSchMeasCfmInfo cfm;
322 memset(&cfm, 0, sizeof(LrgSchMeasCfmInfo));
323 cfm.hdr.transId = measInfo->hdr.transId;
324 cfm.measType = measInfo->measType;
325 cfm.cellId = measInfo->cellId;
326 cfm.cfm.status = LCM_PRIM_OK;
329 cfm.cfm.status = LCM_PRIM_NOK;
330 cfm.cfm.reason = LCM_REASON_INVALID_PAR_VAL;
331 RgMiLrgSchL2MeasCfm(pst, &cfm);
335 } /* rgSchL2mSndCfm */
337 /** @brief This function fills the LM confirmation pst structure
341 * Function: rgSchL2mFillCfmPst
343 * @param [in] Pst *pst
344 * @param [out] Pst *cfmPst
345 * @param [in] LrgSchMeasReqInfo *measInfo
348 Void rgSchL2mFillCfmPst
352 LrgSchMeasReqInfo *measInfo
356 cfmPst->srcEnt = pst->dstEnt;
357 cfmPst->srcInst = pst->dstInst;
358 cfmPst->srcProcId = pst->dstProcId;
359 cfmPst->dstEnt = pst->srcEnt;
360 cfmPst->dstInst = pst->srcInst;
361 cfmPst->dstProcId = pst->srcProcId;
363 cfmPst->selector = measInfo->hdr.response.selector;
364 cfmPst->prior = measInfo->hdr.response.prior;
365 cfmPst->route = measInfo->hdr.response.route;
366 cfmPst->region = measInfo->hdr.response.mem.region;
367 cfmPst->pool = measInfo->hdr.response.mem.pool;
370 } /* rgSchL2mFillCfmPst */
372 /** @brief This function inserts the MeasCb in to data base
376 * Function: rgSchL2mInsertMeasCb
378 * @param [in] RgSchCellCb *cell
379 * @param [in] RgSchL2MeasCb *measCb
380 * @param [in] LrgSchMeasReqInfo *measInfo
385 static S16 rgSchL2mInsertMeasCb
388 RgSchL2MeasCb *measCb,
389 LrgSchMeasReqInfo *measInfo
393 RgSchL2MeasCb *oldMeasCb;
397 * 1. Check if l2mList has any entries.
399 * 1. Take the first entrie's time period and find the diff with
401 * 2. If the diff is > measInfo->timePeriod then insert before this
403 * 3. Else take the next entry in list
404 * 4. If reached without adding to list . Append at the end of list.
405 * 3. If no entries in l2mList add at the first.
407 lnk = cell->l2mList.first;
408 node = &measCb->measLnk;
409 node->node = (PTR)measCb;
412 oldMeasCb = (RgSchL2MeasCb *)lnk->node;
413 diffTime = (oldMeasCb->measReq.timePrd -
414 (RGSCH_CALC_SF_DIFF(cell->crntTime, oldMeasCb->startTime)));
415 if (diffTime > measInfo->timePrd)
417 cell->l2mList.crnt = lnk;
418 cmLListInsCrnt(&(cell->l2mList), node);
426 cmLListAdd2Tail(&(cell->l2mList), node);
428 } /* rgSchL2mInsertMeasCb */
430 /** @brief This function calculates the Down link prb count
435 * Function: rgSchL2CalDlPrbCount
437 * @param [in] RgSchCellCb *cell
439 static Void rgSchL2CalDlPrbCount(RgSchCellCb *cell)
442 RgSchDlSf *sf = NULLP;
447 frm = cell->crntTime;
448 RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
449 sf = rgSCHUtlSubFrmGet(cell, frm);
451 idx = (cell->crntTime.slot + RG_SCH_CMN_DL_DELTA) %
452 RGSCH_NUM_SUB_FRAMES;
453 if(RG_SCH_CMN_CHK_DL_DATA_ALLOWED(cell, idx))
455 cell->avgPrbDl.prbCount += sf->bwAssigned;
456 dlPrbCnt += sf->bwAssigned;
459 cell->avgPrbDl.prbCount += sf->bwAssigned;
464 /** @brief This function calculates the up link prb count
469 * Function: rgSchL2CalUlPrbCount
471 * @param [in] RgSchCellCb *cell
473 static Void rgSchL2CalUlPrbCount(RgSchCellCb *cell)
475 RgSchUlSf *sf = NULLP;
476 RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
482 idx = cellUl->schdIdx;
483 if(idx < cellUl->numUlSubfrms)
485 sf = &cellUl->ulSfArr[idx];
486 cell->avgPrbUl.prbCount += sf->totPrb;
489 sf = &cellUl->ulSfArr[cellUl->schdIdx];
490 cell->avgPrbUl.prbCount += sf->totPrb;
494 /** @brief This function allocates memory from the heap
498 * Function: rgSchL2mAllocMeasCb
500 * @param [in] RgSchCellCb *cell
501 * @param [in] RgSchL2MeasCb *measInfo
502 * @param [out] RgSchErrInfo *err
503 * @return RgSchL2MeasCb *
505 static RgSchL2MeasCb * rgSchL2mAllocMeasCb
508 LrgSchMeasReqInfo *measInfo,
512 RgSchL2MeasCb *measCb = NULLP;
513 Inst inst = cell->instIdx;
516 if((rgSCHUtlAllocSBuf(inst, (Data **)&measCb,
517 sizeof(RgSchL2MeasCb))) == RFAILED)
519 RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSchL2mAllocMeasCb():"
520 "Allocation of RgSchL2MeasCb failed");
523 memcpy(&measCb->measReq, measInfo, sizeof(LrgSchMeasReqInfo));
524 RGSCHCPYTIMEINFO(cell->crntTime, measCb->startTime);
526 measCb->dlTotalBw = 0;
527 measCb->ulTotalBw = 0;
530 } /* rgSchL2mAllocMeasCb */
533 * @brief Layer Manager Measurement request handler.
537 * Function : rgSchL2mMeasReq
539 * This function handles measurement request received at scheduler instance
540 * from the Layer Manager.
541 * -# Measurement request will be stored in the list in ascending order of
544 * @param[in] Pst *pst, the post structure
545 * @param[in] LrgSchMeasReqInfo *measInfo, the measurement request structure
546 * @param[out] RgSchErrInfo *err, error information
554 LrgSchMeasReqInfo *measInfo,
558 RgSchL2MeasCb *measCb;
564 if ((measCb = rgSchL2mAllocMeasCb(cell, measInfo, err)) == NULLP)
566 RGSCHFILLERR(err, RGSCHERR_L2M_MEASREQ,
567 RGSCHERR_SCH_ALLOC_FAILED);
568 RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "rgSchL2mMeasReq():"
569 "Allocation of RgSchL2MeasCb failed");
572 /*memcpy(&measCb->measReq, measInfo,\
573 sizeof(LrgSchMeasReqInfo));*/
574 rgSchL2mInsertMeasCb(cell, measCb, measInfo);
576 if (measInfo->timePrd == 0)
578 cell->sndL2Meas = FALSE;
579 if (measInfo->measType & LRG_L2MEAS_AVG_PRB_PER_QCI_DL)
581 for (idx = 0; idx < measInfo->avgPrbQciDl.numQci; idx++)
583 qciVal = measInfo->avgPrbQciDl.qci[idx];
584 cell->qciArray[qciVal].qci = qciVal;
587 if (measInfo->measType & LRG_L2MEAS_NMB_ACTV_UE_PER_QCI_DL)
589 for (idx = 0; idx < measInfo->nmbActvUeQciDl.numQci; idx++)
591 qciVal = measInfo->nmbActvUeQciDl.qci[idx];
592 cell->qciArray[qciVal].qci = qciVal;
595 if (measInfo->measType & LRG_L2MEAS_NMB_ACTV_UE_PER_QCI_UL)
597 for (idx = 0; idx < measInfo->nmbActvUeQciUl.numQci; idx++)
599 qciVal = measInfo->nmbActvUeQciUl.qci[idx];
600 cell->qciArray[qciVal].qci = qciVal;
604 /* Here post the message to MAC */
605 if(measInfo->measType & LRG_L2MEAS_AVG_PRB_PER_QCI_UL)
607 RgInfL2MeasReq measReq;
609 memset(&measReq, 0, sizeof(RgInfL2MeasReq));
610 measReq.transId = measInfo->hdr.transId;
611 measReq.measType = measInfo->measType;
612 measReq.timePrd = measInfo->timePrd;
613 measReq.cellId = measInfo->cellId;
614 measReq.t.prbReq.numQci = measInfo->avgPrbQciUl.numQci;
615 for (idx = 0; idx < measInfo->avgPrbQciUl.numQci; idx++)
617 measReq.t.prbReq.qci[idx] = measInfo->avgPrbQciUl.qci[idx];
619 /* Send measReq to MAC */
620 rgSCHUtlGetPstToLyr(&pst, &rgSchCb[cell->instIdx], cell->macInst);
621 RgSchMacL2Meas(&pst, &measReq);
624 } /* rgSchL2mMeasReq */
627 * @brief This function calculates the measurement for differnt measurement type
628 * and send the end result to the layer manager
632 * Function : rgSCHL2Meas
634 * @param[in] RgSchCellCb *cell
645 CmLList *node = NULLP;
646 RgSchL2MeasCb *measCb = NULLP;
648 LrgSchMeasCfmInfo measCfm;
654 Bool isDlDataAllowed;
660 node = cell->l2mList.first;
661 memset(&measCfm, 0, sizeof(LrgSchMeasCfmInfo));
664 measCb = (RgSchL2MeasCb *)node->node;
666 if(cell->crntTime.sfn == 1023 && cell->crntTime.slot == 9)
668 /*calculates diff between crnt time and start time*/
669 meas = RGSCH_CALC_SFN_SF_DIFF(cell->crntTime,
670 measCb->sfnCycle, measCb->startTime);
675 /*calculates diff between crnt time and start time*/
676 meas = RGSCH_CALC_SFN_SF_DIFF(cell->crntTime,
677 measCb->sfnCycle, measCb->startTime);
680 if (cell->sndL2Meas || meas == measCb->measReq.timePrd)
683 rem = meas % RGSCH_NUM_SUB_FRAMES;
684 /* Get the total number of DL and UL subframes within the reporting period*/
685 numDlSf = (meas / RGSCH_NUM_SUB_FRAMES) * rgSchTddNumDlSubfrmTbl[cell->ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
686 numUlSf = (meas / RGSCH_NUM_SUB_FRAMES) * rgSchTddNumUlSubfrmTbl[cell->ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
688 sfIdx = (measCb->startTime.slot + 1) % RGSCH_NUM_SUB_FRAMES;
692 isDlDataAllowed = RG_SCH_CMN_CHK_DL_DATA_ALLOWED(cell, sfIdx);
697 else if(rgSchTddUlDlSubfrmTbl[cell->ulDlCfgIdx][sfIdx] ==
698 RG_SCH_TDD_UL_SUBFRAME)
702 sfIdx = (sfIdx + 1) % RGSCH_NUM_SUB_FRAMES;
706 measCb->dlTotalBw = numDlSf * cell->bwCfg.dlTotalBw;
707 measCb->ulTotalBw = numUlSf * cell->bwCfg.ulTotalBw;
710 measCb->dlTotalBw = meas * cell->bwCfg.dlTotalBw;
711 measCb->ulTotalBw = meas * cell->bwCfg.ulTotalBw;
713 if((measCb->measReq.measType & LRG_L2MEAS_AVG_PRB_PER_QCI_UL))
717 rgSchFillL2MeasCfm(cell, measCb, &measCfm, meas);
726 rgSchFillL2MeasCfm(cell, measCb, &measCfm, meas);
728 RgMiLrgSchL2MeasCfm(&(rgSchCb[cell->instIdx].rgSchInit.lmPst),
730 memset(&measCfm, 0, sizeof(LrgSchMeasCfmInfo));
732 /* Delete this measCb from the list */
733 if(measCb->measReq.timePrd > 0)
735 cmLListDelFrm(&cell->l2mList, &measCb->measLnk);
736 rgSCHUtlFreeSBuf(cell->instIdx, (Data **)&measCb,
737 sizeof(RgSchL2MeasCb));
739 else/*do not delete measCb, will use for next measurement*/
741 measCb->startTime = cell->crntTime;
742 measCb->sfnCycle = 0;
743 measCb->cfmRcvd = FALSE;
744 memset(&measCb->avgPrbQciUl, 0, sizeof(LrgAvgPrbQCICfm));
745 cell->sndL2Meas = FALSE;
747 /* ccpu00117052 - MOD - Passing double pointer
748 for proper NULLP assignment*/
752 /* Just update the AVERAGE UL PRB counter here and return
753 * if the caller is CRCIndication() and the UL scheduling happens
755 #ifdef RG_ULSCHED_AT_CRC
758 if(measCb->measReq.measType & LRG_L2MEAS_AVG_PRB_UL)
760 rgSchL2CalUlPrbCount(cell);
765 /* UL PRB counter gets updated as a part of CRC indication
766 * if the UL scheduling happens there */
767 if((measCb->measReq.measType & LRG_L2MEAS_AVG_PRB_UL))
769 rgSchL2CalUlPrbCount(cell);
772 if((measCb->measReq.measType & LRG_L2MEAS_AVG_PRB_DL))
774 rgSchL2CalDlPrbCount(cell);
776 if(measCb->measReq.measType & LRG_L2MEAS_NMB_ACTV_UE_PER_QCI_DL)
778 sfDiff = RGSCH_CALC_SF_DIFF(cell->crntTime, measCb->startTime);
780 if((sfDiff % measCb->measReq.nmbActvUeQciDl.sampPrd) == 0)
782 if (measCb->measReq.nmbActvUeQciDl.numQci)
784 for (idx = 0; idx < measCb->measReq.nmbActvUeQciDl.numQci;
787 qciVal = measCb->measReq.nmbActvUeQciDl.qci[idx];
788 cell->qciArray[qciVal].dlTotal_UeCount +=
789 cell->qciArray[qciVal].dlUeCount;
794 for (qciVal = 1; qciVal < LRG_MAX_QCI_PER_REQ; qciVal++)
796 cell->qciArray[qciVal].dlTotal_UeCount +=
797 cell->qciArray[qciVal].dlUeCount;
802 if(measCb->measReq.measType & LRG_L2MEAS_NMB_ACTV_UE_PER_QCI_UL)
804 sfDiff = RGSCH_CALC_SF_DIFF(cell->crntTime , measCb->startTime);
805 if((sfDiff % measCb->measReq.nmbActvUeQciUl.sampPrd) == 0)
807 if (measCb->measReq.nmbActvUeQciUl.numQci)
809 for (idx = 0; idx < measCb->measReq.nmbActvUeQciUl.numQci;
812 qciVal = measCb->measReq.nmbActvUeQciUl.qci[idx];
813 cell->qciArray[qciVal].ulTotal_UeCount +=
814 cell->qciArray[qciVal].ulUeCount;
819 for (qciVal = 1; qciVal < LRG_MAX_QCI_PER_REQ; qciVal++)
821 cell->qciArray[qciVal].ulTotal_UeCount +=
822 cell->qciArray[qciVal].ulUeCount;
831 #endif /* LTE_L2_MEAS */
832 /**********************************************************************
835 **********************************************************************/